blob: d60be83ba78b7efbcc42a878cbee6e6110a1e425 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 SCSI Tape Driver for Linux version 1.1 and newer. See the accompanying
3 file Documentation/scsi/st.txt for more information.
4
5 History:
6 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.
11
Kai Makisarafd66c1b2008-01-17 22:45:22 +020012 Copyright 1992 - 2008 Kai Makisara
Linus Torvalds1da177e2005-04-16 15:20:36 -070013 email Kai.Makisara@kolumbus.fi
14
15 Some small formal changes - aeb, 950809
16
17 Last modified: 18-JAN-1998 Richard Gooch <rgooch@atnf.csiro.au> Devfs support
18 */
19
Kai Makisara626dcb12008-07-11 15:05:25 +030020static const char *verstr = "20080504";
Linus Torvalds1da177e2005-04-16 15:20:36 -070021
22#include <linux/module.h>
23
24#include <linux/fs.h>
25#include <linux/kernel.h>
26#include <linux/sched.h>
27#include <linux/mm.h>
28#include <linux/init.h>
29#include <linux/string.h>
30#include <linux/errno.h>
31#include <linux/mtio.h>
Kai Makisara 16c4b3e2005-05-01 18:11:55 +030032#include <linux/cdrom.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070033#include <linux/ioctl.h>
34#include <linux/fcntl.h>
35#include <linux/spinlock.h>
36#include <linux/blkdev.h>
37#include <linux/moduleparam.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070038#include <linux/cdev.h>
39#include <linux/delay.h>
Arjan van de Ven0b950672006-01-11 13:16:10 +010040#include <linux/mutex.h>
Jonathan Corbetb3369c62008-05-15 16:08:15 -060041#include <linux/smp_lock.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070042
43#include <asm/uaccess.h>
44#include <asm/dma.h>
45#include <asm/system.h>
46
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>
Kai Makisara 16c4b3e2005-05-01 18:11:55 +030054#include <scsi/sg.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070055
56
57/* The driver prints some debugging information on the console if DEBUG
58 is defined and non-zero. */
59#define DEBUG 0
60
61#if DEBUG
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
66#define DEB(a) a
67#define DEBC(a) if (debugging) { a ; }
68#else
69#define DEB(a)
70#define DEBC(a)
71#endif
72
73#define ST_KILOBYTE 1024
74
75#include "st_options.h"
76#include "st.h"
77
78static int buffer_kbs;
79static int max_sg_segs;
80static int try_direct_io = TRY_DIRECT_IO;
81static int try_rdio = 1;
82static int try_wdio = 1;
83
84static int st_dev_max;
85static int st_nr_dev;
86
gregkh@suse.ded2538782005-03-23 09:55:22 -080087static struct class *st_sysfs_class;
Linus Torvalds1da177e2005-04-16 15:20:36 -070088
89MODULE_AUTHOR("Kai Makisara");
Rene Hermanf018fa52006-03-08 00:14:20 -080090MODULE_DESCRIPTION("SCSI tape (st) driver");
Linus Torvalds1da177e2005-04-16 15:20:36 -070091MODULE_LICENSE("GPL");
Rene Hermanf018fa52006-03-08 00:14:20 -080092MODULE_ALIAS_CHARDEV_MAJOR(SCSI_TAPE_MAJOR);
Michael Tokarevd7b8bcb2006-10-27 16:02:37 +040093MODULE_ALIAS_SCSI_DEVICE(TYPE_TAPE);
Linus Torvalds1da177e2005-04-16 15:20:36 -070094
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.
98 */
99module_param_named(buffer_kbs, buffer_kbs, int, 0);
100MODULE_PARM_DESC(buffer_kbs, "Default driver buffer size for fixed block mode (KB; 32)");
101module_param_named(max_sg_segs, max_sg_segs, int, 0);
102MODULE_PARM_DESC(max_sg_segs, "Maximum number of scatter/gather segments to use (256)");
103module_param_named(try_direct_io, try_direct_io, int, 0);
104MODULE_PARM_DESC(try_direct_io, "Try direct I/O between user buffer and tape drive (1)");
105
106/* Extra parameters for testing */
107module_param_named(try_rdio, try_rdio, int, 0);
108MODULE_PARM_DESC(try_rdio, "Try direct read i/o when possible");
109module_param_named(try_wdio, try_wdio, int, 0);
110MODULE_PARM_DESC(try_wdio, "Try direct write i/o when possible");
111
112#ifndef MODULE
113static int write_threshold_kbs; /* retained for compatibility */
114static struct st_dev_parm {
115 char *name;
116 int *val;
117} parms[] __initdata = {
118 {
119 "buffer_kbs", &buffer_kbs
120 },
121 { /* Retained for compatibility with 2.4 */
122 "write_threshold_kbs", &write_threshold_kbs
123 },
124 {
125 "max_sg_segs", NULL
126 },
127 {
128 "try_direct_io", &try_direct_io
129 }
130};
131#endif
132
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"
136#endif
137/* Bit reversed order to get same names for same minors with all
138 mode counts */
Arjan van de Ven0ad78202005-11-28 16:22:25 +0100139static const char *st_formats[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700140 "", "r", "k", "s", "l", "t", "o", "u",
141 "m", "v", "p", "x", "a", "y", "q", "z"};
142
143/* The default definitions have been moved to st_options.h */
144
145#define ST_FIXED_BUFFER_SIZE (ST_FIXED_BUFFER_BLOCKS * ST_KILOBYTE)
146
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!"
151#endif
152
153static int debugging = DEBUG;
154
155#define MAX_RETRIES 0
156#define MAX_WRITE_RETRIES 0
157#define MAX_READY_RETRIES 0
158#define NO_TAPE NOT_READY
159
160#define ST_TIMEOUT (900 * HZ)
161#define ST_LONG_TIMEOUT (14000 * HZ)
162
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)
167
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) )
171
172/* Internal ioctl to set both density (uppermost 8 bits) and blocksize (lower
173 24 bits) */
174#define SET_DENS_AND_BLK 0x10001
175
176static DEFINE_RWLOCK(st_dev_arr_lock);
177
178static int st_fixed_buffer_size = ST_FIXED_BUFFER_SIZE;
179static int st_max_sg_segs = ST_MAX_SG;
180
181static struct scsi_tape **scsi_tapes = NULL;
182
183static int modes_defined;
184
185static struct st_buffer *new_tape_buffer(int, int, int);
186static int enlarge_buffer(struct st_buffer *, int, int);
Kai Makisara40f6b362008-02-24 22:23:24 +0200187static void clear_buffer(struct st_buffer *);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188static void normalize_buffer(struct st_buffer *);
189static int append_to_buffer(const char __user *, struct st_buffer *, int);
190static int from_buffer(struct st_buffer *, char __user *, int);
191static void move_buffer_data(struct st_buffer *, int);
192static void buf_to_sg(struct st_buffer *, unsigned int);
193
Linus Torvalds1da177e2005-04-16 15:20:36 -0700194static int sgl_map_user_pages(struct scatterlist *, const unsigned int,
195 unsigned long, size_t, int);
196static int sgl_unmap_user_pages(struct scatterlist *, const unsigned int, int);
197
198static int st_probe(struct device *);
199static int st_remove(struct device *);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200
Robert P. J. Day405ae7d2007-02-17 19:13:42 +0100201static int do_create_sysfs_files(void);
202static void do_remove_sysfs_files(void);
Jeff Garzik13026a62006-10-04 06:00:38 -0400203static int do_create_class_files(struct scsi_tape *, int, int);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700204
205static struct scsi_driver st_template = {
206 .owner = THIS_MODULE,
207 .gendrv = {
208 .name = "st",
209 .probe = st_probe,
210 .remove = st_remove,
211 },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700212};
213
214static int st_compression(struct scsi_tape *, int);
215
216static int find_partition(struct scsi_tape *);
217static int switch_partition(struct scsi_tape *);
218
219static int st_int_ioctl(struct scsi_tape *, unsigned int, unsigned long);
220
Kai Makisaraf03a5672005-08-02 13:40:47 +0300221static void scsi_tape_release(struct kref *);
222
223#define to_scsi_tape(obj) container_of(obj, struct scsi_tape, kref)
224
Arjan van de Ven0b950672006-01-11 13:16:10 +0100225static DEFINE_MUTEX(st_ref_mutex);
Kai Makisaraf03a5672005-08-02 13:40:47 +0300226
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227
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"}
236#endif
237
Kai Makisaraf03a5672005-08-02 13:40:47 +0300238static struct scsi_tape *scsi_tape_get(int dev)
239{
240 struct scsi_tape *STp = NULL;
241
Arjan van de Ven0b950672006-01-11 13:16:10 +0100242 mutex_lock(&st_ref_mutex);
Kai Makisaraf03a5672005-08-02 13:40:47 +0300243 write_lock(&st_dev_arr_lock);
244
245 if (dev < st_dev_max && scsi_tapes != NULL)
246 STp = scsi_tapes[dev];
247 if (!STp) goto out;
248
249 kref_get(&STp->kref);
250
251 if (!STp->device)
252 goto out_put;
253
254 if (scsi_device_get(STp->device))
255 goto out_put;
256
257 goto out;
258
259out_put:
260 kref_put(&STp->kref, scsi_tape_release);
261 STp = NULL;
262out:
263 write_unlock(&st_dev_arr_lock);
Arjan van de Ven0b950672006-01-11 13:16:10 +0100264 mutex_unlock(&st_ref_mutex);
Kai Makisaraf03a5672005-08-02 13:40:47 +0300265 return STp;
266}
267
268static void scsi_tape_put(struct scsi_tape *STp)
269{
270 struct scsi_device *sdev = STp->device;
271
Arjan van de Ven0b950672006-01-11 13:16:10 +0100272 mutex_lock(&st_ref_mutex);
Kai Makisaraf03a5672005-08-02 13:40:47 +0300273 kref_put(&STp->kref, scsi_tape_release);
274 scsi_device_put(sdev);
Arjan van de Ven0b950672006-01-11 13:16:10 +0100275 mutex_unlock(&st_ref_mutex);
Kai Makisaraf03a5672005-08-02 13:40:47 +0300276}
277
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278struct st_reject_data {
279 char *vendor;
280 char *model;
281 char *rev;
282 char *driver_hint; /* Name of the correct driver, NULL if unknown */
283};
284
285static struct st_reject_data reject_list[] = {
286 /* {"XXX", "Yy-", "", NULL}, example */
287 SIGS_FROM_OSST,
288 {NULL, }};
289
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) */
292static char * st_incompatible(struct scsi_device* SDp)
293{
294 struct st_reject_data *rp;
295
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))) {
300 if (rp->driver_hint)
301 return rp->driver_hint;
302 else
303 return "unknown";
304 }
305 return NULL;
306}
307
308
309static inline char *tape_name(struct scsi_tape *tape)
310{
311 return tape->disk->disk_name;
312}
313
314
Mike Christie8b05b772005-11-08 04:06:44 -0600315static void st_analyze_sense(struct st_request *SRpnt, struct st_cmdstatus *s)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316{
317 const u8 *ucp;
Mike Christie8b05b772005-11-08 04:06:44 -0600318 const u8 *sense = SRpnt->sense;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319
Mike Christie8b05b772005-11-08 04:06:44 -0600320 s->have_sense = scsi_normalize_sense(SRpnt->sense,
321 SCSI_SENSE_BUFFERSIZE, &s->sense_hdr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700322 s->flags = 0;
323
324 if (s->have_sense) {
325 s->deferred = 0;
326 s->remainder_valid =
327 scsi_get_sense_info_fld(sense, SCSI_SENSE_BUFFERSIZE, &s->uremainder64);
328 switch (sense[0] & 0x7f) {
329 case 0x71:
330 s->deferred = 1;
331 case 0x70:
332 s->fixed_format = 1;
333 s->flags = sense[2] & 0xe0;
334 break;
335 case 0x73:
336 s->deferred = 1;
337 case 0x72:
338 s->fixed_format = 0;
339 ucp = scsi_sense_desc_find(sense, SCSI_SENSE_BUFFERSIZE, 4);
340 s->flags = ucp ? (ucp[3] & 0xe0) : 0;
341 break;
342 }
343 }
344}
345
346
347/* Convert the result to success code */
Mike Christie8b05b772005-11-08 04:06:44 -0600348static int st_chk_result(struct scsi_tape *STp, struct st_request * SRpnt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349{
Mike Christie8b05b772005-11-08 04:06:44 -0600350 int result = SRpnt->result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351 u8 scode;
352 DEB(const char *stp;)
353 char *name = tape_name(STp);
354 struct st_cmdstatus *cmdstatp;
355
356 if (!result)
357 return 0;
358
359 cmdstatp = &STp->buffer->cmdstat;
Kai Makisaraf03a5672005-08-02 13:40:47 +0300360 st_analyze_sense(SRpnt, cmdstatp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361
362 if (cmdstatp->have_sense)
363 scode = STp->buffer->cmdstat.sense_hdr.sense_key;
364 else
365 scode = 0;
366
367 DEB(
368 if (debugging) {
Mike Christie8b05b772005-11-08 04:06:44 -0600369 printk(ST_DEB_MSG "%s: Error: %x, cmd: %x %x %x %x %x %x\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370 name, result,
Mike Christie8b05b772005-11-08 04:06:44 -0600371 SRpnt->cmd[0], SRpnt->cmd[1], SRpnt->cmd[2],
372 SRpnt->cmd[3], SRpnt->cmd[4], SRpnt->cmd[5]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700373 if (cmdstatp->have_sense)
Luben Tuikov4e73ea72006-07-07 00:02:18 -0700374 __scsi_print_sense(name, SRpnt->sense, SCSI_SENSE_BUFFERSIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700375 } ) /* end DEB */
376 if (!debugging) { /* Abnormal conditions for tape */
377 if (!cmdstatp->have_sense)
378 printk(KERN_WARNING
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 &&
383 scode != NO_SENSE &&
384 scode != RECOVERED_ERROR &&
385 /* scode != UNIT_ATTENTION && */
386 scode != BLANK_CHECK &&
387 scode != VOLUME_OVERFLOW &&
Mike Christie8b05b772005-11-08 04:06:44 -0600388 SRpnt->cmd[0] != MODE_SENSE &&
389 SRpnt->cmd[0] != TEST_UNIT_READY) {
Luben Tuikov4e73ea72006-07-07 00:02:18 -0700390
391 __scsi_print_sense(name, SRpnt->sense, SCSI_SENSE_BUFFERSIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392 }
393 }
394
395 if (cmdstatp->fixed_format &&
396 STp->cln_mode >= EXTENDED_SENSE_START) { /* Only fixed format sense */
397 if (STp->cln_sense_value)
Mike Christie8b05b772005-11-08 04:06:44 -0600398 STp->cleaning_req |= ((SRpnt->sense[STp->cln_mode] &
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399 STp->cln_sense_mask) == STp->cln_sense_value);
400 else
Mike Christie8b05b772005-11-08 04:06:44 -0600401 STp->cleaning_req |= ((SRpnt->sense[STp->cln_mode] &
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402 STp->cln_sense_mask) != 0);
403 }
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 */
407
408 STp->pos_unknown |= STp->device->was_reset;
409
410 if (cmdstatp->have_sense &&
411 scode == RECOVERED_ERROR
412#if ST_RECOVERED_WRITE_FATAL
Mike Christie8b05b772005-11-08 04:06:44 -0600413 && SRpnt->cmd[0] != WRITE_6
414 && SRpnt->cmd[0] != WRITE_FILEMARKS
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415#endif
416 ) {
417 STp->recover_count++;
418 STp->recover_reg++;
419
420 DEB(
421 if (debugging) {
Mike Christie8b05b772005-11-08 04:06:44 -0600422 if (SRpnt->cmd[0] == READ_6)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423 stp = "read";
Mike Christie8b05b772005-11-08 04:06:44 -0600424 else if (SRpnt->cmd[0] == WRITE_6)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425 stp = "write";
426 else
427 stp = "ioctl";
428 printk(ST_DEB_MSG "%s: Recovered %s error (%d).\n", name, stp,
429 STp->recover_count);
430 } ) /* end DEB */
431
432 if (cmdstatp->flags == 0)
433 return 0;
434 }
435 return (-EIO);
436}
437
438
439/* Wakeup from interrupt */
Mike Christie8b05b772005-11-08 04:06:44 -0600440static void st_sleep_done(void *data, char *sense, int result, int resid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441{
Mike Christie8b05b772005-11-08 04:06:44 -0600442 struct st_request *SRpnt = data;
443 struct scsi_tape *STp = SRpnt->stp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444
Mike Christie8b05b772005-11-08 04:06:44 -0600445 memcpy(SRpnt->sense, sense, SCSI_SENSE_BUFFERSIZE);
446 (STp->buffer)->cmdstat.midlevel_result = SRpnt->result = result;
Kai Makisara40f6b362008-02-24 22:23:24 +0200447 (STp->buffer)->cmdstat.residual = resid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448 DEB( STp->write_pending = 0; )
449
Mike Christie8b05b772005-11-08 04:06:44 -0600450 if (SRpnt->waiting)
451 complete(SRpnt->waiting);
452}
453
454static struct st_request *st_allocate_request(void)
455{
456 return kzalloc(sizeof(struct st_request), GFP_KERNEL);
457}
458
459static void st_release_request(struct st_request *streq)
460{
461 kfree(streq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462}
463
464/* Do the scsi command. Waits until command performed if do_wait is true.
465 Otherwise write_behind_check() is used to check that the command
466 has finished. */
Mike Christie8b05b772005-11-08 04:06:44 -0600467static struct st_request *
468st_do_scsi(struct st_request * SRpnt, struct scsi_tape * STp, unsigned char *cmd,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700469 int bytes, int direction, int timeout, int retries, int do_wait)
470{
Kai Makisaraf03a5672005-08-02 13:40:47 +0300471 struct completion *waiting;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472
Kai Makisaraf03a5672005-08-02 13:40:47 +0300473 /* if async, make sure there's no command outstanding */
474 if (!do_wait && ((STp->buffer)->last_SRpnt)) {
475 printk(KERN_ERR "%s: Async command already active.\n",
476 tape_name(STp));
477 if (signal_pending(current))
478 (STp->buffer)->syscall_result = (-EINTR);
479 else
480 (STp->buffer)->syscall_result = (-EBUSY);
481 return NULL;
482 }
483
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484 if (SRpnt == NULL) {
Mike Christie8b05b772005-11-08 04:06:44 -0600485 SRpnt = st_allocate_request();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700486 if (SRpnt == NULL) {
487 DEBC( printk(KERN_ERR "%s: Can't get SCSI request.\n",
488 tape_name(STp)); );
489 if (signal_pending(current))
490 (STp->buffer)->syscall_result = (-EINTR);
491 else
492 (STp->buffer)->syscall_result = (-EBUSY);
493 return NULL;
494 }
Mike Christie8b05b772005-11-08 04:06:44 -0600495 SRpnt->stp = STp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496 }
497
Kai Makisaraf03a5672005-08-02 13:40:47 +0300498 /* If async IO, set last_SRpnt. This ptr tells write_behind_check
499 which IO is outstanding. It's nulled out when the IO completes. */
500 if (!do_wait)
501 (STp->buffer)->last_SRpnt = SRpnt;
502
503 waiting = &STp->wait;
504 init_completion(waiting);
Mike Christie8b05b772005-11-08 04:06:44 -0600505 SRpnt->waiting = waiting;
506
507 if (!STp->buffer->do_dio)
508 buf_to_sg(STp->buffer, bytes);
509
510 memcpy(SRpnt->cmd, cmd, sizeof(SRpnt->cmd));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700511 STp->buffer->cmdstat.have_sense = 0;
Mike Christie8b05b772005-11-08 04:06:44 -0600512 STp->buffer->syscall_result = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700513
brking@us.ibm.combb1d1072006-01-23 15:03:22 -0600514 if (scsi_execute_async(STp->device, cmd, COMMAND_SIZE(cmd[0]), direction,
Mike Christie8b05b772005-11-08 04:06:44 -0600515 &((STp->buffer)->sg[0]), bytes, (STp->buffer)->sg_segs,
Kai Makisara787926b2005-11-13 10:04:44 +0200516 timeout, retries, SRpnt, st_sleep_done, GFP_KERNEL)) {
Mike Christie8b05b772005-11-08 04:06:44 -0600517 /* could not allocate the buffer or request was too large */
518 (STp->buffer)->syscall_result = (-EBUSY);
Kai Makisara787926b2005-11-13 10:04:44 +0200519 (STp->buffer)->last_SRpnt = NULL;
520 }
Mike Christie8b05b772005-11-08 04:06:44 -0600521 else if (do_wait) {
Kai Makisaraf03a5672005-08-02 13:40:47 +0300522 wait_for_completion(waiting);
Mike Christie8b05b772005-11-08 04:06:44 -0600523 SRpnt->waiting = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700524 (STp->buffer)->syscall_result = st_chk_result(STp, SRpnt);
525 }
Mike Christie8b05b772005-11-08 04:06:44 -0600526
Linus Torvalds1da177e2005-04-16 15:20:36 -0700527 return SRpnt;
528}
529
530
531/* Handle the write-behind checking (waits for completion). Returns -ENOSPC if
532 write has been correct but EOM early warning reached, -EIO if write ended in
533 error or zero if write successful. Asynchronous writes are used only in
534 variable block mode. */
535static int write_behind_check(struct scsi_tape * STp)
536{
537 int retval = 0;
538 struct st_buffer *STbuffer;
539 struct st_partstat *STps;
540 struct st_cmdstatus *cmdstatp;
Mike Christie8b05b772005-11-08 04:06:44 -0600541 struct st_request *SRpnt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542
543 STbuffer = STp->buffer;
544 if (!STbuffer->writing)
545 return 0;
546
547 DEB(
548 if (STp->write_pending)
549 STp->nbr_waits++;
550 else
551 STp->nbr_finished++;
552 ) /* end DEB */
553
554 wait_for_completion(&(STp->wait));
Kai Makisaraf03a5672005-08-02 13:40:47 +0300555 SRpnt = STbuffer->last_SRpnt;
556 STbuffer->last_SRpnt = NULL;
Mike Christie8b05b772005-11-08 04:06:44 -0600557 SRpnt->waiting = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558
Kai Makisaraf03a5672005-08-02 13:40:47 +0300559 (STp->buffer)->syscall_result = st_chk_result(STp, SRpnt);
Mike Christie8b05b772005-11-08 04:06:44 -0600560 st_release_request(SRpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700561
562 STbuffer->buffer_bytes -= STbuffer->writing;
563 STps = &(STp->ps[STp->partition]);
564 if (STps->drv_block >= 0) {
565 if (STp->block_size == 0)
566 STps->drv_block++;
567 else
568 STps->drv_block += STbuffer->writing / STp->block_size;
569 }
570
571 cmdstatp = &STbuffer->cmdstat;
572 if (STbuffer->syscall_result) {
573 retval = -EIO;
574 if (cmdstatp->have_sense && !cmdstatp->deferred &&
575 (cmdstatp->flags & SENSE_EOM) &&
576 (cmdstatp->sense_hdr.sense_key == NO_SENSE ||
577 cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR)) {
578 /* EOM at write-behind, has all data been written? */
579 if (!cmdstatp->remainder_valid ||
580 cmdstatp->uremainder64 == 0)
581 retval = -ENOSPC;
582 }
583 if (retval == -EIO)
584 STps->drv_block = -1;
585 }
586 STbuffer->writing = 0;
587
588 DEB(if (debugging && retval)
589 printk(ST_DEB_MSG "%s: Async write error %x, return value %d.\n",
590 tape_name(STp), STbuffer->cmdstat.midlevel_result, retval);) /* end DEB */
591
592 return retval;
593}
594
595
596/* Step over EOF if it has been inadvertently crossed (ioctl not used because
597 it messes up the block number). */
598static int cross_eof(struct scsi_tape * STp, int forward)
599{
Mike Christie8b05b772005-11-08 04:06:44 -0600600 struct st_request *SRpnt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700601 unsigned char cmd[MAX_COMMAND_SIZE];
602
603 cmd[0] = SPACE;
604 cmd[1] = 0x01; /* Space FileMarks */
605 if (forward) {
606 cmd[2] = cmd[3] = 0;
607 cmd[4] = 1;
608 } else
609 cmd[2] = cmd[3] = cmd[4] = 0xff; /* -1 filemarks */
610 cmd[5] = 0;
611
612 DEBC(printk(ST_DEB_MSG "%s: Stepping over filemark %s.\n",
613 tape_name(STp), forward ? "forward" : "backward"));
614
615 SRpnt = st_do_scsi(NULL, STp, cmd, 0, DMA_NONE,
James Bottomleya02488e2008-11-30 10:36:26 -0600616 STp->device->request_queue->rq_timeout,
617 MAX_RETRIES, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700618 if (!SRpnt)
619 return (STp->buffer)->syscall_result;
620
Mike Christie8b05b772005-11-08 04:06:44 -0600621 st_release_request(SRpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700622 SRpnt = NULL;
623
624 if ((STp->buffer)->cmdstat.midlevel_result != 0)
625 printk(KERN_ERR "%s: Stepping over filemark %s failed.\n",
626 tape_name(STp), forward ? "forward" : "backward");
627
628 return (STp->buffer)->syscall_result;
629}
630
631
632/* Flush the write buffer (never need to write if variable blocksize). */
Adrian Bunk8ef8d592008-04-14 17:17:16 +0300633static int st_flush_write_buffer(struct scsi_tape * STp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700634{
Kai Makisara786231a2008-07-11 15:06:40 +0300635 int transfer, blks;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700636 int result;
637 unsigned char cmd[MAX_COMMAND_SIZE];
Mike Christie8b05b772005-11-08 04:06:44 -0600638 struct st_request *SRpnt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700639 struct st_partstat *STps;
640
641 result = write_behind_check(STp);
642 if (result)
643 return result;
644
645 result = 0;
646 if (STp->dirty == 1) {
647
Kai Makisara786231a2008-07-11 15:06:40 +0300648 transfer = STp->buffer->buffer_bytes;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700649 DEBC(printk(ST_DEB_MSG "%s: Flushing %d bytes.\n",
650 tape_name(STp), transfer));
651
Linus Torvalds1da177e2005-04-16 15:20:36 -0700652 memset(cmd, 0, MAX_COMMAND_SIZE);
653 cmd[0] = WRITE_6;
654 cmd[1] = 1;
655 blks = transfer / STp->block_size;
656 cmd[2] = blks >> 16;
657 cmd[3] = blks >> 8;
658 cmd[4] = blks;
659
660 SRpnt = st_do_scsi(NULL, STp, cmd, transfer, DMA_TO_DEVICE,
James Bottomleya02488e2008-11-30 10:36:26 -0600661 STp->device->request_queue->rq_timeout,
662 MAX_WRITE_RETRIES, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700663 if (!SRpnt)
664 return (STp->buffer)->syscall_result;
665
666 STps = &(STp->ps[STp->partition]);
667 if ((STp->buffer)->syscall_result != 0) {
668 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
669
670 if (cmdstatp->have_sense && !cmdstatp->deferred &&
671 (cmdstatp->flags & SENSE_EOM) &&
672 (cmdstatp->sense_hdr.sense_key == NO_SENSE ||
673 cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR) &&
674 (!cmdstatp->remainder_valid ||
675 cmdstatp->uremainder64 == 0)) { /* All written at EOM early warning */
676 STp->dirty = 0;
677 (STp->buffer)->buffer_bytes = 0;
678 if (STps->drv_block >= 0)
679 STps->drv_block += blks;
680 result = (-ENOSPC);
681 } else {
682 printk(KERN_ERR "%s: Error on flush.\n",
683 tape_name(STp));
684 STps->drv_block = (-1);
685 result = (-EIO);
686 }
687 } else {
688 if (STps->drv_block >= 0)
689 STps->drv_block += blks;
690 STp->dirty = 0;
691 (STp->buffer)->buffer_bytes = 0;
692 }
Mike Christie8b05b772005-11-08 04:06:44 -0600693 st_release_request(SRpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700694 SRpnt = NULL;
695 }
696 return result;
697}
698
699
700/* Flush the tape buffer. The tape will be positioned correctly unless
701 seek_next is true. */
702static int flush_buffer(struct scsi_tape *STp, int seek_next)
703{
704 int backspace, result;
705 struct st_buffer *STbuffer;
706 struct st_partstat *STps;
707
708 STbuffer = STp->buffer;
709
710 /*
711 * If there was a bus reset, block further access
712 * to this device.
713 */
714 if (STp->pos_unknown)
715 return (-EIO);
716
717 if (STp->ready != ST_READY)
718 return 0;
719 STps = &(STp->ps[STp->partition]);
720 if (STps->rw == ST_WRITING) /* Writing */
Adrian Bunk8ef8d592008-04-14 17:17:16 +0300721 return st_flush_write_buffer(STp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700722
723 if (STp->block_size == 0)
724 return 0;
725
726 backspace = ((STp->buffer)->buffer_bytes +
727 (STp->buffer)->read_pointer) / STp->block_size -
728 ((STp->buffer)->read_pointer + STp->block_size - 1) /
729 STp->block_size;
730 (STp->buffer)->buffer_bytes = 0;
731 (STp->buffer)->read_pointer = 0;
732 result = 0;
733 if (!seek_next) {
734 if (STps->eof == ST_FM_HIT) {
735 result = cross_eof(STp, 0); /* Back over the EOF hit */
736 if (!result)
737 STps->eof = ST_NOEOF;
738 else {
739 if (STps->drv_file >= 0)
740 STps->drv_file++;
741 STps->drv_block = 0;
742 }
743 }
744 if (!result && backspace > 0)
745 result = st_int_ioctl(STp, MTBSR, backspace);
746 } else if (STps->eof == ST_FM_HIT) {
747 if (STps->drv_file >= 0)
748 STps->drv_file++;
749 STps->drv_block = 0;
750 STps->eof = ST_NOEOF;
751 }
752 return result;
753
754}
755
756/* Set the mode parameters */
757static int set_mode_densblk(struct scsi_tape * STp, struct st_modedef * STm)
758{
759 int set_it = 0;
760 unsigned long arg;
761 char *name = tape_name(STp);
762
763 if (!STp->density_changed &&
764 STm->default_density >= 0 &&
765 STm->default_density != STp->density) {
766 arg = STm->default_density;
767 set_it = 1;
768 } else
769 arg = STp->density;
770 arg <<= MT_ST_DENSITY_SHIFT;
771 if (!STp->blksize_changed &&
772 STm->default_blksize >= 0 &&
773 STm->default_blksize != STp->block_size) {
774 arg |= STm->default_blksize;
775 set_it = 1;
776 } else
777 arg |= STp->block_size;
778 if (set_it &&
779 st_int_ioctl(STp, SET_DENS_AND_BLK, arg)) {
780 printk(KERN_WARNING
781 "%s: Can't set default block size to %d bytes and density %x.\n",
782 name, STm->default_blksize, STm->default_density);
783 if (modes_defined)
784 return (-EINVAL);
785 }
786 return 0;
787}
788
789
Mike Christie8b05b772005-11-08 04:06:44 -0600790/* Lock or unlock the drive door. Don't use when st_request allocated. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700791static int do_door_lock(struct scsi_tape * STp, int do_lock)
792{
793 int retval, cmd;
794 DEB(char *name = tape_name(STp);)
795
796
797 cmd = do_lock ? SCSI_IOCTL_DOORLOCK : SCSI_IOCTL_DOORUNLOCK;
798 DEBC(printk(ST_DEB_MSG "%s: %socking drive door.\n", name,
799 do_lock ? "L" : "Unl"));
800 retval = scsi_ioctl(STp->device, cmd, NULL);
801 if (!retval) {
802 STp->door_locked = do_lock ? ST_LOCKED_EXPLICIT : ST_UNLOCKED;
803 }
804 else {
805 STp->door_locked = ST_LOCK_FAILS;
806 }
807 return retval;
808}
809
810
811/* Set the internal state after reset */
812static void reset_state(struct scsi_tape *STp)
813{
814 int i;
815 struct st_partstat *STps;
816
817 STp->pos_unknown = 0;
818 for (i = 0; i < ST_NBR_PARTITIONS; i++) {
819 STps = &(STp->ps[i]);
820 STps->rw = ST_IDLE;
821 STps->eof = ST_NOEOF;
822 STps->at_sm = 0;
823 STps->last_block_valid = 0;
824 STps->drv_block = -1;
825 STps->drv_file = -1;
826 }
827 if (STp->can_partitions) {
828 STp->partition = find_partition(STp);
829 if (STp->partition < 0)
830 STp->partition = 0;
831 STp->new_partition = STp->partition;
832 }
833}
834
835/* Test if the drive is ready. Returns either one of the codes below or a negative system
836 error code. */
837#define CHKRES_READY 0
838#define CHKRES_NEW_SESSION 1
839#define CHKRES_NOT_READY 2
840#define CHKRES_NO_TAPE 3
841
842#define MAX_ATTENTIONS 10
843
844static int test_ready(struct scsi_tape *STp, int do_wait)
845{
846 int attentions, waits, max_wait, scode;
847 int retval = CHKRES_READY, new_session = 0;
848 unsigned char cmd[MAX_COMMAND_SIZE];
Mike Christie8b05b772005-11-08 04:06:44 -0600849 struct st_request *SRpnt = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700850 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
851
852 max_wait = do_wait ? ST_BLOCK_SECONDS : 0;
853
854 for (attentions=waits=0; ; ) {
855 memset((void *) &cmd[0], 0, MAX_COMMAND_SIZE);
856 cmd[0] = TEST_UNIT_READY;
857 SRpnt = st_do_scsi(SRpnt, STp, cmd, 0, DMA_NONE,
858 STp->long_timeout, MAX_READY_RETRIES, 1);
859
860 if (!SRpnt) {
861 retval = (STp->buffer)->syscall_result;
862 break;
863 }
864
865 if (cmdstatp->have_sense) {
866
867 scode = cmdstatp->sense_hdr.sense_key;
868
869 if (scode == UNIT_ATTENTION) { /* New media? */
870 new_session = 1;
871 if (attentions < MAX_ATTENTIONS) {
872 attentions++;
873 continue;
874 }
875 else {
876 retval = (-EIO);
877 break;
878 }
879 }
880
881 if (scode == NOT_READY) {
882 if (waits < max_wait) {
883 if (msleep_interruptible(1000)) {
884 retval = (-EINTR);
885 break;
886 }
887 waits++;
888 continue;
889 }
890 else {
891 if ((STp->device)->scsi_level >= SCSI_2 &&
892 cmdstatp->sense_hdr.asc == 0x3a) /* Check ASC */
893 retval = CHKRES_NO_TAPE;
894 else
895 retval = CHKRES_NOT_READY;
896 break;
897 }
898 }
899 }
900
901 retval = (STp->buffer)->syscall_result;
902 if (!retval)
903 retval = new_session ? CHKRES_NEW_SESSION : CHKRES_READY;
904 break;
905 }
906
907 if (SRpnt != NULL)
Mike Christie8b05b772005-11-08 04:06:44 -0600908 st_release_request(SRpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700909 return retval;
910}
911
912
913/* See if the drive is ready and gather information about the tape. Return values:
914 < 0 negative error code from errno.h
915 0 drive ready
916 1 drive not ready (possibly no tape)
917*/
918static int check_tape(struct scsi_tape *STp, struct file *filp)
919{
920 int i, retval, new_session = 0, do_wait;
921 unsigned char cmd[MAX_COMMAND_SIZE], saved_cleaning;
922 unsigned short st_flags = filp->f_flags;
Mike Christie8b05b772005-11-08 04:06:44 -0600923 struct st_request *SRpnt = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700924 struct st_modedef *STm;
925 struct st_partstat *STps;
926 char *name = tape_name(STp);
Josef Sipek7ac62072006-12-08 02:37:37 -0800927 struct inode *inode = filp->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700928 int mode = TAPE_MODE(inode);
929
930 STp->ready = ST_READY;
931
932 if (mode != STp->current_mode) {
933 DEBC(printk(ST_DEB_MSG "%s: Mode change from %d to %d.\n",
934 name, STp->current_mode, mode));
935 new_session = 1;
936 STp->current_mode = mode;
937 }
938 STm = &(STp->modes[STp->current_mode]);
939
940 saved_cleaning = STp->cleaning_req;
941 STp->cleaning_req = 0;
942
943 do_wait = ((filp->f_flags & O_NONBLOCK) == 0);
944 retval = test_ready(STp, do_wait);
945
946 if (retval < 0)
947 goto err_out;
948
949 if (retval == CHKRES_NEW_SESSION) {
950 STp->pos_unknown = 0;
951 STp->partition = STp->new_partition = 0;
952 if (STp->can_partitions)
953 STp->nbr_partitions = 1; /* This guess will be updated later
954 if necessary */
955 for (i = 0; i < ST_NBR_PARTITIONS; i++) {
956 STps = &(STp->ps[i]);
957 STps->rw = ST_IDLE;
958 STps->eof = ST_NOEOF;
959 STps->at_sm = 0;
960 STps->last_block_valid = 0;
961 STps->drv_block = 0;
962 STps->drv_file = 0;
963 }
964 new_session = 1;
965 }
966 else {
967 STp->cleaning_req |= saved_cleaning;
968
969 if (retval == CHKRES_NOT_READY || retval == CHKRES_NO_TAPE) {
970 if (retval == CHKRES_NO_TAPE)
971 STp->ready = ST_NO_TAPE;
972 else
973 STp->ready = ST_NOT_READY;
974
975 STp->density = 0; /* Clear the erroneous "residue" */
976 STp->write_prot = 0;
977 STp->block_size = 0;
978 STp->ps[0].drv_file = STp->ps[0].drv_block = (-1);
979 STp->partition = STp->new_partition = 0;
980 STp->door_locked = ST_UNLOCKED;
981 return CHKRES_NOT_READY;
982 }
983 }
984
985 if (STp->omit_blklims)
986 STp->min_block = STp->max_block = (-1);
987 else {
988 memset((void *) &cmd[0], 0, MAX_COMMAND_SIZE);
989 cmd[0] = READ_BLOCK_LIMITS;
990
991 SRpnt = st_do_scsi(SRpnt, STp, cmd, 6, DMA_FROM_DEVICE,
James Bottomleya02488e2008-11-30 10:36:26 -0600992 STp->device->request_queue->rq_timeout,
993 MAX_READY_RETRIES, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700994 if (!SRpnt) {
995 retval = (STp->buffer)->syscall_result;
996 goto err_out;
997 }
998
Mike Christie8b05b772005-11-08 04:06:44 -0600999 if (!SRpnt->result && !STp->buffer->cmdstat.have_sense) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001000 STp->max_block = ((STp->buffer)->b_data[1] << 16) |
1001 ((STp->buffer)->b_data[2] << 8) | (STp->buffer)->b_data[3];
1002 STp->min_block = ((STp->buffer)->b_data[4] << 8) |
1003 (STp->buffer)->b_data[5];
1004 if ( DEB( debugging || ) !STp->inited)
Kai Makisara42252852006-11-07 21:56:38 +02001005 printk(KERN_INFO
Linus Torvalds1da177e2005-04-16 15:20:36 -07001006 "%s: Block limits %d - %d bytes.\n", name,
1007 STp->min_block, STp->max_block);
1008 } else {
1009 STp->min_block = STp->max_block = (-1);
1010 DEBC(printk(ST_DEB_MSG "%s: Can't read block limits.\n",
1011 name));
1012 }
1013 }
1014
1015 memset((void *) &cmd[0], 0, MAX_COMMAND_SIZE);
1016 cmd[0] = MODE_SENSE;
1017 cmd[4] = 12;
1018
1019 SRpnt = st_do_scsi(SRpnt, STp, cmd, 12, DMA_FROM_DEVICE,
James Bottomleya02488e2008-11-30 10:36:26 -06001020 STp->device->request_queue->rq_timeout,
1021 MAX_READY_RETRIES, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001022 if (!SRpnt) {
1023 retval = (STp->buffer)->syscall_result;
1024 goto err_out;
1025 }
1026
1027 if ((STp->buffer)->syscall_result != 0) {
1028 DEBC(printk(ST_DEB_MSG "%s: No Mode Sense.\n", name));
1029 STp->block_size = ST_DEFAULT_BLOCK; /* Educated guess (?) */
1030 (STp->buffer)->syscall_result = 0; /* Prevent error propagation */
1031 STp->drv_write_prot = 0;
1032 } else {
1033 DEBC(printk(ST_DEB_MSG
1034 "%s: Mode sense. Length %d, medium %x, WBS %x, BLL %d\n",
1035 name,
1036 (STp->buffer)->b_data[0], (STp->buffer)->b_data[1],
1037 (STp->buffer)->b_data[2], (STp->buffer)->b_data[3]));
1038
1039 if ((STp->buffer)->b_data[3] >= 8) {
1040 STp->drv_buffer = ((STp->buffer)->b_data[2] >> 4) & 7;
1041 STp->density = (STp->buffer)->b_data[4];
1042 STp->block_size = (STp->buffer)->b_data[9] * 65536 +
1043 (STp->buffer)->b_data[10] * 256 + (STp->buffer)->b_data[11];
1044 DEBC(printk(ST_DEB_MSG
1045 "%s: Density %x, tape length: %x, drv buffer: %d\n",
1046 name, STp->density, (STp->buffer)->b_data[5] * 65536 +
1047 (STp->buffer)->b_data[6] * 256 + (STp->buffer)->b_data[7],
1048 STp->drv_buffer));
1049 }
1050 STp->drv_write_prot = ((STp->buffer)->b_data[2] & 0x80) != 0;
1051 }
Mike Christie8b05b772005-11-08 04:06:44 -06001052 st_release_request(SRpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001053 SRpnt = NULL;
1054 STp->inited = 1;
1055
1056 if (STp->block_size > 0)
1057 (STp->buffer)->buffer_blocks =
1058 (STp->buffer)->buffer_size / STp->block_size;
1059 else
1060 (STp->buffer)->buffer_blocks = 1;
1061 (STp->buffer)->buffer_bytes = (STp->buffer)->read_pointer = 0;
1062
1063 DEBC(printk(ST_DEB_MSG
1064 "%s: Block size: %d, buffer size: %d (%d blocks).\n", name,
1065 STp->block_size, (STp->buffer)->buffer_size,
1066 (STp->buffer)->buffer_blocks));
1067
1068 if (STp->drv_write_prot) {
1069 STp->write_prot = 1;
1070
1071 DEBC(printk(ST_DEB_MSG "%s: Write protected\n", name));
1072
1073 if (do_wait &&
1074 ((st_flags & O_ACCMODE) == O_WRONLY ||
1075 (st_flags & O_ACCMODE) == O_RDWR)) {
1076 retval = (-EROFS);
1077 goto err_out;
1078 }
1079 }
1080
1081 if (STp->can_partitions && STp->nbr_partitions < 1) {
1082 /* This code is reached when the device is opened for the first time
1083 after the driver has been initialized with tape in the drive and the
1084 partition support has been enabled. */
1085 DEBC(printk(ST_DEB_MSG
1086 "%s: Updating partition number in status.\n", name));
1087 if ((STp->partition = find_partition(STp)) < 0) {
1088 retval = STp->partition;
1089 goto err_out;
1090 }
1091 STp->new_partition = STp->partition;
1092 STp->nbr_partitions = 1; /* This guess will be updated when necessary */
1093 }
1094
1095 if (new_session) { /* Change the drive parameters for the new mode */
1096 STp->density_changed = STp->blksize_changed = 0;
1097 STp->compression_changed = 0;
1098 if (!(STm->defaults_for_writes) &&
1099 (retval = set_mode_densblk(STp, STm)) < 0)
1100 goto err_out;
1101
1102 if (STp->default_drvbuffer != 0xff) {
1103 if (st_int_ioctl(STp, MTSETDRVBUFFER, STp->default_drvbuffer))
1104 printk(KERN_WARNING
1105 "%s: Can't set default drive buffering to %d.\n",
1106 name, STp->default_drvbuffer);
1107 }
1108 }
1109
1110 return CHKRES_READY;
1111
1112 err_out:
1113 return retval;
1114}
1115
1116
Jonathan Corbetb3369c62008-05-15 16:08:15 -06001117 /* Open the device. Needs to take the BKL only because of incrementing the SCSI host
Linus Torvalds1da177e2005-04-16 15:20:36 -07001118 module count. */
1119static int st_open(struct inode *inode, struct file *filp)
1120{
1121 int i, retval = (-EIO);
1122 struct scsi_tape *STp;
1123 struct st_partstat *STps;
1124 int dev = TAPE_NR(inode);
1125 char *name;
1126
Jonathan Corbetb3369c62008-05-15 16:08:15 -06001127 lock_kernel();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001128 /*
1129 * We really want to do nonseekable_open(inode, filp); here, but some
1130 * versions of tar incorrectly call lseek on tapes and bail out if that
1131 * fails. So we disallow pread() and pwrite(), but permit lseeks.
1132 */
1133 filp->f_mode &= ~(FMODE_PREAD | FMODE_PWRITE);
1134
Jonathan Corbetb3369c62008-05-15 16:08:15 -06001135 if (!(STp = scsi_tape_get(dev))) {
1136 unlock_kernel();
Kai Makisaraf03a5672005-08-02 13:40:47 +03001137 return -ENXIO;
Jonathan Corbetb3369c62008-05-15 16:08:15 -06001138 }
Kai Makisaraf03a5672005-08-02 13:40:47 +03001139
Linus Torvalds1da177e2005-04-16 15:20:36 -07001140 write_lock(&st_dev_arr_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001141 filp->private_data = STp;
1142 name = tape_name(STp);
1143
1144 if (STp->in_use) {
1145 write_unlock(&st_dev_arr_lock);
Kai Makisaraf03a5672005-08-02 13:40:47 +03001146 scsi_tape_put(STp);
Jonathan Corbetb3369c62008-05-15 16:08:15 -06001147 unlock_kernel();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001148 DEB( printk(ST_DEB_MSG "%s: Device already in use.\n", name); )
1149 return (-EBUSY);
1150 }
1151
Linus Torvalds1da177e2005-04-16 15:20:36 -07001152 STp->in_use = 1;
1153 write_unlock(&st_dev_arr_lock);
1154 STp->rew_at_close = STp->autorew_dev = (iminor(inode) & 0x80) == 0;
1155
1156 if (!scsi_block_when_processing_errors(STp->device)) {
1157 retval = (-ENXIO);
1158 goto err_out;
1159 }
1160
1161 /* See that we have at least a one page buffer available */
1162 if (!enlarge_buffer(STp->buffer, PAGE_SIZE, STp->restr_dma)) {
1163 printk(KERN_WARNING "%s: Can't allocate one page tape buffer.\n",
1164 name);
1165 retval = (-EOVERFLOW);
1166 goto err_out;
1167 }
1168
Kai Makisara40f6b362008-02-24 22:23:24 +02001169 (STp->buffer)->cleared = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001170 (STp->buffer)->writing = 0;
1171 (STp->buffer)->syscall_result = 0;
1172
1173 STp->write_prot = ((filp->f_flags & O_ACCMODE) == O_RDONLY);
1174
1175 STp->dirty = 0;
1176 for (i = 0; i < ST_NBR_PARTITIONS; i++) {
1177 STps = &(STp->ps[i]);
1178 STps->rw = ST_IDLE;
1179 }
Kai Makisara9abe16c2007-02-03 13:21:29 +02001180 STp->try_dio_now = STp->try_dio;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001181 STp->recover_count = 0;
1182 DEB( STp->nbr_waits = STp->nbr_finished = 0;
Kai Makisaradeee13d2008-02-22 20:11:21 +02001183 STp->nbr_requests = STp->nbr_dio = STp->nbr_pages = 0; )
Linus Torvalds1da177e2005-04-16 15:20:36 -07001184
1185 retval = check_tape(STp, filp);
1186 if (retval < 0)
1187 goto err_out;
1188 if ((filp->f_flags & O_NONBLOCK) == 0 &&
1189 retval != CHKRES_READY) {
Kai Makisara413f7322006-10-05 22:59:46 +03001190 if (STp->ready == NO_TAPE)
1191 retval = (-ENOMEDIUM);
1192 else
1193 retval = (-EIO);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001194 goto err_out;
1195 }
Jonathan Corbetb3369c62008-05-15 16:08:15 -06001196 unlock_kernel();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001197 return 0;
1198
1199 err_out:
1200 normalize_buffer(STp->buffer);
1201 STp->in_use = 0;
Kai Makisaraf03a5672005-08-02 13:40:47 +03001202 scsi_tape_put(STp);
Jonathan Corbetb3369c62008-05-15 16:08:15 -06001203 unlock_kernel();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001204 return retval;
1205
1206}
1207
1208
1209/* Flush the tape buffer before close */
Miklos Szeredi75e1fcc2006-06-23 02:05:12 -07001210static int st_flush(struct file *filp, fl_owner_t id)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001211{
1212 int result = 0, result2;
1213 unsigned char cmd[MAX_COMMAND_SIZE];
Mike Christie8b05b772005-11-08 04:06:44 -06001214 struct st_request *SRpnt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001215 struct scsi_tape *STp = filp->private_data;
1216 struct st_modedef *STm = &(STp->modes[STp->current_mode]);
1217 struct st_partstat *STps = &(STp->ps[STp->partition]);
1218 char *name = tape_name(STp);
1219
1220 if (file_count(filp) > 1)
1221 return 0;
1222
1223 if (STps->rw == ST_WRITING && !STp->pos_unknown) {
Adrian Bunk8ef8d592008-04-14 17:17:16 +03001224 result = st_flush_write_buffer(STp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001225 if (result != 0 && result != (-ENOSPC))
1226 goto out;
1227 }
1228
1229 if (STp->can_partitions &&
1230 (result2 = switch_partition(STp)) < 0) {
1231 DEBC(printk(ST_DEB_MSG
1232 "%s: switch_partition at close failed.\n", name));
1233 if (result == 0)
1234 result = result2;
1235 goto out;
1236 }
1237
1238 DEBC( if (STp->nbr_requests)
Kai Makisaradeee13d2008-02-22 20:11:21 +02001239 printk(KERN_DEBUG "%s: Number of r/w requests %d, dio used in %d, pages %d.\n",
1240 name, STp->nbr_requests, STp->nbr_dio, STp->nbr_pages));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001241
1242 if (STps->rw == ST_WRITING && !STp->pos_unknown) {
1243 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
1244
1245 DEBC(printk(ST_DEB_MSG "%s: Async write waits %d, finished %d.\n",
1246 name, STp->nbr_waits, STp->nbr_finished);
1247 )
1248
1249 memset(cmd, 0, MAX_COMMAND_SIZE);
1250 cmd[0] = WRITE_FILEMARKS;
1251 cmd[4] = 1 + STp->two_fm;
1252
1253 SRpnt = st_do_scsi(NULL, STp, cmd, 0, DMA_NONE,
James Bottomleya02488e2008-11-30 10:36:26 -06001254 STp->device->request_queue->rq_timeout,
1255 MAX_WRITE_RETRIES, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001256 if (!SRpnt) {
1257 result = (STp->buffer)->syscall_result;
1258 goto out;
1259 }
1260
1261 if (STp->buffer->syscall_result == 0 ||
1262 (cmdstatp->have_sense && !cmdstatp->deferred &&
1263 (cmdstatp->flags & SENSE_EOM) &&
1264 (cmdstatp->sense_hdr.sense_key == NO_SENSE ||
1265 cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR) &&
1266 (!cmdstatp->remainder_valid || cmdstatp->uremainder64 == 0))) {
1267 /* Write successful at EOM */
Mike Christie8b05b772005-11-08 04:06:44 -06001268 st_release_request(SRpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001269 SRpnt = NULL;
1270 if (STps->drv_file >= 0)
1271 STps->drv_file++;
1272 STps->drv_block = 0;
1273 if (STp->two_fm)
1274 cross_eof(STp, 0);
1275 STps->eof = ST_FM;
1276 }
1277 else { /* Write error */
Mike Christie8b05b772005-11-08 04:06:44 -06001278 st_release_request(SRpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001279 SRpnt = NULL;
1280 printk(KERN_ERR "%s: Error on write filemark.\n", name);
1281 if (result == 0)
1282 result = (-EIO);
1283 }
1284
1285 DEBC(printk(ST_DEB_MSG "%s: Buffer flushed, %d EOF(s) written\n",
1286 name, cmd[4]));
1287 } else if (!STp->rew_at_close) {
1288 STps = &(STp->ps[STp->partition]);
1289 if (!STm->sysv || STps->rw != ST_READING) {
1290 if (STp->can_bsr)
1291 result = flush_buffer(STp, 0);
1292 else if (STps->eof == ST_FM_HIT) {
1293 result = cross_eof(STp, 0);
1294 if (result) {
1295 if (STps->drv_file >= 0)
1296 STps->drv_file++;
1297 STps->drv_block = 0;
1298 STps->eof = ST_FM;
1299 } else
1300 STps->eof = ST_NOEOF;
1301 }
1302 } else if ((STps->eof == ST_NOEOF &&
1303 !(result = cross_eof(STp, 1))) ||
1304 STps->eof == ST_FM_HIT) {
1305 if (STps->drv_file >= 0)
1306 STps->drv_file++;
1307 STps->drv_block = 0;
1308 STps->eof = ST_FM;
1309 }
1310 }
1311
1312 out:
1313 if (STp->rew_at_close) {
1314 result2 = st_int_ioctl(STp, MTREW, 1);
1315 if (result == 0)
1316 result = result2;
1317 }
1318 return result;
1319}
1320
1321
1322/* Close the device and release it. BKL is not needed: this is the only thread
1323 accessing this tape. */
1324static int st_release(struct inode *inode, struct file *filp)
1325{
1326 int result = 0;
1327 struct scsi_tape *STp = filp->private_data;
1328
1329 if (STp->door_locked == ST_LOCKED_AUTO)
1330 do_door_lock(STp, 0);
1331
1332 normalize_buffer(STp->buffer);
1333 write_lock(&st_dev_arr_lock);
1334 STp->in_use = 0;
1335 write_unlock(&st_dev_arr_lock);
Kai Makisaraf03a5672005-08-02 13:40:47 +03001336 scsi_tape_put(STp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001337
1338 return result;
1339}
1340
1341/* The checks common to both reading and writing */
1342static ssize_t rw_checks(struct scsi_tape *STp, struct file *filp, size_t count)
1343{
1344 ssize_t retval = 0;
1345
1346 /*
1347 * If we are in the middle of error recovery, don't let anyone
1348 * else try and use this device. Also, if error recovery fails, it
1349 * may try and take the device offline, in which case all further
1350 * access to the device is prohibited.
1351 */
1352 if (!scsi_block_when_processing_errors(STp->device)) {
1353 retval = (-ENXIO);
1354 goto out;
1355 }
1356
1357 if (STp->ready != ST_READY) {
1358 if (STp->ready == ST_NO_TAPE)
1359 retval = (-ENOMEDIUM);
1360 else
1361 retval = (-EIO);
1362 goto out;
1363 }
1364
1365 if (! STp->modes[STp->current_mode].defined) {
1366 retval = (-ENXIO);
1367 goto out;
1368 }
1369
1370
1371 /*
1372 * If there was a bus reset, block further access
1373 * to this device.
1374 */
1375 if (STp->pos_unknown) {
1376 retval = (-EIO);
1377 goto out;
1378 }
1379
1380 if (count == 0)
1381 goto out;
1382
1383 DEB(
1384 if (!STp->in_use) {
1385 printk(ST_DEB_MSG "%s: Incorrect device.\n", tape_name(STp));
1386 retval = (-EIO);
1387 goto out;
1388 } ) /* end DEB */
1389
1390 if (STp->can_partitions &&
1391 (retval = switch_partition(STp)) < 0)
1392 goto out;
1393
1394 if (STp->block_size == 0 && STp->max_block > 0 &&
1395 (count < STp->min_block || count > STp->max_block)) {
1396 retval = (-EINVAL);
1397 goto out;
1398 }
1399
1400 if (STp->do_auto_lock && STp->door_locked == ST_UNLOCKED &&
1401 !do_door_lock(STp, 1))
1402 STp->door_locked = ST_LOCKED_AUTO;
1403
1404 out:
1405 return retval;
1406}
1407
1408
1409static int setup_buffering(struct scsi_tape *STp, const char __user *buf,
1410 size_t count, int is_read)
1411{
1412 int i, bufsize, retval = 0;
1413 struct st_buffer *STbp = STp->buffer;
1414
1415 if (is_read)
Kai Makisara9abe16c2007-02-03 13:21:29 +02001416 i = STp->try_dio_now && try_rdio;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001417 else
Kai Makisara9abe16c2007-02-03 13:21:29 +02001418 i = STp->try_dio_now && try_wdio;
Mike Christie8b05b772005-11-08 04:06:44 -06001419
Linus Torvalds1da177e2005-04-16 15:20:36 -07001420 if (i && ((unsigned long)buf & queue_dma_alignment(
1421 STp->device->request_queue)) == 0) {
Mike Christie8b05b772005-11-08 04:06:44 -06001422 i = sgl_map_user_pages(&(STbp->sg[0]), STbp->use_sg,
1423 (unsigned long)buf, count, (is_read ? READ : WRITE));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001424 if (i > 0) {
1425 STbp->do_dio = i;
1426 STbp->buffer_bytes = 0; /* can be used as transfer counter */
1427 }
1428 else
1429 STbp->do_dio = 0; /* fall back to buffering with any error */
1430 STbp->sg_segs = STbp->do_dio;
1431 STbp->frp_sg_current = 0;
1432 DEB(
1433 if (STbp->do_dio) {
1434 STp->nbr_dio++;
1435 STp->nbr_pages += STbp->do_dio;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001436 }
1437 )
1438 } else
1439 STbp->do_dio = 0;
1440 DEB( STp->nbr_requests++; )
1441
1442 if (!STbp->do_dio) {
1443 if (STp->block_size)
1444 bufsize = STp->block_size > st_fixed_buffer_size ?
1445 STp->block_size : st_fixed_buffer_size;
Kai Makisara40f6b362008-02-24 22:23:24 +02001446 else {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001447 bufsize = count;
Kai Makisara40f6b362008-02-24 22:23:24 +02001448 /* Make sure that data from previous user is not leaked even if
1449 HBA does not return correct residual */
1450 if (is_read && STp->sili && !STbp->cleared)
1451 clear_buffer(STbp);
1452 }
1453
Linus Torvalds1da177e2005-04-16 15:20:36 -07001454 if (bufsize > STbp->buffer_size &&
1455 !enlarge_buffer(STbp, bufsize, STp->restr_dma)) {
1456 printk(KERN_WARNING "%s: Can't allocate %d byte tape buffer.\n",
1457 tape_name(STp), bufsize);
1458 retval = (-EOVERFLOW);
1459 goto out;
1460 }
1461 if (STp->block_size)
1462 STbp->buffer_blocks = bufsize / STp->block_size;
1463 }
1464
1465 out:
1466 return retval;
1467}
1468
1469
1470/* Can be called more than once after each setup_buffer() */
Kai Makisara787926b2005-11-13 10:04:44 +02001471static void release_buffering(struct scsi_tape *STp, int is_read)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001472{
1473 struct st_buffer *STbp;
1474
1475 STbp = STp->buffer;
1476 if (STbp->do_dio) {
Kai Makisara787926b2005-11-13 10:04:44 +02001477 sgl_unmap_user_pages(&(STbp->sg[0]), STbp->do_dio, is_read);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001478 STbp->do_dio = 0;
Kai Makisara787926b2005-11-13 10:04:44 +02001479 STbp->sg_segs = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001480 }
1481}
1482
1483
1484/* Write command */
1485static ssize_t
1486st_write(struct file *filp, const char __user *buf, size_t count, loff_t * ppos)
1487{
1488 ssize_t total;
1489 ssize_t i, do_count, blks, transfer;
1490 ssize_t retval;
1491 int undone, retry_eot = 0, scode;
1492 int async_write;
1493 unsigned char cmd[MAX_COMMAND_SIZE];
1494 const char __user *b_point;
Mike Christie8b05b772005-11-08 04:06:44 -06001495 struct st_request *SRpnt = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001496 struct scsi_tape *STp = filp->private_data;
1497 struct st_modedef *STm;
1498 struct st_partstat *STps;
1499 struct st_buffer *STbp;
1500 char *name = tape_name(STp);
1501
Matthias Kaehlcke28f85002007-07-29 23:38:15 +02001502 if (mutex_lock_interruptible(&STp->lock))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001503 return -ERESTARTSYS;
1504
1505 retval = rw_checks(STp, filp, count);
1506 if (retval || count == 0)
1507 goto out;
1508
1509 /* Write must be integral number of blocks */
1510 if (STp->block_size != 0 && (count % STp->block_size) != 0) {
1511 printk(KERN_WARNING "%s: Write not multiple of tape block size.\n",
1512 name);
1513 retval = (-EINVAL);
1514 goto out;
1515 }
1516
1517 STm = &(STp->modes[STp->current_mode]);
1518 STps = &(STp->ps[STp->partition]);
1519
1520 if (STp->write_prot) {
1521 retval = (-EACCES);
1522 goto out;
1523 }
1524
1525
1526 if (STps->rw == ST_READING) {
1527 retval = flush_buffer(STp, 0);
1528 if (retval)
1529 goto out;
1530 STps->rw = ST_WRITING;
1531 } else if (STps->rw != ST_WRITING &&
1532 STps->drv_file == 0 && STps->drv_block == 0) {
1533 if ((retval = set_mode_densblk(STp, STm)) < 0)
1534 goto out;
1535 if (STm->default_compression != ST_DONT_TOUCH &&
1536 !(STp->compression_changed)) {
1537 if (st_compression(STp, (STm->default_compression == ST_YES))) {
1538 printk(KERN_WARNING "%s: Can't set default compression.\n",
1539 name);
1540 if (modes_defined) {
1541 retval = (-EINVAL);
1542 goto out;
1543 }
1544 }
1545 }
1546 }
1547
1548 STbp = STp->buffer;
1549 i = write_behind_check(STp);
1550 if (i) {
1551 if (i == -ENOSPC)
1552 STps->eof = ST_EOM_OK;
1553 else
1554 STps->eof = ST_EOM_ERROR;
1555 }
1556
1557 if (STps->eof == ST_EOM_OK) {
1558 STps->eof = ST_EOD_1; /* allow next write */
1559 retval = (-ENOSPC);
1560 goto out;
1561 }
1562 else if (STps->eof == ST_EOM_ERROR) {
1563 retval = (-EIO);
1564 goto out;
1565 }
1566
1567 /* Check the buffer readability in cases where copy_user might catch
1568 the problems after some tape movement. */
1569 if (STp->block_size != 0 &&
1570 !STbp->do_dio &&
1571 (copy_from_user(&i, buf, 1) != 0 ||
1572 copy_from_user(&i, buf + count - 1, 1) != 0)) {
1573 retval = (-EFAULT);
1574 goto out;
1575 }
1576
1577 retval = setup_buffering(STp, buf, count, 0);
1578 if (retval)
1579 goto out;
1580
1581 total = count;
1582
1583 memset(cmd, 0, MAX_COMMAND_SIZE);
1584 cmd[0] = WRITE_6;
1585 cmd[1] = (STp->block_size != 0);
1586
1587 STps->rw = ST_WRITING;
1588
1589 b_point = buf;
1590 while (count > 0 && !retry_eot) {
1591
1592 if (STbp->do_dio) {
1593 do_count = count;
1594 }
1595 else {
1596 if (STp->block_size == 0)
1597 do_count = count;
1598 else {
1599 do_count = STbp->buffer_blocks * STp->block_size -
1600 STbp->buffer_bytes;
1601 if (do_count > count)
1602 do_count = count;
1603 }
1604
1605 i = append_to_buffer(b_point, STbp, do_count);
1606 if (i) {
1607 retval = i;
1608 goto out;
1609 }
1610 }
1611 count -= do_count;
1612 b_point += do_count;
1613
1614 async_write = STp->block_size == 0 && !STbp->do_dio &&
1615 STm->do_async_writes && STps->eof < ST_EOM_OK;
1616
1617 if (STp->block_size != 0 && STm->do_buffer_writes &&
Kai Makisara9abe16c2007-02-03 13:21:29 +02001618 !(STp->try_dio_now && try_wdio) && STps->eof < ST_EOM_OK &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001619 STbp->buffer_bytes < STbp->buffer_size) {
1620 STp->dirty = 1;
1621 /* Don't write a buffer that is not full enough. */
1622 if (!async_write && count == 0)
1623 break;
1624 }
1625
1626 retry_write:
1627 if (STp->block_size == 0)
1628 blks = transfer = do_count;
1629 else {
1630 if (!STbp->do_dio)
1631 blks = STbp->buffer_bytes;
1632 else
1633 blks = do_count;
1634 blks /= STp->block_size;
1635 transfer = blks * STp->block_size;
1636 }
1637 cmd[2] = blks >> 16;
1638 cmd[3] = blks >> 8;
1639 cmd[4] = blks;
1640
1641 SRpnt = st_do_scsi(SRpnt, STp, cmd, transfer, DMA_TO_DEVICE,
James Bottomleya02488e2008-11-30 10:36:26 -06001642 STp->device->request_queue->rq_timeout,
1643 MAX_WRITE_RETRIES, !async_write);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001644 if (!SRpnt) {
1645 retval = STbp->syscall_result;
1646 goto out;
1647 }
Mike Christie8b05b772005-11-08 04:06:44 -06001648 if (async_write && !STbp->syscall_result) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001649 STbp->writing = transfer;
1650 STp->dirty = !(STbp->writing ==
1651 STbp->buffer_bytes);
1652 SRpnt = NULL; /* Prevent releasing this request! */
1653 DEB( STp->write_pending = 1; )
1654 break;
1655 }
1656
1657 if (STbp->syscall_result != 0) {
1658 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
1659
1660 DEBC(printk(ST_DEB_MSG "%s: Error on write:\n", name));
1661 if (cmdstatp->have_sense && (cmdstatp->flags & SENSE_EOM)) {
1662 scode = cmdstatp->sense_hdr.sense_key;
1663 if (cmdstatp->remainder_valid)
1664 undone = (int)cmdstatp->uremainder64;
1665 else if (STp->block_size == 0 &&
1666 scode == VOLUME_OVERFLOW)
1667 undone = transfer;
1668 else
1669 undone = 0;
1670 if (STp->block_size != 0)
1671 undone *= STp->block_size;
1672 if (undone <= do_count) {
1673 /* Only data from this write is not written */
1674 count += undone;
Kai Makisara626dcb12008-07-11 15:05:25 +03001675 b_point -= undone;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001676 do_count -= undone;
1677 if (STp->block_size)
1678 blks = (transfer - undone) / STp->block_size;
1679 STps->eof = ST_EOM_OK;
1680 /* Continue in fixed block mode if all written
1681 in this request but still something left to write
1682 (retval left to zero)
1683 */
1684 if (STp->block_size == 0 ||
1685 undone > 0 || count == 0)
1686 retval = (-ENOSPC); /* EOM within current request */
1687 DEBC(printk(ST_DEB_MSG
1688 "%s: EOM with %d bytes unwritten.\n",
1689 name, (int)count));
1690 } else {
1691 /* EOT within data buffered earlier (possible only
1692 in fixed block mode without direct i/o) */
1693 if (!retry_eot && !cmdstatp->deferred &&
1694 (scode == NO_SENSE || scode == RECOVERED_ERROR)) {
1695 move_buffer_data(STp->buffer, transfer - undone);
1696 retry_eot = 1;
1697 if (STps->drv_block >= 0) {
1698 STps->drv_block += (transfer - undone) /
1699 STp->block_size;
1700 }
1701 STps->eof = ST_EOM_OK;
1702 DEBC(printk(ST_DEB_MSG
1703 "%s: Retry write of %d bytes at EOM.\n",
1704 name, STp->buffer->buffer_bytes));
1705 goto retry_write;
1706 }
1707 else {
1708 /* Either error within data buffered by driver or
1709 failed retry */
1710 count -= do_count;
1711 blks = do_count = 0;
1712 STps->eof = ST_EOM_ERROR;
1713 STps->drv_block = (-1); /* Too cautious? */
1714 retval = (-EIO); /* EOM for old data */
1715 DEBC(printk(ST_DEB_MSG
1716 "%s: EOM with lost data.\n",
1717 name));
1718 }
1719 }
1720 } else {
1721 count += do_count;
1722 STps->drv_block = (-1); /* Too cautious? */
Mike Christie8b05b772005-11-08 04:06:44 -06001723 retval = STbp->syscall_result;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001724 }
1725
1726 }
1727
1728 if (STps->drv_block >= 0) {
1729 if (STp->block_size == 0)
1730 STps->drv_block += (do_count > 0);
1731 else
1732 STps->drv_block += blks;
1733 }
1734
1735 STbp->buffer_bytes = 0;
1736 STp->dirty = 0;
1737
1738 if (retval || retry_eot) {
1739 if (count < total)
1740 retval = total - count;
1741 goto out;
1742 }
1743 }
1744
1745 if (STps->eof == ST_EOD_1)
1746 STps->eof = ST_EOM_OK;
1747 else if (STps->eof != ST_EOM_OK)
1748 STps->eof = ST_NOEOF;
1749 retval = total - count;
1750
1751 out:
1752 if (SRpnt != NULL)
Mike Christie8b05b772005-11-08 04:06:44 -06001753 st_release_request(SRpnt);
Kai Makisara787926b2005-11-13 10:04:44 +02001754 release_buffering(STp, 0);
Matthias Kaehlcke28f85002007-07-29 23:38:15 +02001755 mutex_unlock(&STp->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001756
1757 return retval;
1758}
1759
1760/* Read data from the tape. Returns zero in the normal case, one if the
1761 eof status has changed, and the negative error code in case of a
1762 fatal error. Otherwise updates the buffer and the eof state.
1763
1764 Does release user buffer mapping if it is set.
1765*/
1766static long read_tape(struct scsi_tape *STp, long count,
Mike Christie8b05b772005-11-08 04:06:44 -06001767 struct st_request ** aSRpnt)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001768{
1769 int transfer, blks, bytes;
1770 unsigned char cmd[MAX_COMMAND_SIZE];
Mike Christie8b05b772005-11-08 04:06:44 -06001771 struct st_request *SRpnt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001772 struct st_modedef *STm;
1773 struct st_partstat *STps;
1774 struct st_buffer *STbp;
1775 int retval = 0;
1776 char *name = tape_name(STp);
1777
1778 if (count == 0)
1779 return 0;
1780
1781 STm = &(STp->modes[STp->current_mode]);
1782 STps = &(STp->ps[STp->partition]);
1783 if (STps->eof == ST_FM_HIT)
1784 return 1;
1785 STbp = STp->buffer;
1786
1787 if (STp->block_size == 0)
1788 blks = bytes = count;
1789 else {
Kai Makisara9abe16c2007-02-03 13:21:29 +02001790 if (!(STp->try_dio_now && try_rdio) && STm->do_read_ahead) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001791 blks = (STp->buffer)->buffer_blocks;
1792 bytes = blks * STp->block_size;
1793 } else {
1794 bytes = count;
1795 if (!STbp->do_dio && bytes > (STp->buffer)->buffer_size)
1796 bytes = (STp->buffer)->buffer_size;
1797 blks = bytes / STp->block_size;
1798 bytes = blks * STp->block_size;
1799 }
1800 }
1801
1802 memset(cmd, 0, MAX_COMMAND_SIZE);
1803 cmd[0] = READ_6;
1804 cmd[1] = (STp->block_size != 0);
Kai Makisara40f6b362008-02-24 22:23:24 +02001805 if (!cmd[1] && STp->sili)
1806 cmd[1] |= 2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001807 cmd[2] = blks >> 16;
1808 cmd[3] = blks >> 8;
1809 cmd[4] = blks;
1810
1811 SRpnt = *aSRpnt;
1812 SRpnt = st_do_scsi(SRpnt, STp, cmd, bytes, DMA_FROM_DEVICE,
James Bottomleya02488e2008-11-30 10:36:26 -06001813 STp->device->request_queue->rq_timeout,
1814 MAX_RETRIES, 1);
Kai Makisara787926b2005-11-13 10:04:44 +02001815 release_buffering(STp, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001816 *aSRpnt = SRpnt;
1817 if (!SRpnt)
1818 return STbp->syscall_result;
1819
1820 STbp->read_pointer = 0;
1821 STps->at_sm = 0;
1822
1823 /* Something to check */
1824 if (STbp->syscall_result) {
1825 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
1826
1827 retval = 1;
1828 DEBC(printk(ST_DEB_MSG "%s: Sense: %2x %2x %2x %2x %2x %2x %2x %2x\n",
1829 name,
Mike Christie8b05b772005-11-08 04:06:44 -06001830 SRpnt->sense[0], SRpnt->sense[1],
1831 SRpnt->sense[2], SRpnt->sense[3],
1832 SRpnt->sense[4], SRpnt->sense[5],
1833 SRpnt->sense[6], SRpnt->sense[7]));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001834 if (cmdstatp->have_sense) {
1835
1836 if (cmdstatp->sense_hdr.sense_key == BLANK_CHECK)
1837 cmdstatp->flags &= 0xcf; /* No need for EOM in this case */
1838
1839 if (cmdstatp->flags != 0) { /* EOF, EOM, or ILI */
1840 /* Compute the residual count */
1841 if (cmdstatp->remainder_valid)
1842 transfer = (int)cmdstatp->uremainder64;
1843 else
1844 transfer = 0;
1845 if (STp->block_size == 0 &&
1846 cmdstatp->sense_hdr.sense_key == MEDIUM_ERROR)
1847 transfer = bytes;
1848
1849 if (cmdstatp->flags & SENSE_ILI) { /* ILI */
1850 if (STp->block_size == 0) {
1851 if (transfer <= 0) {
1852 if (transfer < 0)
1853 printk(KERN_NOTICE
1854 "%s: Failed to read %d byte block with %d byte transfer.\n",
1855 name, bytes - transfer, bytes);
1856 if (STps->drv_block >= 0)
1857 STps->drv_block += 1;
1858 STbp->buffer_bytes = 0;
1859 return (-ENOMEM);
1860 }
1861 STbp->buffer_bytes = bytes - transfer;
1862 } else {
Mike Christie8b05b772005-11-08 04:06:44 -06001863 st_release_request(SRpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001864 SRpnt = *aSRpnt = NULL;
1865 if (transfer == blks) { /* We did not get anything, error */
1866 printk(KERN_NOTICE "%s: Incorrect block size.\n", name);
1867 if (STps->drv_block >= 0)
1868 STps->drv_block += blks - transfer + 1;
1869 st_int_ioctl(STp, MTBSR, 1);
1870 return (-EIO);
1871 }
1872 /* We have some data, deliver it */
1873 STbp->buffer_bytes = (blks - transfer) *
1874 STp->block_size;
1875 DEBC(printk(ST_DEB_MSG
1876 "%s: ILI but enough data received %ld %d.\n",
1877 name, count, STbp->buffer_bytes));
1878 if (STps->drv_block >= 0)
1879 STps->drv_block += 1;
1880 if (st_int_ioctl(STp, MTBSR, 1))
1881 return (-EIO);
1882 }
1883 } else if (cmdstatp->flags & SENSE_FMK) { /* FM overrides EOM */
1884 if (STps->eof != ST_FM_HIT)
1885 STps->eof = ST_FM_HIT;
1886 else
1887 STps->eof = ST_EOD_2;
1888 if (STp->block_size == 0)
1889 STbp->buffer_bytes = 0;
1890 else
1891 STbp->buffer_bytes =
1892 bytes - transfer * STp->block_size;
1893 DEBC(printk(ST_DEB_MSG
1894 "%s: EOF detected (%d bytes read).\n",
1895 name, STbp->buffer_bytes));
1896 } else if (cmdstatp->flags & SENSE_EOM) {
1897 if (STps->eof == ST_FM)
1898 STps->eof = ST_EOD_1;
1899 else
1900 STps->eof = ST_EOM_OK;
1901 if (STp->block_size == 0)
1902 STbp->buffer_bytes = bytes - transfer;
1903 else
1904 STbp->buffer_bytes =
1905 bytes - transfer * STp->block_size;
1906
1907 DEBC(printk(ST_DEB_MSG "%s: EOM detected (%d bytes read).\n",
1908 name, STbp->buffer_bytes));
1909 }
1910 }
1911 /* end of EOF, EOM, ILI test */
1912 else { /* nonzero sense key */
1913 DEBC(printk(ST_DEB_MSG
1914 "%s: Tape error while reading.\n", name));
1915 STps->drv_block = (-1);
1916 if (STps->eof == ST_FM &&
1917 cmdstatp->sense_hdr.sense_key == BLANK_CHECK) {
1918 DEBC(printk(ST_DEB_MSG
1919 "%s: Zero returned for first BLANK CHECK after EOF.\n",
1920 name));
1921 STps->eof = ST_EOD_2; /* First BLANK_CHECK after FM */
1922 } else /* Some other extended sense code */
1923 retval = (-EIO);
1924 }
1925
1926 if (STbp->buffer_bytes < 0) /* Caused by bogus sense data */
1927 STbp->buffer_bytes = 0;
1928 }
1929 /* End of extended sense test */
1930 else { /* Non-extended sense */
1931 retval = STbp->syscall_result;
1932 }
1933
1934 }
1935 /* End of error handling */
Kai Makisara40f6b362008-02-24 22:23:24 +02001936 else { /* Read successful */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001937 STbp->buffer_bytes = bytes;
Kai Makisara40f6b362008-02-24 22:23:24 +02001938 if (STp->sili) /* In fixed block mode residual is always zero here */
1939 STbp->buffer_bytes -= STp->buffer->cmdstat.residual;
1940 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001941
1942 if (STps->drv_block >= 0) {
1943 if (STp->block_size == 0)
1944 STps->drv_block++;
1945 else
1946 STps->drv_block += STbp->buffer_bytes / STp->block_size;
1947 }
1948 return retval;
1949}
1950
1951
1952/* Read command */
1953static ssize_t
1954st_read(struct file *filp, char __user *buf, size_t count, loff_t * ppos)
1955{
1956 ssize_t total;
1957 ssize_t retval = 0;
1958 ssize_t i, transfer;
1959 int special, do_dio = 0;
Mike Christie8b05b772005-11-08 04:06:44 -06001960 struct st_request *SRpnt = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001961 struct scsi_tape *STp = filp->private_data;
1962 struct st_modedef *STm;
1963 struct st_partstat *STps;
1964 struct st_buffer *STbp = STp->buffer;
1965 DEB( char *name = tape_name(STp); )
1966
Matthias Kaehlcke28f85002007-07-29 23:38:15 +02001967 if (mutex_lock_interruptible(&STp->lock))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001968 return -ERESTARTSYS;
1969
1970 retval = rw_checks(STp, filp, count);
1971 if (retval || count == 0)
1972 goto out;
1973
1974 STm = &(STp->modes[STp->current_mode]);
Kai Makisara9abe16c2007-02-03 13:21:29 +02001975 if (STp->block_size != 0 && (count % STp->block_size) != 0) {
1976 if (!STm->do_read_ahead) {
1977 retval = (-EINVAL); /* Read must be integral number of blocks */
1978 goto out;
1979 }
1980 STp->try_dio_now = 0; /* Direct i/o can't handle split blocks */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001981 }
1982
1983 STps = &(STp->ps[STp->partition]);
1984 if (STps->rw == ST_WRITING) {
1985 retval = flush_buffer(STp, 0);
1986 if (retval)
1987 goto out;
1988 STps->rw = ST_READING;
1989 }
1990 DEB(
1991 if (debugging && STps->eof != ST_NOEOF)
1992 printk(ST_DEB_MSG "%s: EOF/EOM flag up (%d). Bytes %d\n", name,
1993 STps->eof, STbp->buffer_bytes);
1994 ) /* end DEB */
1995
1996 retval = setup_buffering(STp, buf, count, 1);
1997 if (retval)
1998 goto out;
1999 do_dio = STbp->do_dio;
2000
2001 if (STbp->buffer_bytes == 0 &&
2002 STps->eof >= ST_EOD_1) {
2003 if (STps->eof < ST_EOD) {
2004 STps->eof += 1;
2005 retval = 0;
2006 goto out;
2007 }
2008 retval = (-EIO); /* EOM or Blank Check */
2009 goto out;
2010 }
2011
2012 if (do_dio) {
2013 /* Check the buffer writability before any tape movement. Don't alter
2014 buffer data. */
2015 if (copy_from_user(&i, buf, 1) != 0 ||
2016 copy_to_user(buf, &i, 1) != 0 ||
2017 copy_from_user(&i, buf + count - 1, 1) != 0 ||
2018 copy_to_user(buf + count - 1, &i, 1) != 0) {
2019 retval = (-EFAULT);
2020 goto out;
2021 }
2022 }
2023
2024 STps->rw = ST_READING;
2025
2026
2027 /* Loop until enough data in buffer or a special condition found */
2028 for (total = 0, special = 0; total < count && !special;) {
2029
2030 /* Get new data if the buffer is empty */
2031 if (STbp->buffer_bytes == 0) {
2032 special = read_tape(STp, count - total, &SRpnt);
2033 if (special < 0) { /* No need to continue read */
2034 retval = special;
2035 goto out;
2036 }
2037 }
2038
2039 /* Move the data from driver buffer to user buffer */
2040 if (STbp->buffer_bytes > 0) {
2041 DEB(
2042 if (debugging && STps->eof != ST_NOEOF)
2043 printk(ST_DEB_MSG
2044 "%s: EOF up (%d). Left %d, needed %d.\n", name,
2045 STps->eof, STbp->buffer_bytes,
2046 (int)(count - total));
2047 ) /* end DEB */
2048 transfer = STbp->buffer_bytes < count - total ?
2049 STbp->buffer_bytes : count - total;
2050 if (!do_dio) {
2051 i = from_buffer(STbp, buf, transfer);
2052 if (i) {
2053 retval = i;
2054 goto out;
2055 }
2056 }
2057 buf += transfer;
2058 total += transfer;
2059 }
2060
2061 if (STp->block_size == 0)
2062 break; /* Read only one variable length block */
2063
2064 } /* for (total = 0, special = 0;
2065 total < count && !special; ) */
2066
2067 /* Change the eof state if no data from tape or buffer */
2068 if (total == 0) {
2069 if (STps->eof == ST_FM_HIT) {
2070 STps->eof = ST_FM;
2071 STps->drv_block = 0;
2072 if (STps->drv_file >= 0)
2073 STps->drv_file++;
2074 } else if (STps->eof == ST_EOD_1) {
2075 STps->eof = ST_EOD_2;
2076 STps->drv_block = 0;
2077 if (STps->drv_file >= 0)
2078 STps->drv_file++;
2079 } else if (STps->eof == ST_EOD_2)
2080 STps->eof = ST_EOD;
2081 } else if (STps->eof == ST_FM)
2082 STps->eof = ST_NOEOF;
2083 retval = total;
2084
2085 out:
2086 if (SRpnt != NULL) {
Mike Christie8b05b772005-11-08 04:06:44 -06002087 st_release_request(SRpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002088 SRpnt = NULL;
2089 }
2090 if (do_dio) {
Kai Makisara787926b2005-11-13 10:04:44 +02002091 release_buffering(STp, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002092 STbp->buffer_bytes = 0;
2093 }
Matthias Kaehlcke28f85002007-07-29 23:38:15 +02002094 mutex_unlock(&STp->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002095
2096 return retval;
2097}
2098
2099
2100
2101DEB(
2102/* Set the driver options */
2103static void st_log_options(struct scsi_tape * STp, struct st_modedef * STm, char *name)
2104{
2105 if (debugging) {
2106 printk(KERN_INFO
2107 "%s: Mode %d options: buffer writes: %d, async writes: %d, read ahead: %d\n",
2108 name, STp->current_mode, STm->do_buffer_writes, STm->do_async_writes,
2109 STm->do_read_ahead);
2110 printk(KERN_INFO
2111 "%s: can bsr: %d, two FMs: %d, fast mteom: %d, auto lock: %d,\n",
2112 name, STp->can_bsr, STp->two_fm, STp->fast_mteom, STp->do_auto_lock);
2113 printk(KERN_INFO
2114 "%s: defs for wr: %d, no block limits: %d, partitions: %d, s2 log: %d\n",
2115 name, STm->defaults_for_writes, STp->omit_blklims, STp->can_partitions,
2116 STp->scsi2_logical);
2117 printk(KERN_INFO
Kai Makisara40f6b362008-02-24 22:23:24 +02002118 "%s: sysv: %d nowait: %d sili: %d\n", name, STm->sysv, STp->immediate,
2119 STp->sili);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002120 printk(KERN_INFO "%s: debugging: %d\n",
2121 name, debugging);
2122 }
2123}
2124 )
2125
2126
2127static int st_set_options(struct scsi_tape *STp, long options)
2128{
2129 int value;
2130 long code;
2131 struct st_modedef *STm;
2132 char *name = tape_name(STp);
2133 struct cdev *cd0, *cd1;
2134
2135 STm = &(STp->modes[STp->current_mode]);
2136 if (!STm->defined) {
2137 cd0 = STm->cdevs[0]; cd1 = STm->cdevs[1];
2138 memcpy(STm, &(STp->modes[0]), sizeof(struct st_modedef));
2139 STm->cdevs[0] = cd0; STm->cdevs[1] = cd1;
2140 modes_defined = 1;
2141 DEBC(printk(ST_DEB_MSG
2142 "%s: Initialized mode %d definition from mode 0\n",
2143 name, STp->current_mode));
2144 }
2145
2146 code = options & MT_ST_OPTIONS;
2147 if (code == MT_ST_BOOLEANS) {
2148 STm->do_buffer_writes = (options & MT_ST_BUFFER_WRITES) != 0;
2149 STm->do_async_writes = (options & MT_ST_ASYNC_WRITES) != 0;
2150 STm->defaults_for_writes = (options & MT_ST_DEF_WRITES) != 0;
2151 STm->do_read_ahead = (options & MT_ST_READ_AHEAD) != 0;
2152 STp->two_fm = (options & MT_ST_TWO_FM) != 0;
2153 STp->fast_mteom = (options & MT_ST_FAST_MTEOM) != 0;
2154 STp->do_auto_lock = (options & MT_ST_AUTO_LOCK) != 0;
2155 STp->can_bsr = (options & MT_ST_CAN_BSR) != 0;
2156 STp->omit_blklims = (options & MT_ST_NO_BLKLIMS) != 0;
2157 if ((STp->device)->scsi_level >= SCSI_2)
2158 STp->can_partitions = (options & MT_ST_CAN_PARTITIONS) != 0;
2159 STp->scsi2_logical = (options & MT_ST_SCSI2LOGICAL) != 0;
2160 STp->immediate = (options & MT_ST_NOWAIT) != 0;
2161 STm->sysv = (options & MT_ST_SYSV) != 0;
Kai Makisara40f6b362008-02-24 22:23:24 +02002162 STp->sili = (options & MT_ST_SILI) != 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002163 DEB( debugging = (options & MT_ST_DEBUGGING) != 0;
2164 st_log_options(STp, STm, name); )
2165 } else if (code == MT_ST_SETBOOLEANS || code == MT_ST_CLEARBOOLEANS) {
2166 value = (code == MT_ST_SETBOOLEANS);
2167 if ((options & MT_ST_BUFFER_WRITES) != 0)
2168 STm->do_buffer_writes = value;
2169 if ((options & MT_ST_ASYNC_WRITES) != 0)
2170 STm->do_async_writes = value;
2171 if ((options & MT_ST_DEF_WRITES) != 0)
2172 STm->defaults_for_writes = value;
2173 if ((options & MT_ST_READ_AHEAD) != 0)
2174 STm->do_read_ahead = value;
2175 if ((options & MT_ST_TWO_FM) != 0)
2176 STp->two_fm = value;
2177 if ((options & MT_ST_FAST_MTEOM) != 0)
2178 STp->fast_mteom = value;
2179 if ((options & MT_ST_AUTO_LOCK) != 0)
2180 STp->do_auto_lock = value;
2181 if ((options & MT_ST_CAN_BSR) != 0)
2182 STp->can_bsr = value;
2183 if ((options & MT_ST_NO_BLKLIMS) != 0)
2184 STp->omit_blklims = value;
2185 if ((STp->device)->scsi_level >= SCSI_2 &&
2186 (options & MT_ST_CAN_PARTITIONS) != 0)
2187 STp->can_partitions = value;
2188 if ((options & MT_ST_SCSI2LOGICAL) != 0)
2189 STp->scsi2_logical = value;
2190 if ((options & MT_ST_NOWAIT) != 0)
2191 STp->immediate = value;
2192 if ((options & MT_ST_SYSV) != 0)
2193 STm->sysv = value;
Kai Makisara40f6b362008-02-24 22:23:24 +02002194 if ((options & MT_ST_SILI) != 0)
2195 STp->sili = value;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002196 DEB(
2197 if ((options & MT_ST_DEBUGGING) != 0)
2198 debugging = value;
2199 st_log_options(STp, STm, name); )
2200 } else if (code == MT_ST_WRITE_THRESHOLD) {
2201 /* Retained for compatibility */
2202 } else if (code == MT_ST_DEF_BLKSIZE) {
2203 value = (options & ~MT_ST_OPTIONS);
2204 if (value == ~MT_ST_OPTIONS) {
2205 STm->default_blksize = (-1);
2206 DEBC( printk(KERN_INFO "%s: Default block size disabled.\n", name));
2207 } else {
2208 STm->default_blksize = value;
2209 DEBC( printk(KERN_INFO "%s: Default block size set to %d bytes.\n",
2210 name, STm->default_blksize));
2211 if (STp->ready == ST_READY) {
2212 STp->blksize_changed = 0;
2213 set_mode_densblk(STp, STm);
2214 }
2215 }
2216 } else if (code == MT_ST_TIMEOUTS) {
2217 value = (options & ~MT_ST_OPTIONS);
2218 if ((value & MT_ST_SET_LONG_TIMEOUT) != 0) {
2219 STp->long_timeout = (value & ~MT_ST_SET_LONG_TIMEOUT) * HZ;
2220 DEBC( printk(KERN_INFO "%s: Long timeout set to %d seconds.\n", name,
2221 (value & ~MT_ST_SET_LONG_TIMEOUT)));
2222 } else {
James Bottomleya02488e2008-11-30 10:36:26 -06002223 blk_queue_rq_timeout(STp->device->request_queue,
2224 value * HZ);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002225 DEBC( printk(KERN_INFO "%s: Normal timeout set to %d seconds.\n",
2226 name, value) );
2227 }
2228 } else if (code == MT_ST_SET_CLN) {
2229 value = (options & ~MT_ST_OPTIONS) & 0xff;
2230 if (value != 0 &&
2231 value < EXTENDED_SENSE_START && value >= SCSI_SENSE_BUFFERSIZE)
2232 return (-EINVAL);
2233 STp->cln_mode = value;
2234 STp->cln_sense_mask = (options >> 8) & 0xff;
2235 STp->cln_sense_value = (options >> 16) & 0xff;
2236 printk(KERN_INFO
2237 "%s: Cleaning request mode %d, mask %02x, value %02x\n",
2238 name, value, STp->cln_sense_mask, STp->cln_sense_value);
2239 } else if (code == MT_ST_DEF_OPTIONS) {
2240 code = (options & ~MT_ST_CLEAR_DEFAULT);
2241 value = (options & MT_ST_CLEAR_DEFAULT);
2242 if (code == MT_ST_DEF_DENSITY) {
2243 if (value == MT_ST_CLEAR_DEFAULT) {
2244 STm->default_density = (-1);
2245 DEBC( printk(KERN_INFO "%s: Density default disabled.\n",
2246 name));
2247 } else {
2248 STm->default_density = value & 0xff;
2249 DEBC( printk(KERN_INFO "%s: Density default set to %x\n",
2250 name, STm->default_density));
2251 if (STp->ready == ST_READY) {
2252 STp->density_changed = 0;
2253 set_mode_densblk(STp, STm);
2254 }
2255 }
2256 } else if (code == MT_ST_DEF_DRVBUFFER) {
2257 if (value == MT_ST_CLEAR_DEFAULT) {
2258 STp->default_drvbuffer = 0xff;
2259 DEBC( printk(KERN_INFO
2260 "%s: Drive buffer default disabled.\n", name));
2261 } else {
2262 STp->default_drvbuffer = value & 7;
2263 DEBC( printk(KERN_INFO
2264 "%s: Drive buffer default set to %x\n",
2265 name, STp->default_drvbuffer));
2266 if (STp->ready == ST_READY)
2267 st_int_ioctl(STp, MTSETDRVBUFFER, STp->default_drvbuffer);
2268 }
2269 } else if (code == MT_ST_DEF_COMPRESSION) {
2270 if (value == MT_ST_CLEAR_DEFAULT) {
2271 STm->default_compression = ST_DONT_TOUCH;
2272 DEBC( printk(KERN_INFO
2273 "%s: Compression default disabled.\n", name));
2274 } else {
2275 if ((value & 0xff00) != 0) {
2276 STp->c_algo = (value & 0xff00) >> 8;
2277 DEBC( printk(KERN_INFO "%s: Compression algorithm set to 0x%x.\n",
2278 name, STp->c_algo));
2279 }
2280 if ((value & 0xff) != 0xff) {
2281 STm->default_compression = (value & 1 ? ST_YES : ST_NO);
2282 DEBC( printk(KERN_INFO "%s: Compression default set to %x\n",
2283 name, (value & 1)));
2284 if (STp->ready == ST_READY) {
2285 STp->compression_changed = 0;
2286 st_compression(STp, (STm->default_compression == ST_YES));
2287 }
2288 }
2289 }
2290 }
2291 } else
2292 return (-EIO);
2293
2294 return 0;
2295}
2296
2297#define MODE_HEADER_LENGTH 4
2298
2299/* Mode header and page byte offsets */
2300#define MH_OFF_DATA_LENGTH 0
2301#define MH_OFF_MEDIUM_TYPE 1
2302#define MH_OFF_DEV_SPECIFIC 2
2303#define MH_OFF_BDESCS_LENGTH 3
2304#define MP_OFF_PAGE_NBR 0
2305#define MP_OFF_PAGE_LENGTH 1
2306
2307/* Mode header and page bit masks */
2308#define MH_BIT_WP 0x80
2309#define MP_MSK_PAGE_NBR 0x3f
2310
2311/* Don't return block descriptors */
2312#define MODE_SENSE_OMIT_BDESCS 0x08
2313
2314#define MODE_SELECT_PAGE_FORMAT 0x10
2315
2316/* Read a mode page into the tape buffer. The block descriptors are included
2317 if incl_block_descs is true. The page control is ored to the page number
2318 parameter, if necessary. */
2319static int read_mode_page(struct scsi_tape *STp, int page, int omit_block_descs)
2320{
2321 unsigned char cmd[MAX_COMMAND_SIZE];
Mike Christie8b05b772005-11-08 04:06:44 -06002322 struct st_request *SRpnt = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002323
2324 memset(cmd, 0, MAX_COMMAND_SIZE);
2325 cmd[0] = MODE_SENSE;
2326 if (omit_block_descs)
2327 cmd[1] = MODE_SENSE_OMIT_BDESCS;
2328 cmd[2] = page;
2329 cmd[4] = 255;
2330
2331 SRpnt = st_do_scsi(SRpnt, STp, cmd, cmd[4], DMA_FROM_DEVICE,
James Bottomleya02488e2008-11-30 10:36:26 -06002332 STp->device->request_queue->rq_timeout, 0, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002333 if (SRpnt == NULL)
2334 return (STp->buffer)->syscall_result;
2335
Mike Christie8b05b772005-11-08 04:06:44 -06002336 st_release_request(SRpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002337
2338 return (STp->buffer)->syscall_result;
2339}
2340
2341
2342/* Send the mode page in the tape buffer to the drive. Assumes that the mode data
2343 in the buffer is correctly formatted. The long timeout is used if slow is non-zero. */
2344static int write_mode_page(struct scsi_tape *STp, int page, int slow)
2345{
2346 int pgo;
2347 unsigned char cmd[MAX_COMMAND_SIZE];
Mike Christie8b05b772005-11-08 04:06:44 -06002348 struct st_request *SRpnt = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002349
2350 memset(cmd, 0, MAX_COMMAND_SIZE);
2351 cmd[0] = MODE_SELECT;
2352 cmd[1] = MODE_SELECT_PAGE_FORMAT;
2353 pgo = MODE_HEADER_LENGTH + (STp->buffer)->b_data[MH_OFF_BDESCS_LENGTH];
2354 cmd[4] = pgo + (STp->buffer)->b_data[pgo + MP_OFF_PAGE_LENGTH] + 2;
2355
2356 /* Clear reserved fields */
2357 (STp->buffer)->b_data[MH_OFF_DATA_LENGTH] = 0;
2358 (STp->buffer)->b_data[MH_OFF_MEDIUM_TYPE] = 0;
2359 (STp->buffer)->b_data[MH_OFF_DEV_SPECIFIC] &= ~MH_BIT_WP;
2360 (STp->buffer)->b_data[pgo + MP_OFF_PAGE_NBR] &= MP_MSK_PAGE_NBR;
2361
2362 SRpnt = st_do_scsi(SRpnt, STp, cmd, cmd[4], DMA_TO_DEVICE,
James Bottomleya02488e2008-11-30 10:36:26 -06002363 (slow ? STp->long_timeout : STp->device->request_queue->rq_timeout), 0, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002364 if (SRpnt == NULL)
2365 return (STp->buffer)->syscall_result;
2366
Mike Christie8b05b772005-11-08 04:06:44 -06002367 st_release_request(SRpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002368
2369 return (STp->buffer)->syscall_result;
2370}
2371
2372
2373#define COMPRESSION_PAGE 0x0f
2374#define COMPRESSION_PAGE_LENGTH 16
2375
2376#define CP_OFF_DCE_DCC 2
2377#define CP_OFF_C_ALGO 7
2378
2379#define DCE_MASK 0x80
2380#define DCC_MASK 0x40
2381#define RED_MASK 0x60
2382
2383
2384/* Control the compression with mode page 15. Algorithm not changed if zero.
2385
2386 The block descriptors are read and written because Sony SDT-7000 does not
2387 work without this (suggestion from Michael Schaefer <Michael.Schaefer@dlr.de>).
2388 Including block descriptors should not cause any harm to other drives. */
2389
2390static int st_compression(struct scsi_tape * STp, int state)
2391{
2392 int retval;
2393 int mpoffs; /* Offset to mode page start */
2394 unsigned char *b_data = (STp->buffer)->b_data;
2395 DEB( char *name = tape_name(STp); )
2396
2397 if (STp->ready != ST_READY)
2398 return (-EIO);
2399
2400 /* Read the current page contents */
2401 retval = read_mode_page(STp, COMPRESSION_PAGE, 0);
2402 if (retval) {
2403 DEBC(printk(ST_DEB_MSG "%s: Compression mode page not supported.\n",
2404 name));
2405 return (-EIO);
2406 }
2407
2408 mpoffs = MODE_HEADER_LENGTH + b_data[MH_OFF_BDESCS_LENGTH];
2409 DEBC(printk(ST_DEB_MSG "%s: Compression state is %d.\n", name,
2410 (b_data[mpoffs + CP_OFF_DCE_DCC] & DCE_MASK ? 1 : 0)));
2411
2412 /* Check if compression can be changed */
2413 if ((b_data[mpoffs + CP_OFF_DCE_DCC] & DCC_MASK) == 0) {
2414 DEBC(printk(ST_DEB_MSG "%s: Compression not supported.\n", name));
2415 return (-EIO);
2416 }
2417
2418 /* Do the change */
2419 if (state) {
2420 b_data[mpoffs + CP_OFF_DCE_DCC] |= DCE_MASK;
2421 if (STp->c_algo != 0)
2422 b_data[mpoffs + CP_OFF_C_ALGO] = STp->c_algo;
2423 }
2424 else {
2425 b_data[mpoffs + CP_OFF_DCE_DCC] &= ~DCE_MASK;
2426 if (STp->c_algo != 0)
2427 b_data[mpoffs + CP_OFF_C_ALGO] = 0; /* no compression */
2428 }
2429
2430 retval = write_mode_page(STp, COMPRESSION_PAGE, 0);
2431 if (retval) {
2432 DEBC(printk(ST_DEB_MSG "%s: Compression change failed.\n", name));
2433 return (-EIO);
2434 }
2435 DEBC(printk(ST_DEB_MSG "%s: Compression state changed to %d.\n",
2436 name, state));
2437
2438 STp->compression_changed = 1;
2439 return 0;
2440}
2441
2442
2443/* Process the load and unload commands (does unload if the load code is zero) */
2444static int do_load_unload(struct scsi_tape *STp, struct file *filp, int load_code)
2445{
2446 int retval = (-EIO), timeout;
2447 DEB( char *name = tape_name(STp); )
2448 unsigned char cmd[MAX_COMMAND_SIZE];
2449 struct st_partstat *STps;
Mike Christie8b05b772005-11-08 04:06:44 -06002450 struct st_request *SRpnt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002451
2452 if (STp->ready != ST_READY && !load_code) {
2453 if (STp->ready == ST_NO_TAPE)
2454 return (-ENOMEDIUM);
2455 else
2456 return (-EIO);
2457 }
2458
2459 memset(cmd, 0, MAX_COMMAND_SIZE);
2460 cmd[0] = START_STOP;
2461 if (load_code)
2462 cmd[4] |= 1;
2463 /*
2464 * If arg >= 1 && arg <= 6 Enhanced load/unload in HP C1553A
2465 */
2466 if (load_code >= 1 + MT_ST_HPLOADER_OFFSET
2467 && load_code <= 6 + MT_ST_HPLOADER_OFFSET) {
2468 DEBC(printk(ST_DEB_MSG "%s: Enhanced %sload slot %2d.\n",
2469 name, (cmd[4]) ? "" : "un",
2470 load_code - MT_ST_HPLOADER_OFFSET));
2471 cmd[3] = load_code - MT_ST_HPLOADER_OFFSET; /* MediaID field of C1553A */
2472 }
2473 if (STp->immediate) {
2474 cmd[1] = 1; /* Don't wait for completion */
James Bottomleya02488e2008-11-30 10:36:26 -06002475 timeout = STp->device->request_queue->rq_timeout;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002476 }
2477 else
2478 timeout = STp->long_timeout;
2479
2480 DEBC(
2481 if (!load_code)
2482 printk(ST_DEB_MSG "%s: Unloading tape.\n", name);
2483 else
2484 printk(ST_DEB_MSG "%s: Loading tape.\n", name);
2485 );
2486
2487 SRpnt = st_do_scsi(NULL, STp, cmd, 0, DMA_NONE,
2488 timeout, MAX_RETRIES, 1);
2489 if (!SRpnt)
2490 return (STp->buffer)->syscall_result;
2491
2492 retval = (STp->buffer)->syscall_result;
Mike Christie8b05b772005-11-08 04:06:44 -06002493 st_release_request(SRpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002494
2495 if (!retval) { /* SCSI command successful */
2496
2497 if (!load_code) {
2498 STp->rew_at_close = 0;
2499 STp->ready = ST_NO_TAPE;
2500 }
2501 else {
2502 STp->rew_at_close = STp->autorew_dev;
2503 retval = check_tape(STp, filp);
2504 if (retval > 0)
2505 retval = 0;
2506 }
2507 }
2508 else {
2509 STps = &(STp->ps[STp->partition]);
2510 STps->drv_file = STps->drv_block = (-1);
2511 }
2512
2513 return retval;
2514}
2515
2516#if DEBUG
2517#define ST_DEB_FORWARD 0
2518#define ST_DEB_BACKWARD 1
2519static void deb_space_print(char *name, int direction, char *units, unsigned char *cmd)
2520{
2521 s32 sc;
2522
2523 sc = cmd[2] & 0x80 ? 0xff000000 : 0;
2524 sc |= (cmd[2] << 16) | (cmd[3] << 8) | cmd[4];
2525 if (direction)
2526 sc = -sc;
2527 printk(ST_DEB_MSG "%s: Spacing tape %s over %d %s.\n", name,
2528 direction ? "backward" : "forward", sc, units);
2529}
2530#endif
2531
2532
2533/* Internal ioctl function */
2534static int st_int_ioctl(struct scsi_tape *STp, unsigned int cmd_in, unsigned long arg)
2535{
2536 int timeout;
2537 long ltmp;
2538 int ioctl_result;
2539 int chg_eof = 1;
2540 unsigned char cmd[MAX_COMMAND_SIZE];
Mike Christie8b05b772005-11-08 04:06:44 -06002541 struct st_request *SRpnt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002542 struct st_partstat *STps;
2543 int fileno, blkno, at_sm, undone;
2544 int datalen = 0, direction = DMA_NONE;
2545 char *name = tape_name(STp);
2546
2547 WARN_ON(STp->buffer->do_dio != 0);
2548 if (STp->ready != ST_READY) {
2549 if (STp->ready == ST_NO_TAPE)
2550 return (-ENOMEDIUM);
2551 else
2552 return (-EIO);
2553 }
2554 timeout = STp->long_timeout;
2555 STps = &(STp->ps[STp->partition]);
2556 fileno = STps->drv_file;
2557 blkno = STps->drv_block;
2558 at_sm = STps->at_sm;
2559
2560 memset(cmd, 0, MAX_COMMAND_SIZE);
2561 switch (cmd_in) {
2562 case MTFSFM:
2563 chg_eof = 0; /* Changed from the FSF after this */
2564 case MTFSF:
2565 cmd[0] = SPACE;
2566 cmd[1] = 0x01; /* Space FileMarks */
2567 cmd[2] = (arg >> 16);
2568 cmd[3] = (arg >> 8);
2569 cmd[4] = arg;
2570 DEBC(deb_space_print(name, ST_DEB_FORWARD, "filemarks", cmd);)
2571 if (fileno >= 0)
2572 fileno += arg;
2573 blkno = 0;
2574 at_sm &= (arg == 0);
2575 break;
2576 case MTBSFM:
2577 chg_eof = 0; /* Changed from the FSF after this */
2578 case MTBSF:
2579 cmd[0] = SPACE;
2580 cmd[1] = 0x01; /* Space FileMarks */
2581 ltmp = (-arg);
2582 cmd[2] = (ltmp >> 16);
2583 cmd[3] = (ltmp >> 8);
2584 cmd[4] = ltmp;
2585 DEBC(deb_space_print(name, ST_DEB_BACKWARD, "filemarks", cmd);)
2586 if (fileno >= 0)
2587 fileno -= arg;
2588 blkno = (-1); /* We can't know the block number */
2589 at_sm &= (arg == 0);
2590 break;
2591 case MTFSR:
2592 cmd[0] = SPACE;
2593 cmd[1] = 0x00; /* Space Blocks */
2594 cmd[2] = (arg >> 16);
2595 cmd[3] = (arg >> 8);
2596 cmd[4] = arg;
2597 DEBC(deb_space_print(name, ST_DEB_FORWARD, "blocks", cmd);)
2598 if (blkno >= 0)
2599 blkno += arg;
2600 at_sm &= (arg == 0);
2601 break;
2602 case MTBSR:
2603 cmd[0] = SPACE;
2604 cmd[1] = 0x00; /* Space Blocks */
2605 ltmp = (-arg);
2606 cmd[2] = (ltmp >> 16);
2607 cmd[3] = (ltmp >> 8);
2608 cmd[4] = ltmp;
2609 DEBC(deb_space_print(name, ST_DEB_BACKWARD, "blocks", cmd);)
2610 if (blkno >= 0)
2611 blkno -= arg;
2612 at_sm &= (arg == 0);
2613 break;
2614 case MTFSS:
2615 cmd[0] = SPACE;
2616 cmd[1] = 0x04; /* Space Setmarks */
2617 cmd[2] = (arg >> 16);
2618 cmd[3] = (arg >> 8);
2619 cmd[4] = arg;
2620 DEBC(deb_space_print(name, ST_DEB_FORWARD, "setmarks", cmd);)
2621 if (arg != 0) {
2622 blkno = fileno = (-1);
2623 at_sm = 1;
2624 }
2625 break;
2626 case MTBSS:
2627 cmd[0] = SPACE;
2628 cmd[1] = 0x04; /* Space Setmarks */
2629 ltmp = (-arg);
2630 cmd[2] = (ltmp >> 16);
2631 cmd[3] = (ltmp >> 8);
2632 cmd[4] = ltmp;
2633 DEBC(deb_space_print(name, ST_DEB_BACKWARD, "setmarks", cmd);)
2634 if (arg != 0) {
2635 blkno = fileno = (-1);
2636 at_sm = 1;
2637 }
2638 break;
2639 case MTWEOF:
2640 case MTWSM:
2641 if (STp->write_prot)
2642 return (-EACCES);
2643 cmd[0] = WRITE_FILEMARKS;
2644 if (cmd_in == MTWSM)
2645 cmd[1] = 2;
2646 cmd[2] = (arg >> 16);
2647 cmd[3] = (arg >> 8);
2648 cmd[4] = arg;
James Bottomleya02488e2008-11-30 10:36:26 -06002649 timeout = STp->device->request_queue->rq_timeout;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002650 DEBC(
2651 if (cmd_in == MTWEOF)
2652 printk(ST_DEB_MSG "%s: Writing %d filemarks.\n", name,
2653 cmd[2] * 65536 + cmd[3] * 256 + cmd[4]);
2654 else
2655 printk(ST_DEB_MSG "%s: Writing %d setmarks.\n", name,
2656 cmd[2] * 65536 + cmd[3] * 256 + cmd[4]);
2657 )
2658 if (fileno >= 0)
2659 fileno += arg;
2660 blkno = 0;
2661 at_sm = (cmd_in == MTWSM);
2662 break;
2663 case MTREW:
2664 cmd[0] = REZERO_UNIT;
2665 if (STp->immediate) {
2666 cmd[1] = 1; /* Don't wait for completion */
James Bottomleya02488e2008-11-30 10:36:26 -06002667 timeout = STp->device->request_queue->rq_timeout;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002668 }
2669 DEBC(printk(ST_DEB_MSG "%s: Rewinding tape.\n", name));
2670 fileno = blkno = at_sm = 0;
2671 break;
2672 case MTNOP:
2673 DEBC(printk(ST_DEB_MSG "%s: No op on tape.\n", name));
2674 return 0; /* Should do something ? */
2675 break;
2676 case MTRETEN:
2677 cmd[0] = START_STOP;
2678 if (STp->immediate) {
2679 cmd[1] = 1; /* Don't wait for completion */
James Bottomleya02488e2008-11-30 10:36:26 -06002680 timeout = STp->device->request_queue->rq_timeout;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002681 }
2682 cmd[4] = 3;
2683 DEBC(printk(ST_DEB_MSG "%s: Retensioning tape.\n", name));
2684 fileno = blkno = at_sm = 0;
2685 break;
2686 case MTEOM:
2687 if (!STp->fast_mteom) {
2688 /* space to the end of tape */
2689 ioctl_result = st_int_ioctl(STp, MTFSF, 0x7fffff);
2690 fileno = STps->drv_file;
2691 if (STps->eof >= ST_EOD_1)
2692 return 0;
2693 /* The next lines would hide the number of spaced FileMarks
2694 That's why I inserted the previous lines. I had no luck
2695 with detecting EOM with FSF, so we go now to EOM.
2696 Joerg Weule */
2697 } else
2698 fileno = (-1);
2699 cmd[0] = SPACE;
2700 cmd[1] = 3;
2701 DEBC(printk(ST_DEB_MSG "%s: Spacing to end of recorded medium.\n",
2702 name));
2703 blkno = -1;
2704 at_sm = 0;
2705 break;
2706 case MTERASE:
2707 if (STp->write_prot)
2708 return (-EACCES);
2709 cmd[0] = ERASE;
2710 cmd[1] = (arg ? 1 : 0); /* Long erase with non-zero argument */
2711 if (STp->immediate) {
2712 cmd[1] |= 2; /* Don't wait for completion */
James Bottomleya02488e2008-11-30 10:36:26 -06002713 timeout = STp->device->request_queue->rq_timeout;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002714 }
2715 else
2716 timeout = STp->long_timeout * 8;
2717
2718 DEBC(printk(ST_DEB_MSG "%s: Erasing tape.\n", name));
2719 fileno = blkno = at_sm = 0;
2720 break;
2721 case MTSETBLK: /* Set block length */
2722 case MTSETDENSITY: /* Set tape density */
2723 case MTSETDRVBUFFER: /* Set drive buffering */
2724 case SET_DENS_AND_BLK: /* Set density and block size */
2725 chg_eof = 0;
2726 if (STp->dirty || (STp->buffer)->buffer_bytes != 0)
2727 return (-EIO); /* Not allowed if data in buffer */
2728 if ((cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) &&
2729 (arg & MT_ST_BLKSIZE_MASK) != 0 &&
2730 STp->max_block > 0 &&
2731 ((arg & MT_ST_BLKSIZE_MASK) < STp->min_block ||
2732 (arg & MT_ST_BLKSIZE_MASK) > STp->max_block)) {
2733 printk(KERN_WARNING "%s: Illegal block size.\n", name);
2734 return (-EINVAL);
2735 }
2736 cmd[0] = MODE_SELECT;
2737 if ((STp->use_pf & USE_PF))
2738 cmd[1] = MODE_SELECT_PAGE_FORMAT;
2739 cmd[4] = datalen = 12;
2740 direction = DMA_TO_DEVICE;
2741
2742 memset((STp->buffer)->b_data, 0, 12);
2743 if (cmd_in == MTSETDRVBUFFER)
2744 (STp->buffer)->b_data[2] = (arg & 7) << 4;
2745 else
2746 (STp->buffer)->b_data[2] =
2747 STp->drv_buffer << 4;
2748 (STp->buffer)->b_data[3] = 8; /* block descriptor length */
2749 if (cmd_in == MTSETDENSITY) {
2750 (STp->buffer)->b_data[4] = arg;
2751 STp->density_changed = 1; /* At least we tried ;-) */
2752 } else if (cmd_in == SET_DENS_AND_BLK)
2753 (STp->buffer)->b_data[4] = arg >> 24;
2754 else
2755 (STp->buffer)->b_data[4] = STp->density;
2756 if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) {
2757 ltmp = arg & MT_ST_BLKSIZE_MASK;
2758 if (cmd_in == MTSETBLK)
2759 STp->blksize_changed = 1; /* At least we tried ;-) */
2760 } else
2761 ltmp = STp->block_size;
2762 (STp->buffer)->b_data[9] = (ltmp >> 16);
2763 (STp->buffer)->b_data[10] = (ltmp >> 8);
2764 (STp->buffer)->b_data[11] = ltmp;
James Bottomleya02488e2008-11-30 10:36:26 -06002765 timeout = STp->device->request_queue->rq_timeout;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002766 DEBC(
2767 if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK)
2768 printk(ST_DEB_MSG
2769 "%s: Setting block size to %d bytes.\n", name,
2770 (STp->buffer)->b_data[9] * 65536 +
2771 (STp->buffer)->b_data[10] * 256 +
2772 (STp->buffer)->b_data[11]);
2773 if (cmd_in == MTSETDENSITY || cmd_in == SET_DENS_AND_BLK)
2774 printk(ST_DEB_MSG
2775 "%s: Setting density code to %x.\n", name,
2776 (STp->buffer)->b_data[4]);
2777 if (cmd_in == MTSETDRVBUFFER)
2778 printk(ST_DEB_MSG
2779 "%s: Setting drive buffer code to %d.\n", name,
2780 ((STp->buffer)->b_data[2] >> 4) & 7);
2781 )
2782 break;
2783 default:
2784 return (-ENOSYS);
2785 }
2786
2787 SRpnt = st_do_scsi(NULL, STp, cmd, datalen, direction,
2788 timeout, MAX_RETRIES, 1);
2789 if (!SRpnt)
2790 return (STp->buffer)->syscall_result;
2791
2792 ioctl_result = (STp->buffer)->syscall_result;
2793
2794 if (!ioctl_result) { /* SCSI command successful */
Mike Christie8b05b772005-11-08 04:06:44 -06002795 st_release_request(SRpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002796 SRpnt = NULL;
2797 STps->drv_block = blkno;
2798 STps->drv_file = fileno;
2799 STps->at_sm = at_sm;
2800
2801 if (cmd_in == MTBSFM)
2802 ioctl_result = st_int_ioctl(STp, MTFSF, 1);
2803 else if (cmd_in == MTFSFM)
2804 ioctl_result = st_int_ioctl(STp, MTBSF, 1);
2805
2806 if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) {
2807 int old_block_size = STp->block_size;
2808 STp->block_size = arg & MT_ST_BLKSIZE_MASK;
2809 if (STp->block_size != 0) {
2810 if (old_block_size == 0)
2811 normalize_buffer(STp->buffer);
2812 (STp->buffer)->buffer_blocks =
2813 (STp->buffer)->buffer_size / STp->block_size;
2814 }
2815 (STp->buffer)->buffer_bytes = (STp->buffer)->read_pointer = 0;
2816 if (cmd_in == SET_DENS_AND_BLK)
2817 STp->density = arg >> MT_ST_DENSITY_SHIFT;
2818 } else if (cmd_in == MTSETDRVBUFFER)
2819 STp->drv_buffer = (arg & 7);
2820 else if (cmd_in == MTSETDENSITY)
2821 STp->density = arg;
2822
2823 if (cmd_in == MTEOM)
2824 STps->eof = ST_EOD;
2825 else if (cmd_in == MTFSF)
2826 STps->eof = ST_FM;
2827 else if (chg_eof)
2828 STps->eof = ST_NOEOF;
2829
2830 if (cmd_in == MTWEOF)
2831 STps->rw = ST_IDLE;
2832 } else { /* SCSI command was not completely successful. Don't return
2833 from this block without releasing the SCSI command block! */
2834 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
2835
2836 if (cmdstatp->flags & SENSE_EOM) {
2837 if (cmd_in != MTBSF && cmd_in != MTBSFM &&
2838 cmd_in != MTBSR && cmd_in != MTBSS)
2839 STps->eof = ST_EOM_OK;
2840 STps->drv_block = 0;
2841 }
2842
2843 if (cmdstatp->remainder_valid)
2844 undone = (int)cmdstatp->uremainder64;
2845 else
2846 undone = 0;
2847
2848 if (cmd_in == MTWEOF &&
2849 cmdstatp->have_sense &&
Kai Makisara91614c02007-01-26 00:38:39 +02002850 (cmdstatp->flags & SENSE_EOM)) {
2851 if (cmdstatp->sense_hdr.sense_key == NO_SENSE ||
2852 cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR) {
2853 ioctl_result = 0; /* EOF(s) written successfully at EOM */
2854 STps->eof = ST_NOEOF;
2855 } else { /* Writing EOF(s) failed */
2856 if (fileno >= 0)
2857 fileno -= undone;
2858 if (undone < arg)
2859 STps->eof = ST_NOEOF;
2860 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002861 STps->drv_file = fileno;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002862 } else if ((cmd_in == MTFSF) || (cmd_in == MTFSFM)) {
2863 if (fileno >= 0)
2864 STps->drv_file = fileno - undone;
2865 else
2866 STps->drv_file = fileno;
2867 STps->drv_block = -1;
2868 STps->eof = ST_NOEOF;
2869 } else if ((cmd_in == MTBSF) || (cmd_in == MTBSFM)) {
2870 if (arg > 0 && undone < 0) /* Some drives get this wrong */
2871 undone = (-undone);
2872 if (STps->drv_file >= 0)
2873 STps->drv_file = fileno + undone;
2874 STps->drv_block = 0;
2875 STps->eof = ST_NOEOF;
2876 } else if (cmd_in == MTFSR) {
2877 if (cmdstatp->flags & SENSE_FMK) { /* Hit filemark */
2878 if (STps->drv_file >= 0)
2879 STps->drv_file++;
2880 STps->drv_block = 0;
2881 STps->eof = ST_FM;
2882 } else {
2883 if (blkno >= undone)
2884 STps->drv_block = blkno - undone;
2885 else
2886 STps->drv_block = (-1);
2887 STps->eof = ST_NOEOF;
2888 }
2889 } else if (cmd_in == MTBSR) {
2890 if (cmdstatp->flags & SENSE_FMK) { /* Hit filemark */
2891 STps->drv_file--;
2892 STps->drv_block = (-1);
2893 } else {
2894 if (arg > 0 && undone < 0) /* Some drives get this wrong */
2895 undone = (-undone);
2896 if (STps->drv_block >= 0)
2897 STps->drv_block = blkno + undone;
2898 }
2899 STps->eof = ST_NOEOF;
2900 } else if (cmd_in == MTEOM) {
2901 STps->drv_file = (-1);
2902 STps->drv_block = (-1);
2903 STps->eof = ST_EOD;
2904 } else if (cmd_in == MTSETBLK ||
2905 cmd_in == MTSETDENSITY ||
2906 cmd_in == MTSETDRVBUFFER ||
2907 cmd_in == SET_DENS_AND_BLK) {
2908 if (cmdstatp->sense_hdr.sense_key == ILLEGAL_REQUEST &&
2909 !(STp->use_pf & PF_TESTED)) {
2910 /* Try the other possible state of Page Format if not
2911 already tried */
2912 STp->use_pf = !STp->use_pf | PF_TESTED;
Mike Christie8b05b772005-11-08 04:06:44 -06002913 st_release_request(SRpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002914 SRpnt = NULL;
2915 return st_int_ioctl(STp, cmd_in, arg);
2916 }
2917 } else if (chg_eof)
2918 STps->eof = ST_NOEOF;
2919
2920 if (cmdstatp->sense_hdr.sense_key == BLANK_CHECK)
2921 STps->eof = ST_EOD;
2922
Mike Christie8b05b772005-11-08 04:06:44 -06002923 st_release_request(SRpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002924 SRpnt = NULL;
2925 }
2926
2927 return ioctl_result;
2928}
2929
2930
2931/* Get the tape position. If bt == 2, arg points into a kernel space mt_loc
2932 structure. */
2933
2934static int get_location(struct scsi_tape *STp, unsigned int *block, int *partition,
2935 int logical)
2936{
2937 int result;
2938 unsigned char scmd[MAX_COMMAND_SIZE];
Mike Christie8b05b772005-11-08 04:06:44 -06002939 struct st_request *SRpnt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002940 DEB( char *name = tape_name(STp); )
2941
2942 if (STp->ready != ST_READY)
2943 return (-EIO);
2944
2945 memset(scmd, 0, MAX_COMMAND_SIZE);
2946 if ((STp->device)->scsi_level < SCSI_2) {
2947 scmd[0] = QFA_REQUEST_BLOCK;
2948 scmd[4] = 3;
2949 } else {
2950 scmd[0] = READ_POSITION;
2951 if (!logical && !STp->scsi2_logical)
2952 scmd[1] = 1;
2953 }
2954 SRpnt = st_do_scsi(NULL, STp, scmd, 20, DMA_FROM_DEVICE,
James Bottomleya02488e2008-11-30 10:36:26 -06002955 STp->device->request_queue->rq_timeout,
2956 MAX_READY_RETRIES, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002957 if (!SRpnt)
2958 return (STp->buffer)->syscall_result;
2959
2960 if ((STp->buffer)->syscall_result != 0 ||
2961 (STp->device->scsi_level >= SCSI_2 &&
2962 ((STp->buffer)->b_data[0] & 4) != 0)) {
2963 *block = *partition = 0;
2964 DEBC(printk(ST_DEB_MSG "%s: Can't read tape position.\n", name));
2965 result = (-EIO);
2966 } else {
2967 result = 0;
2968 if ((STp->device)->scsi_level < SCSI_2) {
2969 *block = ((STp->buffer)->b_data[0] << 16)
2970 + ((STp->buffer)->b_data[1] << 8)
2971 + (STp->buffer)->b_data[2];
2972 *partition = 0;
2973 } else {
2974 *block = ((STp->buffer)->b_data[4] << 24)
2975 + ((STp->buffer)->b_data[5] << 16)
2976 + ((STp->buffer)->b_data[6] << 8)
2977 + (STp->buffer)->b_data[7];
2978 *partition = (STp->buffer)->b_data[1];
2979 if (((STp->buffer)->b_data[0] & 0x80) &&
2980 (STp->buffer)->b_data[1] == 0) /* BOP of partition 0 */
2981 STp->ps[0].drv_block = STp->ps[0].drv_file = 0;
2982 }
2983 DEBC(printk(ST_DEB_MSG "%s: Got tape pos. blk %d part %d.\n", name,
2984 *block, *partition));
2985 }
Mike Christie8b05b772005-11-08 04:06:44 -06002986 st_release_request(SRpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002987 SRpnt = NULL;
2988
2989 return result;
2990}
2991
2992
2993/* Set the tape block and partition. Negative partition means that only the
2994 block should be set in vendor specific way. */
2995static int set_location(struct scsi_tape *STp, unsigned int block, int partition,
2996 int logical)
2997{
2998 struct st_partstat *STps;
2999 int result, p;
3000 unsigned int blk;
3001 int timeout;
3002 unsigned char scmd[MAX_COMMAND_SIZE];
Mike Christie8b05b772005-11-08 04:06:44 -06003003 struct st_request *SRpnt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003004 DEB( char *name = tape_name(STp); )
3005
3006 if (STp->ready != ST_READY)
3007 return (-EIO);
3008 timeout = STp->long_timeout;
3009 STps = &(STp->ps[STp->partition]);
3010
3011 DEBC(printk(ST_DEB_MSG "%s: Setting block to %d and partition to %d.\n",
3012 name, block, partition));
3013 DEB(if (partition < 0)
3014 return (-EIO); )
3015
3016 /* Update the location at the partition we are leaving */
3017 if ((!STp->can_partitions && partition != 0) ||
3018 partition >= ST_NBR_PARTITIONS)
3019 return (-EINVAL);
3020 if (partition != STp->partition) {
3021 if (get_location(STp, &blk, &p, 1))
3022 STps->last_block_valid = 0;
3023 else {
3024 STps->last_block_valid = 1;
3025 STps->last_block_visited = blk;
3026 DEBC(printk(ST_DEB_MSG
3027 "%s: Visited block %d for partition %d saved.\n",
3028 name, blk, STp->partition));
3029 }
3030 }
3031
3032 memset(scmd, 0, MAX_COMMAND_SIZE);
3033 if ((STp->device)->scsi_level < SCSI_2) {
3034 scmd[0] = QFA_SEEK_BLOCK;
3035 scmd[2] = (block >> 16);
3036 scmd[3] = (block >> 8);
3037 scmd[4] = block;
3038 scmd[5] = 0;
3039 } else {
3040 scmd[0] = SEEK_10;
3041 scmd[3] = (block >> 24);
3042 scmd[4] = (block >> 16);
3043 scmd[5] = (block >> 8);
3044 scmd[6] = block;
3045 if (!logical && !STp->scsi2_logical)
3046 scmd[1] = 4;
3047 if (STp->partition != partition) {
3048 scmd[1] |= 2;
3049 scmd[8] = partition;
3050 DEBC(printk(ST_DEB_MSG
3051 "%s: Trying to change partition from %d to %d\n",
3052 name, STp->partition, partition));
3053 }
3054 }
3055 if (STp->immediate) {
3056 scmd[1] |= 1; /* Don't wait for completion */
James Bottomleya02488e2008-11-30 10:36:26 -06003057 timeout = STp->device->request_queue->rq_timeout;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003058 }
3059
3060 SRpnt = st_do_scsi(NULL, STp, scmd, 0, DMA_NONE,
3061 timeout, MAX_READY_RETRIES, 1);
3062 if (!SRpnt)
3063 return (STp->buffer)->syscall_result;
3064
3065 STps->drv_block = STps->drv_file = (-1);
3066 STps->eof = ST_NOEOF;
3067 if ((STp->buffer)->syscall_result != 0) {
3068 result = (-EIO);
3069 if (STp->can_partitions &&
3070 (STp->device)->scsi_level >= SCSI_2 &&
3071 (p = find_partition(STp)) >= 0)
3072 STp->partition = p;
3073 } else {
3074 if (STp->can_partitions) {
3075 STp->partition = partition;
3076 STps = &(STp->ps[partition]);
3077 if (!STps->last_block_valid ||
3078 STps->last_block_visited != block) {
3079 STps->at_sm = 0;
3080 STps->rw = ST_IDLE;
3081 }
3082 } else
3083 STps->at_sm = 0;
3084 if (block == 0)
3085 STps->drv_block = STps->drv_file = 0;
3086 result = 0;
3087 }
3088
Mike Christie8b05b772005-11-08 04:06:44 -06003089 st_release_request(SRpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003090 SRpnt = NULL;
3091
3092 return result;
3093}
3094
3095
3096/* Find the current partition number for the drive status. Called from open and
3097 returns either partition number of negative error code. */
3098static int find_partition(struct scsi_tape *STp)
3099{
3100 int i, partition;
3101 unsigned int block;
3102
3103 if ((i = get_location(STp, &block, &partition, 1)) < 0)
3104 return i;
3105 if (partition >= ST_NBR_PARTITIONS)
3106 return (-EIO);
3107 return partition;
3108}
3109
3110
3111/* Change the partition if necessary */
3112static int switch_partition(struct scsi_tape *STp)
3113{
3114 struct st_partstat *STps;
3115
3116 if (STp->partition == STp->new_partition)
3117 return 0;
3118 STps = &(STp->ps[STp->new_partition]);
3119 if (!STps->last_block_valid)
3120 STps->last_block_visited = 0;
3121 return set_location(STp, STps->last_block_visited, STp->new_partition, 1);
3122}
3123
3124/* Functions for reading and writing the medium partition mode page. */
3125
3126#define PART_PAGE 0x11
3127#define PART_PAGE_FIXED_LENGTH 8
3128
3129#define PP_OFF_MAX_ADD_PARTS 2
3130#define PP_OFF_NBR_ADD_PARTS 3
3131#define PP_OFF_FLAGS 4
3132#define PP_OFF_PART_UNITS 6
3133#define PP_OFF_RESERVED 7
3134
3135#define PP_BIT_IDP 0x20
3136#define PP_MSK_PSUM_MB 0x10
3137
3138/* Get the number of partitions on the tape. As a side effect reads the
3139 mode page into the tape buffer. */
3140static int nbr_partitions(struct scsi_tape *STp)
3141{
3142 int result;
3143 DEB( char *name = tape_name(STp); )
3144
3145 if (STp->ready != ST_READY)
3146 return (-EIO);
3147
3148 result = read_mode_page(STp, PART_PAGE, 1);
3149
3150 if (result) {
3151 DEBC(printk(ST_DEB_MSG "%s: Can't read medium partition page.\n",
3152 name));
3153 result = (-EIO);
3154 } else {
3155 result = (STp->buffer)->b_data[MODE_HEADER_LENGTH +
3156 PP_OFF_NBR_ADD_PARTS] + 1;
3157 DEBC(printk(ST_DEB_MSG "%s: Number of partitions %d.\n", name, result));
3158 }
3159
3160 return result;
3161}
3162
3163
3164/* Partition the tape into two partitions if size > 0 or one partition if
3165 size == 0.
3166
3167 The block descriptors are read and written because Sony SDT-7000 does not
3168 work without this (suggestion from Michael Schaefer <Michael.Schaefer@dlr.de>).
3169
3170 My HP C1533A drive returns only one partition size field. This is used to
3171 set the size of partition 1. There is no size field for the default partition.
3172 Michael Schaefer's Sony SDT-7000 returns two descriptors and the second is
3173 used to set the size of partition 1 (this is what the SCSI-3 standard specifies).
3174 The following algorithm is used to accommodate both drives: if the number of
3175 partition size fields is greater than the maximum number of additional partitions
3176 in the mode page, the second field is used. Otherwise the first field is used.
3177
3178 For Seagate DDS drives the page length must be 8 when no partitions is defined
3179 and 10 when 1 partition is defined (information from Eric Lee Green). This is
3180 is acceptable also to some other old drives and enforced if the first partition
3181 size field is used for the first additional partition size.
3182 */
3183static int partition_tape(struct scsi_tape *STp, int size)
3184{
3185 char *name = tape_name(STp);
3186 int result;
3187 int pgo, psd_cnt, psdo;
3188 unsigned char *bp;
3189
3190 result = read_mode_page(STp, PART_PAGE, 0);
3191 if (result) {
3192 DEBC(printk(ST_DEB_MSG "%s: Can't read partition mode page.\n", name));
3193 return result;
3194 }
3195 /* The mode page is in the buffer. Let's modify it and write it. */
3196 bp = (STp->buffer)->b_data;
3197 pgo = MODE_HEADER_LENGTH + bp[MH_OFF_BDESCS_LENGTH];
3198 DEBC(printk(ST_DEB_MSG "%s: Partition page length is %d bytes.\n",
3199 name, bp[pgo + MP_OFF_PAGE_LENGTH] + 2));
3200
3201 psd_cnt = (bp[pgo + MP_OFF_PAGE_LENGTH] + 2 - PART_PAGE_FIXED_LENGTH) / 2;
3202 psdo = pgo + PART_PAGE_FIXED_LENGTH;
3203 if (psd_cnt > bp[pgo + PP_OFF_MAX_ADD_PARTS]) {
3204 bp[psdo] = bp[psdo + 1] = 0xff; /* Rest of the tape */
3205 psdo += 2;
3206 }
3207 memset(bp + psdo, 0, bp[pgo + PP_OFF_NBR_ADD_PARTS] * 2);
3208
3209 DEBC(printk("%s: psd_cnt %d, max.parts %d, nbr_parts %d\n", name,
3210 psd_cnt, bp[pgo + PP_OFF_MAX_ADD_PARTS],
3211 bp[pgo + PP_OFF_NBR_ADD_PARTS]));
3212
3213 if (size <= 0) {
3214 bp[pgo + PP_OFF_NBR_ADD_PARTS] = 0;
3215 if (psd_cnt <= bp[pgo + PP_OFF_MAX_ADD_PARTS])
3216 bp[pgo + MP_OFF_PAGE_LENGTH] = 6;
3217 DEBC(printk(ST_DEB_MSG "%s: Formatting tape with one partition.\n",
3218 name));
3219 } else {
3220 bp[psdo] = (size >> 8) & 0xff;
3221 bp[psdo + 1] = size & 0xff;
3222 bp[pgo + 3] = 1;
3223 if (bp[pgo + MP_OFF_PAGE_LENGTH] < 8)
3224 bp[pgo + MP_OFF_PAGE_LENGTH] = 8;
3225 DEBC(printk(ST_DEB_MSG
3226 "%s: Formatting tape with two partitions (1 = %d MB).\n",
3227 name, size));
3228 }
3229 bp[pgo + PP_OFF_PART_UNITS] = 0;
3230 bp[pgo + PP_OFF_RESERVED] = 0;
3231 bp[pgo + PP_OFF_FLAGS] = PP_BIT_IDP | PP_MSK_PSUM_MB;
3232
3233 result = write_mode_page(STp, PART_PAGE, 1);
3234 if (result) {
3235 printk(KERN_INFO "%s: Partitioning of tape failed.\n", name);
3236 result = (-EIO);
3237 }
3238
3239 return result;
3240}
3241
3242
3243
3244/* The ioctl command */
Kai Makisarafd66c1b2008-01-17 22:45:22 +02003245static long st_ioctl(struct file *file, unsigned int cmd_in, unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003246{
3247 int i, cmd_nr, cmd_type, bt;
3248 int retval = 0;
3249 unsigned int blk;
3250 struct scsi_tape *STp = file->private_data;
3251 struct st_modedef *STm;
3252 struct st_partstat *STps;
3253 char *name = tape_name(STp);
3254 void __user *p = (void __user *)arg;
3255
Matthias Kaehlcke28f85002007-07-29 23:38:15 +02003256 if (mutex_lock_interruptible(&STp->lock))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003257 return -ERESTARTSYS;
3258
3259 DEB(
3260 if (debugging && !STp->in_use) {
3261 printk(ST_DEB_MSG "%s: Incorrect device.\n", name);
3262 retval = (-EIO);
3263 goto out;
3264 } ) /* end DEB */
3265
3266 STm = &(STp->modes[STp->current_mode]);
3267 STps = &(STp->ps[STp->partition]);
3268
3269 /*
3270 * If we are in the middle of error recovery, don't let anyone
3271 * else try and use this device. Also, if error recovery fails, it
3272 * may try and take the device offline, in which case all further
3273 * access to the device is prohibited.
3274 */
Al Viro83ff6fe2008-03-02 08:15:49 -05003275 retval = scsi_nonblockable_ioctl(STp->device, cmd_in, p,
3276 file->f_flags & O_NDELAY);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003277 if (!scsi_block_when_processing_errors(STp->device) || retval != -ENODEV)
3278 goto out;
3279 retval = 0;
3280
3281 cmd_type = _IOC_TYPE(cmd_in);
3282 cmd_nr = _IOC_NR(cmd_in);
3283
3284 if (cmd_type == _IOC_TYPE(MTIOCTOP) && cmd_nr == _IOC_NR(MTIOCTOP)) {
3285 struct mtop mtc;
3286
3287 if (_IOC_SIZE(cmd_in) != sizeof(mtc)) {
3288 retval = (-EINVAL);
3289 goto out;
3290 }
3291
3292 i = copy_from_user(&mtc, p, sizeof(struct mtop));
3293 if (i) {
3294 retval = (-EFAULT);
3295 goto out;
3296 }
3297
3298 if (mtc.mt_op == MTSETDRVBUFFER && !capable(CAP_SYS_ADMIN)) {
3299 printk(KERN_WARNING
3300 "%s: MTSETDRVBUFFER only allowed for root.\n", name);
3301 retval = (-EPERM);
3302 goto out;
3303 }
3304 if (!STm->defined &&
3305 (mtc.mt_op != MTSETDRVBUFFER &&
3306 (mtc.mt_count & MT_ST_OPTIONS) == 0)) {
3307 retval = (-ENXIO);
3308 goto out;
3309 }
3310
3311 if (!STp->pos_unknown) {
3312
3313 if (STps->eof == ST_FM_HIT) {
3314 if (mtc.mt_op == MTFSF || mtc.mt_op == MTFSFM ||
3315 mtc.mt_op == MTEOM) {
3316 mtc.mt_count -= 1;
3317 if (STps->drv_file >= 0)
3318 STps->drv_file += 1;
3319 } else if (mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM) {
3320 mtc.mt_count += 1;
3321 if (STps->drv_file >= 0)
3322 STps->drv_file += 1;
3323 }
3324 }
3325
3326 if (mtc.mt_op == MTSEEK) {
3327 /* Old position must be restored if partition will be
3328 changed */
3329 i = !STp->can_partitions ||
3330 (STp->new_partition != STp->partition);
3331 } else {
3332 i = mtc.mt_op == MTREW || mtc.mt_op == MTOFFL ||
3333 mtc.mt_op == MTRETEN || mtc.mt_op == MTEOM ||
3334 mtc.mt_op == MTLOCK || mtc.mt_op == MTLOAD ||
3335 mtc.mt_op == MTFSF || mtc.mt_op == MTFSFM ||
3336 mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM ||
3337 mtc.mt_op == MTCOMPRESSION;
3338 }
3339 i = flush_buffer(STp, i);
3340 if (i < 0) {
3341 retval = i;
3342 goto out;
3343 }
3344 if (STps->rw == ST_WRITING &&
3345 (mtc.mt_op == MTREW || mtc.mt_op == MTOFFL ||
3346 mtc.mt_op == MTSEEK ||
3347 mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM)) {
3348 i = st_int_ioctl(STp, MTWEOF, 1);
3349 if (i < 0) {
3350 retval = i;
3351 goto out;
3352 }
3353 if (mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM)
3354 mtc.mt_count++;
3355 STps->rw = ST_IDLE;
3356 }
3357
3358 } else {
3359 /*
3360 * If there was a bus reset, block further access
3361 * to this device. If the user wants to rewind the tape,
3362 * then reset the flag and allow access again.
3363 */
3364 if (mtc.mt_op != MTREW &&
3365 mtc.mt_op != MTOFFL &&
3366 mtc.mt_op != MTRETEN &&
3367 mtc.mt_op != MTERASE &&
3368 mtc.mt_op != MTSEEK &&
3369 mtc.mt_op != MTEOM) {
3370 retval = (-EIO);
3371 goto out;
3372 }
3373 reset_state(STp);
3374 /* remove this when the midlevel properly clears was_reset */
3375 STp->device->was_reset = 0;
3376 }
3377
3378 if (mtc.mt_op != MTNOP && mtc.mt_op != MTSETBLK &&
3379 mtc.mt_op != MTSETDENSITY && mtc.mt_op != MTWSM &&
3380 mtc.mt_op != MTSETDRVBUFFER && mtc.mt_op != MTSETPART)
3381 STps->rw = ST_IDLE; /* Prevent automatic WEOF and fsf */
3382
3383 if (mtc.mt_op == MTOFFL && STp->door_locked != ST_UNLOCKED)
3384 do_door_lock(STp, 0); /* Ignore result! */
3385
3386 if (mtc.mt_op == MTSETDRVBUFFER &&
3387 (mtc.mt_count & MT_ST_OPTIONS) != 0) {
3388 retval = st_set_options(STp, mtc.mt_count);
3389 goto out;
3390 }
3391
3392 if (mtc.mt_op == MTSETPART) {
3393 if (!STp->can_partitions ||
3394 mtc.mt_count < 0 || mtc.mt_count >= ST_NBR_PARTITIONS) {
3395 retval = (-EINVAL);
3396 goto out;
3397 }
3398 if (mtc.mt_count >= STp->nbr_partitions &&
3399 (STp->nbr_partitions = nbr_partitions(STp)) < 0) {
3400 retval = (-EIO);
3401 goto out;
3402 }
3403 if (mtc.mt_count >= STp->nbr_partitions) {
3404 retval = (-EINVAL);
3405 goto out;
3406 }
3407 STp->new_partition = mtc.mt_count;
3408 retval = 0;
3409 goto out;
3410 }
3411
3412 if (mtc.mt_op == MTMKPART) {
3413 if (!STp->can_partitions) {
3414 retval = (-EINVAL);
3415 goto out;
3416 }
3417 if ((i = st_int_ioctl(STp, MTREW, 0)) < 0 ||
3418 (i = partition_tape(STp, mtc.mt_count)) < 0) {
3419 retval = i;
3420 goto out;
3421 }
3422 for (i = 0; i < ST_NBR_PARTITIONS; i++) {
3423 STp->ps[i].rw = ST_IDLE;
3424 STp->ps[i].at_sm = 0;
3425 STp->ps[i].last_block_valid = 0;
3426 }
3427 STp->partition = STp->new_partition = 0;
3428 STp->nbr_partitions = 1; /* Bad guess ?-) */
3429 STps->drv_block = STps->drv_file = 0;
3430 retval = 0;
3431 goto out;
3432 }
3433
3434 if (mtc.mt_op == MTSEEK) {
3435 i = set_location(STp, mtc.mt_count, STp->new_partition, 0);
3436 if (!STp->can_partitions)
3437 STp->ps[0].rw = ST_IDLE;
3438 retval = i;
3439 goto out;
3440 }
3441
3442 if (mtc.mt_op == MTUNLOAD || mtc.mt_op == MTOFFL) {
3443 retval = do_load_unload(STp, file, 0);
3444 goto out;
3445 }
3446
3447 if (mtc.mt_op == MTLOAD) {
3448 retval = do_load_unload(STp, file, max(1, mtc.mt_count));
3449 goto out;
3450 }
3451
3452 if (mtc.mt_op == MTLOCK || mtc.mt_op == MTUNLOCK) {
3453 retval = do_door_lock(STp, (mtc.mt_op == MTLOCK));
3454 goto out;
3455 }
3456
3457 if (STp->can_partitions && STp->ready == ST_READY &&
3458 (i = switch_partition(STp)) < 0) {
3459 retval = i;
3460 goto out;
3461 }
3462
3463 if (mtc.mt_op == MTCOMPRESSION)
3464 retval = st_compression(STp, (mtc.mt_count & 1));
3465 else
3466 retval = st_int_ioctl(STp, mtc.mt_op, mtc.mt_count);
3467 goto out;
3468 }
3469 if (!STm->defined) {
3470 retval = (-ENXIO);
3471 goto out;
3472 }
3473
3474 if ((i = flush_buffer(STp, 0)) < 0) {
3475 retval = i;
3476 goto out;
3477 }
3478 if (STp->can_partitions &&
3479 (i = switch_partition(STp)) < 0) {
3480 retval = i;
3481 goto out;
3482 }
3483
3484 if (cmd_type == _IOC_TYPE(MTIOCGET) && cmd_nr == _IOC_NR(MTIOCGET)) {
3485 struct mtget mt_status;
3486
3487 if (_IOC_SIZE(cmd_in) != sizeof(struct mtget)) {
3488 retval = (-EINVAL);
3489 goto out;
3490 }
3491
3492 mt_status.mt_type = STp->tape_type;
3493 mt_status.mt_dsreg =
3494 ((STp->block_size << MT_ST_BLKSIZE_SHIFT) & MT_ST_BLKSIZE_MASK) |
3495 ((STp->density << MT_ST_DENSITY_SHIFT) & MT_ST_DENSITY_MASK);
3496 mt_status.mt_blkno = STps->drv_block;
3497 mt_status.mt_fileno = STps->drv_file;
3498 if (STp->block_size != 0) {
3499 if (STps->rw == ST_WRITING)
3500 mt_status.mt_blkno +=
3501 (STp->buffer)->buffer_bytes / STp->block_size;
3502 else if (STps->rw == ST_READING)
3503 mt_status.mt_blkno -=
3504 ((STp->buffer)->buffer_bytes +
3505 STp->block_size - 1) / STp->block_size;
3506 }
3507
3508 mt_status.mt_gstat = 0;
3509 if (STp->drv_write_prot)
3510 mt_status.mt_gstat |= GMT_WR_PROT(0xffffffff);
3511 if (mt_status.mt_blkno == 0) {
3512 if (mt_status.mt_fileno == 0)
3513 mt_status.mt_gstat |= GMT_BOT(0xffffffff);
3514 else
3515 mt_status.mt_gstat |= GMT_EOF(0xffffffff);
3516 }
3517 mt_status.mt_erreg = (STp->recover_reg << MT_ST_SOFTERR_SHIFT);
3518 mt_status.mt_resid = STp->partition;
3519 if (STps->eof == ST_EOM_OK || STps->eof == ST_EOM_ERROR)
3520 mt_status.mt_gstat |= GMT_EOT(0xffffffff);
3521 else if (STps->eof >= ST_EOM_OK)
3522 mt_status.mt_gstat |= GMT_EOD(0xffffffff);
3523 if (STp->density == 1)
3524 mt_status.mt_gstat |= GMT_D_800(0xffffffff);
3525 else if (STp->density == 2)
3526 mt_status.mt_gstat |= GMT_D_1600(0xffffffff);
3527 else if (STp->density == 3)
3528 mt_status.mt_gstat |= GMT_D_6250(0xffffffff);
3529 if (STp->ready == ST_READY)
3530 mt_status.mt_gstat |= GMT_ONLINE(0xffffffff);
3531 if (STp->ready == ST_NO_TAPE)
3532 mt_status.mt_gstat |= GMT_DR_OPEN(0xffffffff);
3533 if (STps->at_sm)
3534 mt_status.mt_gstat |= GMT_SM(0xffffffff);
3535 if (STm->do_async_writes ||
3536 (STm->do_buffer_writes && STp->block_size != 0) ||
3537 STp->drv_buffer != 0)
3538 mt_status.mt_gstat |= GMT_IM_REP_EN(0xffffffff);
3539 if (STp->cleaning_req)
3540 mt_status.mt_gstat |= GMT_CLN(0xffffffff);
3541
3542 i = copy_to_user(p, &mt_status, sizeof(struct mtget));
3543 if (i) {
3544 retval = (-EFAULT);
3545 goto out;
3546 }
3547
3548 STp->recover_reg = 0; /* Clear after read */
3549 retval = 0;
3550 goto out;
3551 } /* End of MTIOCGET */
3552 if (cmd_type == _IOC_TYPE(MTIOCPOS) && cmd_nr == _IOC_NR(MTIOCPOS)) {
3553 struct mtpos mt_pos;
3554 if (_IOC_SIZE(cmd_in) != sizeof(struct mtpos)) {
3555 retval = (-EINVAL);
3556 goto out;
3557 }
3558 if ((i = get_location(STp, &blk, &bt, 0)) < 0) {
3559 retval = i;
3560 goto out;
3561 }
3562 mt_pos.mt_blkno = blk;
3563 i = copy_to_user(p, &mt_pos, sizeof(struct mtpos));
3564 if (i)
3565 retval = (-EFAULT);
3566 goto out;
3567 }
Matthias Kaehlcke28f85002007-07-29 23:38:15 +02003568 mutex_unlock(&STp->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003569 switch (cmd_in) {
3570 case SCSI_IOCTL_GET_IDLUN:
3571 case SCSI_IOCTL_GET_BUS_NUMBER:
3572 break;
3573 default:
Kai Makisara 16c4b3e2005-05-01 18:11:55 +03003574 if ((cmd_in == SG_IO ||
3575 cmd_in == SCSI_IOCTL_SEND_COMMAND ||
3576 cmd_in == CDROM_SEND_PACKET) &&
3577 !capable(CAP_SYS_RAWIO))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003578 i = -EPERM;
3579 else
Al Viro74f3c8a2007-08-27 15:38:10 -04003580 i = scsi_cmd_ioctl(STp->disk->queue, STp->disk,
3581 file->f_mode, cmd_in, p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003582 if (i != -ENOTTY)
3583 return i;
3584 break;
3585 }
Kai Makisara 16c4b3e2005-05-01 18:11:55 +03003586 retval = scsi_ioctl(STp->device, cmd_in, p);
3587 if (!retval && cmd_in == SCSI_IOCTL_STOP_UNIT) { /* unload */
3588 STp->rew_at_close = 0;
3589 STp->ready = ST_NO_TAPE;
3590 }
3591 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003592
3593 out:
Matthias Kaehlcke28f85002007-07-29 23:38:15 +02003594 mutex_unlock(&STp->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003595 return retval;
3596}
3597
3598#ifdef CONFIG_COMPAT
3599static long st_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
3600{
3601 struct scsi_tape *STp = file->private_data;
3602 struct scsi_device *sdev = STp->device;
3603 int ret = -ENOIOCTLCMD;
3604 if (sdev->host->hostt->compat_ioctl) {
3605
3606 ret = sdev->host->hostt->compat_ioctl(sdev, cmd, (void __user *)arg);
3607
3608 }
3609 return ret;
3610}
3611#endif
3612
3613
3614
3615/* Try to allocate a new tape buffer. Calling function must not hold
3616 dev_arr_lock. */
3617static struct st_buffer *
3618 new_tape_buffer(int from_initialization, int need_dma, int max_sg)
3619{
Mike Christie8b05b772005-11-08 04:06:44 -06003620 int i, got = 0;
Al Viroc53033f2005-10-21 03:22:08 -04003621 gfp_t priority;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003622 struct st_buffer *tb;
3623
3624 if (from_initialization)
3625 priority = GFP_ATOMIC;
3626 else
3627 priority = GFP_KERNEL;
3628
3629 i = sizeof(struct st_buffer) + (max_sg - 1) * sizeof(struct scatterlist) +
3630 max_sg * sizeof(struct st_buf_fragment);
Jes Sorensen24669f752006-01-16 10:31:18 -05003631 tb = kzalloc(i, priority);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003632 if (!tb) {
3633 printk(KERN_NOTICE "st: Can't allocate new tape buffer.\n");
3634 return NULL;
3635 }
Mike Christie8b05b772005-11-08 04:06:44 -06003636 tb->frp_segs = tb->orig_frp_segs = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003637 tb->use_sg = max_sg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003638 tb->frp = (struct st_buf_fragment *)(&(tb->sg[0]) + max_sg);
3639
Linus Torvalds1da177e2005-04-16 15:20:36 -07003640 tb->dma = need_dma;
3641 tb->buffer_size = got;
FUJITA Tomonoricd816212007-12-15 15:51:55 +09003642 sg_init_table(tb->sg, max_sg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003643
3644 return tb;
3645}
3646
3647
3648/* Try to allocate enough space in the tape buffer */
3649static int enlarge_buffer(struct st_buffer * STbuffer, int new_size, int need_dma)
3650{
Al Viroc53033f2005-10-21 03:22:08 -04003651 int segs, nbr, max_segs, b_size, order, got;
3652 gfp_t priority;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003653
3654 if (new_size <= STbuffer->buffer_size)
3655 return 1;
3656
3657 if (STbuffer->buffer_size <= PAGE_SIZE)
3658 normalize_buffer(STbuffer); /* Avoid extra segment */
3659
3660 max_segs = STbuffer->use_sg;
3661 nbr = max_segs - STbuffer->frp_segs;
3662 if (nbr <= 0)
3663 return 0;
3664
3665 priority = GFP_KERNEL | __GFP_NOWARN;
3666 if (need_dma)
3667 priority |= GFP_DMA;
Mike Christie8b05b772005-11-08 04:06:44 -06003668 for (b_size = PAGE_SIZE, order=0; order <= 6 &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07003669 b_size < new_size - STbuffer->buffer_size;
3670 order++, b_size *= 2)
3671 ; /* empty */
3672
3673 for (segs = STbuffer->frp_segs, got = STbuffer->buffer_size;
3674 segs < max_segs && got < new_size;) {
3675 STbuffer->frp[segs].page = alloc_pages(priority, order);
3676 if (STbuffer->frp[segs].page == NULL) {
3677 if (new_size - got <= (max_segs - segs) * b_size / 2) {
3678 b_size /= 2; /* Large enough for the rest of the buffers */
3679 order--;
3680 continue;
3681 }
3682 DEB(STbuffer->buffer_size = got);
3683 normalize_buffer(STbuffer);
3684 return 0;
3685 }
3686 STbuffer->frp[segs].length = b_size;
3687 STbuffer->frp_segs += 1;
3688 got += b_size;
3689 STbuffer->buffer_size = got;
Kai Makisara40f6b362008-02-24 22:23:24 +02003690 if (STbuffer->cleared)
3691 memset(page_address(STbuffer->frp[segs].page), 0, b_size);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003692 segs++;
3693 }
3694 STbuffer->b_data = page_address(STbuffer->frp[0].page);
3695
3696 return 1;
3697}
3698
3699
Kai Makisara40f6b362008-02-24 22:23:24 +02003700/* Make sure that no data from previous user is in the internal buffer */
3701static void clear_buffer(struct st_buffer * st_bp)
3702{
3703 int i;
3704
3705 for (i=0; i < st_bp->frp_segs; i++)
3706 memset(page_address(st_bp->frp[i].page), 0, st_bp->frp[i].length);
3707 st_bp->cleared = 1;
3708}
3709
3710
Linus Torvalds1da177e2005-04-16 15:20:36 -07003711/* Release the extra buffer */
3712static void normalize_buffer(struct st_buffer * STbuffer)
3713{
3714 int i, order;
3715
3716 for (i = STbuffer->orig_frp_segs; i < STbuffer->frp_segs; i++) {
3717 order = get_order(STbuffer->frp[i].length);
3718 __free_pages(STbuffer->frp[i].page, order);
3719 STbuffer->buffer_size -= STbuffer->frp[i].length;
3720 }
3721 STbuffer->frp_segs = STbuffer->orig_frp_segs;
3722 STbuffer->frp_sg_current = 0;
Mike Christie8b05b772005-11-08 04:06:44 -06003723 STbuffer->sg_segs = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003724}
3725
3726
3727/* Move data from the user buffer to the tape buffer. Returns zero (success) or
3728 negative error code. */
3729static int append_to_buffer(const char __user *ubp, struct st_buffer * st_bp, int do_count)
3730{
3731 int i, cnt, res, offset;
3732
3733 for (i = 0, offset = st_bp->buffer_bytes;
3734 i < st_bp->frp_segs && offset >= st_bp->frp[i].length; i++)
3735 offset -= st_bp->frp[i].length;
3736 if (i == st_bp->frp_segs) { /* Should never happen */
3737 printk(KERN_WARNING "st: append_to_buffer offset overflow.\n");
3738 return (-EIO);
3739 }
3740 for (; i < st_bp->frp_segs && do_count > 0; i++) {
3741 cnt = st_bp->frp[i].length - offset < do_count ?
3742 st_bp->frp[i].length - offset : do_count;
3743 res = copy_from_user(page_address(st_bp->frp[i].page) + offset, ubp, cnt);
3744 if (res)
3745 return (-EFAULT);
3746 do_count -= cnt;
3747 st_bp->buffer_bytes += cnt;
3748 ubp += cnt;
3749 offset = 0;
3750 }
3751 if (do_count) /* Should never happen */
3752 return (-EIO);
3753
3754 return 0;
3755}
3756
3757
3758/* Move data from the tape buffer to the user buffer. Returns zero (success) or
3759 negative error code. */
3760static int from_buffer(struct st_buffer * st_bp, char __user *ubp, int do_count)
3761{
3762 int i, cnt, res, offset;
3763
3764 for (i = 0, offset = st_bp->read_pointer;
3765 i < st_bp->frp_segs && offset >= st_bp->frp[i].length; i++)
3766 offset -= st_bp->frp[i].length;
3767 if (i == st_bp->frp_segs) { /* Should never happen */
3768 printk(KERN_WARNING "st: from_buffer offset overflow.\n");
3769 return (-EIO);
3770 }
3771 for (; i < st_bp->frp_segs && do_count > 0; i++) {
3772 cnt = st_bp->frp[i].length - offset < do_count ?
3773 st_bp->frp[i].length - offset : do_count;
3774 res = copy_to_user(ubp, page_address(st_bp->frp[i].page) + offset, cnt);
3775 if (res)
3776 return (-EFAULT);
3777 do_count -= cnt;
3778 st_bp->buffer_bytes -= cnt;
3779 st_bp->read_pointer += cnt;
3780 ubp += cnt;
3781 offset = 0;
3782 }
3783 if (do_count) /* Should never happen */
3784 return (-EIO);
3785
3786 return 0;
3787}
3788
3789
3790/* Move data towards start of buffer */
3791static void move_buffer_data(struct st_buffer * st_bp, int offset)
3792{
3793 int src_seg, dst_seg, src_offset = 0, dst_offset;
3794 int count, total;
3795
3796 if (offset == 0)
3797 return;
3798
3799 total=st_bp->buffer_bytes - offset;
3800 for (src_seg=0; src_seg < st_bp->frp_segs; src_seg++) {
3801 src_offset = offset;
3802 if (src_offset < st_bp->frp[src_seg].length)
3803 break;
3804 offset -= st_bp->frp[src_seg].length;
3805 }
3806
3807 st_bp->buffer_bytes = st_bp->read_pointer = total;
3808 for (dst_seg=dst_offset=0; total > 0; ) {
3809 count = min(st_bp->frp[dst_seg].length - dst_offset,
3810 st_bp->frp[src_seg].length - src_offset);
3811 memmove(page_address(st_bp->frp[dst_seg].page) + dst_offset,
3812 page_address(st_bp->frp[src_seg].page) + src_offset, count);
3813 src_offset += count;
3814 if (src_offset >= st_bp->frp[src_seg].length) {
3815 src_seg++;
3816 src_offset = 0;
3817 }
3818 dst_offset += count;
3819 if (dst_offset >= st_bp->frp[dst_seg].length) {
3820 dst_seg++;
3821 dst_offset = 0;
3822 }
3823 total -= count;
3824 }
3825}
3826
3827
3828/* Fill the s/g list up to the length required for this transfer */
3829static void buf_to_sg(struct st_buffer *STbp, unsigned int length)
3830{
3831 int i;
3832 unsigned int count;
3833 struct scatterlist *sg;
3834 struct st_buf_fragment *frp;
3835
3836 if (length == STbp->frp_sg_current)
3837 return; /* work already done */
3838
3839 sg = &(STbp->sg[0]);
3840 frp = STbp->frp;
3841 for (i=count=0; count < length; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003842 if (length - count > frp[i].length)
Jens Axboe642f1492007-10-24 11:20:47 +02003843 sg_set_page(&sg[i], frp[i].page, frp[i].length, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003844 else
Jens Axboe642f1492007-10-24 11:20:47 +02003845 sg_set_page(&sg[i], frp[i].page, length - count, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003846 count += sg[i].length;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003847 }
3848 STbp->sg_segs = i;
3849 STbp->frp_sg_current = length;
3850}
3851
3852
3853/* Validate the options from command line or module parameters */
3854static void validate_options(void)
3855{
3856 if (buffer_kbs > 0)
3857 st_fixed_buffer_size = buffer_kbs * ST_KILOBYTE;
3858 if (max_sg_segs >= ST_FIRST_SG)
3859 st_max_sg_segs = max_sg_segs;
3860}
3861
3862#ifndef MODULE
3863/* Set the boot options. Syntax is defined in Documenation/scsi/st.txt.
3864 */
3865static int __init st_setup(char *str)
3866{
3867 int i, len, ints[5];
3868 char *stp;
3869
3870 stp = get_options(str, ARRAY_SIZE(ints), ints);
3871
3872 if (ints[0] > 0) {
3873 for (i = 0; i < ints[0] && i < ARRAY_SIZE(parms); i++)
3874 if (parms[i].val)
3875 *parms[i].val = ints[i + 1];
3876 } else {
3877 while (stp != NULL) {
3878 for (i = 0; i < ARRAY_SIZE(parms); i++) {
3879 len = strlen(parms[i].name);
3880 if (!strncmp(stp, parms[i].name, len) &&
3881 (*(stp + len) == ':' || *(stp + len) == '=')) {
3882 if (parms[i].val)
3883 *parms[i].val =
3884 simple_strtoul(stp + len + 1, NULL, 0);
3885 else
3886 printk(KERN_WARNING "st: Obsolete parameter %s\n",
3887 parms[i].name);
3888 break;
3889 }
3890 }
Tobias Klauser6391a112006-06-08 22:23:48 -07003891 if (i >= ARRAY_SIZE(parms))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003892 printk(KERN_WARNING "st: invalid parameter in '%s'\n",
3893 stp);
3894 stp = strchr(stp, ',');
3895 if (stp)
3896 stp++;
3897 }
3898 }
3899
3900 validate_options();
3901
3902 return 1;
3903}
3904
3905__setup("st=", st_setup);
3906
3907#endif
3908
Arjan van de Ven00977a52007-02-12 00:55:34 -08003909static const struct file_operations st_fops =
Linus Torvalds1da177e2005-04-16 15:20:36 -07003910{
3911 .owner = THIS_MODULE,
3912 .read = st_read,
3913 .write = st_write,
Kai Makisarafd66c1b2008-01-17 22:45:22 +02003914 .unlocked_ioctl = st_ioctl,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003915#ifdef CONFIG_COMPAT
3916 .compat_ioctl = st_compat_ioctl,
3917#endif
3918 .open = st_open,
3919 .flush = st_flush,
3920 .release = st_release,
3921};
3922
3923static int st_probe(struct device *dev)
3924{
3925 struct scsi_device *SDp = to_scsi_device(dev);
3926 struct gendisk *disk = NULL;
3927 struct cdev *cdev = NULL;
3928 struct scsi_tape *tpnt = NULL;
3929 struct st_modedef *STm;
3930 struct st_partstat *STps;
3931 struct st_buffer *buffer;
3932 int i, j, mode, dev_num, error;
3933 char *stp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003934
3935 if (SDp->type != TYPE_TAPE)
3936 return -ENODEV;
3937 if ((stp = st_incompatible(SDp))) {
Jeff Garzik3bf743e2005-10-24 18:04:06 -04003938 sdev_printk(KERN_INFO, SDp, "Found incompatible tape\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003939 printk(KERN_INFO "st: The suggested driver is %s.\n", stp);
3940 return -ENODEV;
3941 }
3942
Mike Christie8b05b772005-11-08 04:06:44 -06003943 i = min(SDp->request_queue->max_hw_segments,
3944 SDp->request_queue->max_phys_segments);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003945 if (st_max_sg_segs < i)
3946 i = st_max_sg_segs;
3947 buffer = new_tape_buffer(1, (SDp->host)->unchecked_isa_dma, i);
3948 if (buffer == NULL) {
3949 printk(KERN_ERR
3950 "st: Can't allocate new tape buffer. Device not attached.\n");
3951 goto out;
3952 }
3953
3954 disk = alloc_disk(1);
3955 if (!disk) {
3956 printk(KERN_ERR "st: out of memory. Device not attached.\n");
3957 goto out_buffer_free;
3958 }
3959
3960 write_lock(&st_dev_arr_lock);
3961 if (st_nr_dev >= st_dev_max) {
3962 struct scsi_tape **tmp_da;
3963 int tmp_dev_max;
3964
3965 tmp_dev_max = max(st_nr_dev * 2, 8);
3966 if (tmp_dev_max > ST_MAX_TAPES)
3967 tmp_dev_max = ST_MAX_TAPES;
3968 if (tmp_dev_max <= st_nr_dev) {
3969 write_unlock(&st_dev_arr_lock);
3970 printk(KERN_ERR "st: Too many tape devices (max. %d).\n",
3971 ST_MAX_TAPES);
3972 goto out_put_disk;
3973 }
3974
Jes Sorensen24669f752006-01-16 10:31:18 -05003975 tmp_da = kzalloc(tmp_dev_max * sizeof(struct scsi_tape *), GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003976 if (tmp_da == NULL) {
3977 write_unlock(&st_dev_arr_lock);
3978 printk(KERN_ERR "st: Can't extend device array.\n");
3979 goto out_put_disk;
3980 }
3981
Linus Torvalds1da177e2005-04-16 15:20:36 -07003982 if (scsi_tapes != NULL) {
3983 memcpy(tmp_da, scsi_tapes,
3984 st_dev_max * sizeof(struct scsi_tape *));
3985 kfree(scsi_tapes);
3986 }
3987 scsi_tapes = tmp_da;
3988
3989 st_dev_max = tmp_dev_max;
3990 }
3991
3992 for (i = 0; i < st_dev_max; i++)
3993 if (scsi_tapes[i] == NULL)
3994 break;
3995 if (i >= st_dev_max)
3996 panic("scsi_devices corrupt (st)");
3997
Jes Sorensen24669f752006-01-16 10:31:18 -05003998 tpnt = kzalloc(sizeof(struct scsi_tape), GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003999 if (tpnt == NULL) {
4000 write_unlock(&st_dev_arr_lock);
4001 printk(KERN_ERR "st: Can't allocate device descriptor.\n");
4002 goto out_put_disk;
4003 }
Kai Makisaraf03a5672005-08-02 13:40:47 +03004004 kref_init(&tpnt->kref);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004005 tpnt->disk = disk;
4006 sprintf(disk->disk_name, "st%d", i);
4007 disk->private_data = &tpnt->driver;
4008 disk->queue = SDp->request_queue;
4009 tpnt->driver = &st_template;
4010 scsi_tapes[i] = tpnt;
4011 dev_num = i;
4012
4013 tpnt->device = SDp;
4014 if (SDp->scsi_level <= 2)
4015 tpnt->tape_type = MT_ISSCSI1;
4016 else
4017 tpnt->tape_type = MT_ISSCSI2;
4018
4019 tpnt->buffer = buffer;
Kai Makisaraf03a5672005-08-02 13:40:47 +03004020 tpnt->buffer->last_SRpnt = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004021
4022 tpnt->inited = 0;
4023 tpnt->dirty = 0;
4024 tpnt->in_use = 0;
4025 tpnt->drv_buffer = 1; /* Try buffering if no mode sense */
4026 tpnt->restr_dma = (SDp->host)->unchecked_isa_dma;
4027 tpnt->use_pf = (SDp->scsi_level >= SCSI_2);
4028 tpnt->density = 0;
4029 tpnt->do_auto_lock = ST_AUTO_LOCK;
4030 tpnt->can_bsr = (SDp->scsi_level > 2 ? 1 : ST_IN_FILE_POS); /* BSR mandatory in SCSI3 */
4031 tpnt->can_partitions = 0;
4032 tpnt->two_fm = ST_TWO_FM;
4033 tpnt->fast_mteom = ST_FAST_MTEOM;
4034 tpnt->scsi2_logical = ST_SCSI2LOGICAL;
Kai Makisara40f6b362008-02-24 22:23:24 +02004035 tpnt->sili = ST_SILI;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004036 tpnt->immediate = ST_NOWAIT;
4037 tpnt->default_drvbuffer = 0xff; /* No forced buffering */
4038 tpnt->partition = 0;
4039 tpnt->new_partition = 0;
4040 tpnt->nbr_partitions = 0;
James Bottomleya02488e2008-11-30 10:36:26 -06004041 blk_queue_rq_timeout(tpnt->device->request_queue, ST_TIMEOUT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004042 tpnt->long_timeout = ST_LONG_TIMEOUT;
4043 tpnt->try_dio = try_direct_io && !SDp->host->unchecked_isa_dma;
4044
Linus Torvalds1da177e2005-04-16 15:20:36 -07004045 for (i = 0; i < ST_NBR_MODES; i++) {
4046 STm = &(tpnt->modes[i]);
4047 STm->defined = 0;
4048 STm->sysv = ST_SYSV;
4049 STm->defaults_for_writes = 0;
4050 STm->do_async_writes = ST_ASYNC_WRITES;
4051 STm->do_buffer_writes = ST_BUFFER_WRITES;
4052 STm->do_read_ahead = ST_READ_AHEAD;
4053 STm->default_compression = ST_DONT_TOUCH;
4054 STm->default_blksize = (-1); /* No forced size */
4055 STm->default_density = (-1); /* No forced density */
4056 }
4057
4058 for (i = 0; i < ST_NBR_PARTITIONS; i++) {
4059 STps = &(tpnt->ps[i]);
4060 STps->rw = ST_IDLE;
4061 STps->eof = ST_NOEOF;
4062 STps->at_sm = 0;
4063 STps->last_block_valid = 0;
4064 STps->drv_block = (-1);
4065 STps->drv_file = (-1);
4066 }
4067
4068 tpnt->current_mode = 0;
4069 tpnt->modes[0].defined = 1;
4070
4071 tpnt->density_changed = tpnt->compression_changed =
4072 tpnt->blksize_changed = 0;
Matthias Kaehlcke28f85002007-07-29 23:38:15 +02004073 mutex_init(&tpnt->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004074
4075 st_nr_dev++;
4076 write_unlock(&st_dev_arr_lock);
4077
4078 for (mode = 0; mode < ST_NBR_MODES; ++mode) {
4079 STm = &(tpnt->modes[mode]);
4080 for (j=0; j < 2; j++) {
4081 cdev = cdev_alloc();
4082 if (!cdev) {
4083 printk(KERN_ERR
4084 "st%d: out of memory. Device not attached.\n",
4085 dev_num);
4086 goto out_free_tape;
4087 }
4088 cdev->owner = THIS_MODULE;
4089 cdev->ops = &st_fops;
4090
4091 error = cdev_add(cdev,
4092 MKDEV(SCSI_TAPE_MAJOR, TAPE_MINOR(dev_num, mode, j)),
4093 1);
4094 if (error) {
4095 printk(KERN_ERR "st%d: Can't add %s-rewind mode %d\n",
4096 dev_num, j ? "non" : "auto", mode);
4097 printk(KERN_ERR "st%d: Device not attached.\n", dev_num);
4098 goto out_free_tape;
4099 }
4100 STm->cdevs[j] = cdev;
4101
4102 }
Jeff Garzik13026a62006-10-04 06:00:38 -04004103 error = do_create_class_files(tpnt, dev_num, mode);
4104 if (error)
4105 goto out_free_tape;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004106 }
4107
Kai Makisara42252852006-11-07 21:56:38 +02004108 sdev_printk(KERN_NOTICE, SDp,
Rene Herman8b1ea242006-05-20 15:00:22 -07004109 "Attached scsi tape %s\n", tape_name(tpnt));
Kai Makisara42252852006-11-07 21:56:38 +02004110 sdev_printk(KERN_INFO, SDp, "%s: try direct i/o: %s (alignment %d B)\n",
4111 tape_name(tpnt), tpnt->try_dio ? "yes" : "no",
4112 queue_dma_alignment(SDp->request_queue) + 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004113
4114 return 0;
4115
4116out_free_tape:
4117 for (mode=0; mode < ST_NBR_MODES; mode++) {
4118 STm = &(tpnt->modes[mode]);
4119 sysfs_remove_link(&tpnt->device->sdev_gendev.kobj,
4120 "tape");
4121 for (j=0; j < 2; j++) {
4122 if (STm->cdevs[j]) {
4123 if (cdev == STm->cdevs[j])
4124 cdev = NULL;
Tony Jonesee959b02008-02-22 00:13:36 +01004125 device_destroy(st_sysfs_class,
4126 MKDEV(SCSI_TAPE_MAJOR,
4127 TAPE_MINOR(i, mode, j)));
Linus Torvalds1da177e2005-04-16 15:20:36 -07004128 cdev_del(STm->cdevs[j]);
4129 }
4130 }
4131 }
4132 if (cdev)
4133 cdev_del(cdev);
4134 write_lock(&st_dev_arr_lock);
4135 scsi_tapes[dev_num] = NULL;
4136 st_nr_dev--;
4137 write_unlock(&st_dev_arr_lock);
4138out_put_disk:
4139 put_disk(disk);
Jesper Juhlc9475cb2005-11-07 01:01:26 -08004140 kfree(tpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004141out_buffer_free:
4142 kfree(buffer);
4143out:
4144 return -ENODEV;
4145};
4146
4147
4148static int st_remove(struct device *dev)
4149{
4150 struct scsi_device *SDp = to_scsi_device(dev);
4151 struct scsi_tape *tpnt;
4152 int i, j, mode;
4153
4154 write_lock(&st_dev_arr_lock);
4155 for (i = 0; i < st_dev_max; i++) {
4156 tpnt = scsi_tapes[i];
4157 if (tpnt != NULL && tpnt->device == SDp) {
4158 scsi_tapes[i] = NULL;
4159 st_nr_dev--;
4160 write_unlock(&st_dev_arr_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004161 sysfs_remove_link(&tpnt->device->sdev_gendev.kobj,
4162 "tape");
4163 for (mode = 0; mode < ST_NBR_MODES; ++mode) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004164 for (j=0; j < 2; j++) {
Tony Jonesee959b02008-02-22 00:13:36 +01004165 device_destroy(st_sysfs_class,
4166 MKDEV(SCSI_TAPE_MAJOR,
4167 TAPE_MINOR(i, mode, j)));
Linus Torvalds1da177e2005-04-16 15:20:36 -07004168 cdev_del(tpnt->modes[mode].cdevs[j]);
4169 tpnt->modes[mode].cdevs[j] = NULL;
4170 }
4171 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004172
Arjan van de Ven0b950672006-01-11 13:16:10 +01004173 mutex_lock(&st_ref_mutex);
Kai Makisaraf03a5672005-08-02 13:40:47 +03004174 kref_put(&tpnt->kref, scsi_tape_release);
Arjan van de Ven0b950672006-01-11 13:16:10 +01004175 mutex_unlock(&st_ref_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004176 return 0;
4177 }
4178 }
4179
4180 write_unlock(&st_dev_arr_lock);
4181 return 0;
4182}
4183
Kai Makisaraf03a5672005-08-02 13:40:47 +03004184/**
4185 * scsi_tape_release - Called to free the Scsi_Tape structure
4186 * @kref: pointer to embedded kref
4187 *
Arjan van de Ven0b950672006-01-11 13:16:10 +01004188 * st_ref_mutex must be held entering this routine. Because it is
Kai Makisaraf03a5672005-08-02 13:40:47 +03004189 * called on last put, you should always use the scsi_tape_get()
4190 * scsi_tape_put() helpers which manipulate the semaphore directly
4191 * and never do a direct kref_put().
4192 **/
4193static void scsi_tape_release(struct kref *kref)
4194{
4195 struct scsi_tape *tpnt = to_scsi_tape(kref);
4196 struct gendisk *disk = tpnt->disk;
4197
4198 tpnt->device = NULL;
4199
4200 if (tpnt->buffer) {
4201 tpnt->buffer->orig_frp_segs = 0;
4202 normalize_buffer(tpnt->buffer);
4203 kfree(tpnt->buffer);
4204 }
4205
4206 disk->private_data = NULL;
4207 put_disk(disk);
4208 kfree(tpnt);
4209 return;
4210}
4211
Linus Torvalds1da177e2005-04-16 15:20:36 -07004212static int __init init_st(void)
4213{
Jeff Garzik13026a62006-10-04 06:00:38 -04004214 int err;
4215
Linus Torvalds1da177e2005-04-16 15:20:36 -07004216 validate_options();
4217
Jeff Garzik13026a62006-10-04 06:00:38 -04004218 printk(KERN_INFO "st: Version %s, fixed bufsize %d, s/g segs %d\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07004219 verstr, st_fixed_buffer_size, st_max_sg_segs);
4220
gregkh@suse.ded2538782005-03-23 09:55:22 -08004221 st_sysfs_class = class_create(THIS_MODULE, "scsi_tape");
Linus Torvalds1da177e2005-04-16 15:20:36 -07004222 if (IS_ERR(st_sysfs_class)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004223 printk(KERN_ERR "Unable create sysfs class for SCSI tapes\n");
Jeff Garzik13026a62006-10-04 06:00:38 -04004224 return PTR_ERR(st_sysfs_class);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004225 }
4226
Jeff Garzik13026a62006-10-04 06:00:38 -04004227 err = register_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0),
4228 ST_MAX_TAPE_ENTRIES, "st");
4229 if (err) {
4230 printk(KERN_ERR "Unable to get major %d for SCSI tapes\n",
4231 SCSI_TAPE_MAJOR);
4232 goto err_class;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004233 }
Jeff Garzik13026a62006-10-04 06:00:38 -04004234
4235 err = scsi_register_driver(&st_template.gendrv);
4236 if (err)
4237 goto err_chrdev;
4238
Robert P. J. Day405ae7d2007-02-17 19:13:42 +01004239 err = do_create_sysfs_files();
Jeff Garzik13026a62006-10-04 06:00:38 -04004240 if (err)
4241 goto err_scsidrv;
4242
4243 return 0;
4244
4245err_scsidrv:
4246 scsi_unregister_driver(&st_template.gendrv);
4247err_chrdev:
4248 unregister_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0),
4249 ST_MAX_TAPE_ENTRIES);
4250err_class:
Kai Makisarac2c96f42005-08-02 12:21:51 +03004251 class_destroy(st_sysfs_class);
Jeff Garzik13026a62006-10-04 06:00:38 -04004252 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004253}
4254
4255static void __exit exit_st(void)
4256{
Robert P. J. Day405ae7d2007-02-17 19:13:42 +01004257 do_remove_sysfs_files();
Linus Torvalds1da177e2005-04-16 15:20:36 -07004258 scsi_unregister_driver(&st_template.gendrv);
4259 unregister_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0),
4260 ST_MAX_TAPE_ENTRIES);
Kai Makisarac2c96f42005-08-02 12:21:51 +03004261 class_destroy(st_sysfs_class);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004262 kfree(scsi_tapes);
4263 printk(KERN_INFO "st: Unloaded.\n");
4264}
4265
4266module_init(init_st);
4267module_exit(exit_st);
4268
4269
4270/* The sysfs driver interface. Read-only at the moment */
4271static ssize_t st_try_direct_io_show(struct device_driver *ddp, char *buf)
4272{
4273 return snprintf(buf, PAGE_SIZE, "%d\n", try_direct_io);
4274}
4275static DRIVER_ATTR(try_direct_io, S_IRUGO, st_try_direct_io_show, NULL);
4276
4277static ssize_t st_fixed_buffer_size_show(struct device_driver *ddp, char *buf)
4278{
4279 return snprintf(buf, PAGE_SIZE, "%d\n", st_fixed_buffer_size);
4280}
4281static DRIVER_ATTR(fixed_buffer_size, S_IRUGO, st_fixed_buffer_size_show, NULL);
4282
4283static ssize_t st_max_sg_segs_show(struct device_driver *ddp, char *buf)
4284{
4285 return snprintf(buf, PAGE_SIZE, "%d\n", st_max_sg_segs);
4286}
4287static DRIVER_ATTR(max_sg_segs, S_IRUGO, st_max_sg_segs_show, NULL);
4288
4289static ssize_t st_version_show(struct device_driver *ddd, char *buf)
4290{
4291 return snprintf(buf, PAGE_SIZE, "[%s]\n", verstr);
4292}
4293static DRIVER_ATTR(version, S_IRUGO, st_version_show, NULL);
4294
Robert P. J. Day405ae7d2007-02-17 19:13:42 +01004295static int do_create_sysfs_files(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004296{
Robert P. J. Day405ae7d2007-02-17 19:13:42 +01004297 struct device_driver *sysfs = &st_template.gendrv;
Jeff Garzik13026a62006-10-04 06:00:38 -04004298 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004299
Robert P. J. Day405ae7d2007-02-17 19:13:42 +01004300 err = driver_create_file(sysfs, &driver_attr_try_direct_io);
Jeff Garzik13026a62006-10-04 06:00:38 -04004301 if (err)
4302 return err;
Robert P. J. Day405ae7d2007-02-17 19:13:42 +01004303 err = driver_create_file(sysfs, &driver_attr_fixed_buffer_size);
Jeff Garzik13026a62006-10-04 06:00:38 -04004304 if (err)
4305 goto err_try_direct_io;
Robert P. J. Day405ae7d2007-02-17 19:13:42 +01004306 err = driver_create_file(sysfs, &driver_attr_max_sg_segs);
Jeff Garzik13026a62006-10-04 06:00:38 -04004307 if (err)
4308 goto err_attr_fixed_buf;
Robert P. J. Day405ae7d2007-02-17 19:13:42 +01004309 err = driver_create_file(sysfs, &driver_attr_version);
Jeff Garzik13026a62006-10-04 06:00:38 -04004310 if (err)
4311 goto err_attr_max_sg;
4312
4313 return 0;
4314
4315err_attr_max_sg:
Robert P. J. Day405ae7d2007-02-17 19:13:42 +01004316 driver_remove_file(sysfs, &driver_attr_max_sg_segs);
Jeff Garzik13026a62006-10-04 06:00:38 -04004317err_attr_fixed_buf:
Robert P. J. Day405ae7d2007-02-17 19:13:42 +01004318 driver_remove_file(sysfs, &driver_attr_fixed_buffer_size);
Jeff Garzik13026a62006-10-04 06:00:38 -04004319err_try_direct_io:
Robert P. J. Day405ae7d2007-02-17 19:13:42 +01004320 driver_remove_file(sysfs, &driver_attr_try_direct_io);
Jeff Garzik13026a62006-10-04 06:00:38 -04004321 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004322}
4323
Robert P. J. Day405ae7d2007-02-17 19:13:42 +01004324static void do_remove_sysfs_files(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004325{
Robert P. J. Day405ae7d2007-02-17 19:13:42 +01004326 struct device_driver *sysfs = &st_template.gendrv;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004327
Robert P. J. Day405ae7d2007-02-17 19:13:42 +01004328 driver_remove_file(sysfs, &driver_attr_version);
4329 driver_remove_file(sysfs, &driver_attr_max_sg_segs);
4330 driver_remove_file(sysfs, &driver_attr_fixed_buffer_size);
4331 driver_remove_file(sysfs, &driver_attr_try_direct_io);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004332}
4333
4334
4335/* The sysfs simple class interface */
Tony Jonesee959b02008-02-22 00:13:36 +01004336static ssize_t
4337st_defined_show(struct device *dev, struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004338{
James Bottomley7d15d6a2008-03-14 14:12:43 -07004339 struct st_modedef *STm = dev_get_drvdata(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004340 ssize_t l = 0;
4341
4342 l = snprintf(buf, PAGE_SIZE, "%d\n", STm->defined);
4343 return l;
4344}
4345
Tony Jonesee959b02008-02-22 00:13:36 +01004346DEVICE_ATTR(defined, S_IRUGO, st_defined_show, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004347
Tony Jonesee959b02008-02-22 00:13:36 +01004348static ssize_t
4349st_defblk_show(struct device *dev, struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004350{
James Bottomley7d15d6a2008-03-14 14:12:43 -07004351 struct st_modedef *STm = dev_get_drvdata(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004352 ssize_t l = 0;
4353
4354 l = snprintf(buf, PAGE_SIZE, "%d\n", STm->default_blksize);
4355 return l;
4356}
4357
Tony Jonesee959b02008-02-22 00:13:36 +01004358DEVICE_ATTR(default_blksize, S_IRUGO, st_defblk_show, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004359
Tony Jonesee959b02008-02-22 00:13:36 +01004360static ssize_t
4361st_defdensity_show(struct device *dev, struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004362{
James Bottomley7d15d6a2008-03-14 14:12:43 -07004363 struct st_modedef *STm = dev_get_drvdata(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004364 ssize_t l = 0;
4365 char *fmt;
4366
4367 fmt = STm->default_density >= 0 ? "0x%02x\n" : "%d\n";
4368 l = snprintf(buf, PAGE_SIZE, fmt, STm->default_density);
4369 return l;
4370}
4371
Tony Jonesee959b02008-02-22 00:13:36 +01004372DEVICE_ATTR(default_density, S_IRUGO, st_defdensity_show, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004373
Tony Jonesee959b02008-02-22 00:13:36 +01004374static ssize_t
4375st_defcompression_show(struct device *dev, struct device_attribute *attr,
4376 char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004377{
James Bottomley7d15d6a2008-03-14 14:12:43 -07004378 struct st_modedef *STm = dev_get_drvdata(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004379 ssize_t l = 0;
4380
4381 l = snprintf(buf, PAGE_SIZE, "%d\n", STm->default_compression - 1);
4382 return l;
4383}
4384
Tony Jonesee959b02008-02-22 00:13:36 +01004385DEVICE_ATTR(default_compression, S_IRUGO, st_defcompression_show, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004386
Tony Jonesee959b02008-02-22 00:13:36 +01004387static ssize_t
4388st_options_show(struct device *dev, struct device_attribute *attr, char *buf)
Kai Makisarab174be02008-02-24 22:29:12 +02004389{
James Bottomley7d15d6a2008-03-14 14:12:43 -07004390 struct st_modedef *STm = dev_get_drvdata(dev);
Kai Makisarab174be02008-02-24 22:29:12 +02004391 struct scsi_tape *STp;
4392 int i, j, options;
4393 ssize_t l = 0;
4394
4395 for (i=0; i < st_dev_max; i++) {
4396 for (j=0; j < ST_NBR_MODES; j++)
4397 if (&scsi_tapes[i]->modes[j] == STm)
4398 break;
4399 if (j < ST_NBR_MODES)
4400 break;
4401 }
4402 if (i == st_dev_max)
4403 return 0; /* should never happen */
4404
4405 STp = scsi_tapes[i];
4406
4407 options = STm->do_buffer_writes ? MT_ST_BUFFER_WRITES : 0;
4408 options |= STm->do_async_writes ? MT_ST_ASYNC_WRITES : 0;
4409 options |= STm->do_read_ahead ? MT_ST_READ_AHEAD : 0;
4410 DEB( options |= debugging ? MT_ST_DEBUGGING : 0 );
4411 options |= STp->two_fm ? MT_ST_TWO_FM : 0;
4412 options |= STp->fast_mteom ? MT_ST_FAST_MTEOM : 0;
4413 options |= STm->defaults_for_writes ? MT_ST_DEF_WRITES : 0;
4414 options |= STp->can_bsr ? MT_ST_CAN_BSR : 0;
4415 options |= STp->omit_blklims ? MT_ST_NO_BLKLIMS : 0;
4416 options |= STp->can_partitions ? MT_ST_CAN_PARTITIONS : 0;
4417 options |= STp->scsi2_logical ? MT_ST_SCSI2LOGICAL : 0;
4418 options |= STm->sysv ? MT_ST_SYSV : 0;
4419 options |= STp->immediate ? MT_ST_NOWAIT : 0;
4420 options |= STp->sili ? MT_ST_SILI : 0;
4421
4422 l = snprintf(buf, PAGE_SIZE, "0x%08x\n", options);
4423 return l;
4424}
4425
Tony Jonesee959b02008-02-22 00:13:36 +01004426DEVICE_ATTR(options, S_IRUGO, st_options_show, NULL);
Kai Makisarab174be02008-02-24 22:29:12 +02004427
Jeff Garzik13026a62006-10-04 06:00:38 -04004428static int do_create_class_files(struct scsi_tape *STp, int dev_num, int mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004429{
4430 int i, rew, error;
4431 char name[10];
Tony Jonesee959b02008-02-22 00:13:36 +01004432 struct device *st_class_member;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004433
Linus Torvalds1da177e2005-04-16 15:20:36 -07004434 for (rew=0; rew < 2; rew++) {
4435 /* Make sure that the minor numbers corresponding to the four
4436 first modes always get the same names */
4437 i = mode << (4 - ST_NBR_MODE_BITS);
4438 snprintf(name, 10, "%s%s%s", rew ? "n" : "",
4439 STp->disk->disk_name, st_formats[i]);
4440 st_class_member =
Greg Kroah-Hartmand73a1a62008-07-21 20:03:34 -07004441 device_create(st_sysfs_class, &STp->device->sdev_gendev,
4442 MKDEV(SCSI_TAPE_MAJOR,
4443 TAPE_MINOR(dev_num, mode, rew)),
4444 &STp->modes[mode], "%s", name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004445 if (IS_ERR(st_class_member)) {
Tony Jonesee959b02008-02-22 00:13:36 +01004446 printk(KERN_WARNING "st%d: device_create failed\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07004447 dev_num);
Jeff Garzik13026a62006-10-04 06:00:38 -04004448 error = PTR_ERR(st_class_member);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004449 goto out;
4450 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004451
Tony Jonesee959b02008-02-22 00:13:36 +01004452 error = device_create_file(st_class_member,
4453 &dev_attr_defined);
Jeff Garzik13026a62006-10-04 06:00:38 -04004454 if (error) goto out;
Tony Jonesee959b02008-02-22 00:13:36 +01004455 error = device_create_file(st_class_member,
4456 &dev_attr_default_blksize);
Jeff Garzik13026a62006-10-04 06:00:38 -04004457 if (error) goto out;
Tony Jonesee959b02008-02-22 00:13:36 +01004458 error = device_create_file(st_class_member,
4459 &dev_attr_default_density);
Jeff Garzik13026a62006-10-04 06:00:38 -04004460 if (error) goto out;
Tony Jonesee959b02008-02-22 00:13:36 +01004461 error = device_create_file(st_class_member,
4462 &dev_attr_default_compression);
Jeff Garzik13026a62006-10-04 06:00:38 -04004463 if (error) goto out;
Tony Jonesee959b02008-02-22 00:13:36 +01004464 error = device_create_file(st_class_member,
4465 &dev_attr_options);
Kai Makisarab174be02008-02-24 22:29:12 +02004466 if (error) goto out;
Jeff Garzik13026a62006-10-04 06:00:38 -04004467
Linus Torvalds1da177e2005-04-16 15:20:36 -07004468 if (mode == 0 && rew == 0) {
4469 error = sysfs_create_link(&STp->device->sdev_gendev.kobj,
4470 &st_class_member->kobj,
4471 "tape");
4472 if (error) {
4473 printk(KERN_ERR
4474 "st%d: Can't create sysfs link from SCSI device.\n",
4475 dev_num);
Jeff Garzik13026a62006-10-04 06:00:38 -04004476 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004477 }
4478 }
4479 }
Jeff Garzik13026a62006-10-04 06:00:38 -04004480
4481 return 0;
4482
4483out:
4484 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004485}
4486
Linus Torvalds1da177e2005-04-16 15:20:36 -07004487/* The following functions may be useful for a larger audience. */
4488static int sgl_map_user_pages(struct scatterlist *sgl, const unsigned int max_pages,
4489 unsigned long uaddr, size_t count, int rw)
4490{
James Bottomley07542b82005-08-31 20:27:22 -04004491 unsigned long end = (uaddr + count + PAGE_SIZE - 1) >> PAGE_SHIFT;
4492 unsigned long start = uaddr >> PAGE_SHIFT;
4493 const int nr_pages = end - start;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004494 int res, i, j;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004495 struct page **pages;
4496
Linus Torvalds1da177e2005-04-16 15:20:36 -07004497 /* User attempted Overflow! */
4498 if ((uaddr + count) < uaddr)
4499 return -EINVAL;
4500
4501 /* Too big */
4502 if (nr_pages > max_pages)
4503 return -ENOMEM;
4504
4505 /* Hmm? */
4506 if (count == 0)
4507 return 0;
4508
4509 if ((pages = kmalloc(max_pages * sizeof(*pages), GFP_KERNEL)) == NULL)
4510 return -ENOMEM;
4511
4512 /* Try to fault in all of the necessary pages */
4513 down_read(&current->mm->mmap_sem);
4514 /* rw==READ means read from drive, write into memory area */
4515 res = get_user_pages(
4516 current,
4517 current->mm,
4518 uaddr,
4519 nr_pages,
4520 rw == READ,
4521 0, /* don't force */
4522 pages,
4523 NULL);
4524 up_read(&current->mm->mmap_sem);
4525
4526 /* Errors and no page mapped should return here */
4527 if (res < nr_pages)
4528 goto out_unmap;
4529
4530 for (i=0; i < nr_pages; i++) {
4531 /* FIXME: flush superflous for rw==READ,
4532 * probably wrong function for rw==WRITE
4533 */
4534 flush_dcache_page(pages[i]);
4535 }
4536
4537 /* Populate the scatter/gather list */
Jens Axboe642f1492007-10-24 11:20:47 +02004538 sg_set_page(&sgl[0], pages[0], 0, uaddr & ~PAGE_MASK);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004539 if (nr_pages > 1) {
4540 sgl[0].length = PAGE_SIZE - sgl[0].offset;
4541 count -= sgl[0].length;
4542 for (i=1; i < nr_pages ; i++) {
Jens Axboe642f1492007-10-24 11:20:47 +02004543 sg_set_page(&sgl[i], pages[i],
4544 count < PAGE_SIZE ? count : PAGE_SIZE, 0);;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004545 count -= PAGE_SIZE;
4546 }
4547 }
4548 else {
4549 sgl[0].length = count;
4550 }
4551
4552 kfree(pages);
4553 return nr_pages;
4554
4555 out_unmap:
4556 if (res > 0) {
4557 for (j=0; j < res; j++)
4558 page_cache_release(pages[j]);
Hugh Dickins6bc733e2005-12-01 20:21:57 +00004559 res = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004560 }
4561 kfree(pages);
4562 return res;
4563}
4564
4565
4566/* And unmap them... */
4567static int sgl_unmap_user_pages(struct scatterlist *sgl, const unsigned int nr_pages,
4568 int dirtied)
4569{
4570 int i;
4571
4572 for (i=0; i < nr_pages; i++) {
Jens Axboe45711f12007-10-22 21:19:53 +02004573 struct page *page = sg_page(&sgl[i]);
Nick Pigginb5810032005-10-29 18:16:12 -07004574
Nick Pigginb5810032005-10-29 18:16:12 -07004575 if (dirtied)
4576 SetPageDirty(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004577 /* FIXME: cache flush missing for rw==READ
4578 * FIXME: call the correct reference counting function
4579 */
Nick Pigginb5810032005-10-29 18:16:12 -07004580 page_cache_release(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004581 }
4582
4583 return 0;
4584}