blob: d04ea9a6f6732b27526d748ba5b2524e6ebb7c23 [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 Makisara02ae2c02008-12-18 14:49:50 +090020static const char *verstr = "20081215";
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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700185static int enlarge_buffer(struct st_buffer *, int, int);
Kai Makisara40f6b362008-02-24 22:23:24 +0200186static void clear_buffer(struct st_buffer *);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700187static void normalize_buffer(struct st_buffer *);
188static int append_to_buffer(const char __user *, struct st_buffer *, int);
189static int from_buffer(struct st_buffer *, char __user *, int);
190static void move_buffer_data(struct st_buffer *, int);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191
FUJITA Tomonori66207422008-12-18 14:49:43 +0900192static int sgl_map_user_pages(struct st_buffer *, const unsigned int,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193 unsigned long, size_t, int);
FUJITA Tomonori66207422008-12-18 14:49:43 +0900194static int sgl_unmap_user_pages(struct st_buffer *, const unsigned int, int);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195
196static int st_probe(struct device *);
197static int st_remove(struct device *);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198
Robert P. J. Day405ae7d2007-02-17 19:13:42 +0100199static int do_create_sysfs_files(void);
200static void do_remove_sysfs_files(void);
Jeff Garzik13026a62006-10-04 06:00:38 -0400201static int do_create_class_files(struct scsi_tape *, int, int);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202
203static struct scsi_driver st_template = {
204 .owner = THIS_MODULE,
205 .gendrv = {
206 .name = "st",
207 .probe = st_probe,
208 .remove = st_remove,
209 },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210};
211
212static int st_compression(struct scsi_tape *, int);
213
214static int find_partition(struct scsi_tape *);
215static int switch_partition(struct scsi_tape *);
216
217static int st_int_ioctl(struct scsi_tape *, unsigned int, unsigned long);
218
Kai Makisaraf03a5672005-08-02 13:40:47 +0300219static void scsi_tape_release(struct kref *);
220
221#define to_scsi_tape(obj) container_of(obj, struct scsi_tape, kref)
222
Arjan van de Ven0b950672006-01-11 13:16:10 +0100223static DEFINE_MUTEX(st_ref_mutex);
Kai Makisaraf03a5672005-08-02 13:40:47 +0300224
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225
226#include "osst_detect.h"
227#ifndef SIGS_FROM_OSST
228#define SIGS_FROM_OSST \
229 {"OnStream", "SC-", "", "osst"}, \
230 {"OnStream", "DI-", "", "osst"}, \
231 {"OnStream", "DP-", "", "osst"}, \
232 {"OnStream", "USB", "", "osst"}, \
233 {"OnStream", "FW-", "", "osst"}
234#endif
235
Kai Makisaraf03a5672005-08-02 13:40:47 +0300236static struct scsi_tape *scsi_tape_get(int dev)
237{
238 struct scsi_tape *STp = NULL;
239
Arjan van de Ven0b950672006-01-11 13:16:10 +0100240 mutex_lock(&st_ref_mutex);
Kai Makisaraf03a5672005-08-02 13:40:47 +0300241 write_lock(&st_dev_arr_lock);
242
243 if (dev < st_dev_max && scsi_tapes != NULL)
244 STp = scsi_tapes[dev];
245 if (!STp) goto out;
246
247 kref_get(&STp->kref);
248
249 if (!STp->device)
250 goto out_put;
251
252 if (scsi_device_get(STp->device))
253 goto out_put;
254
255 goto out;
256
257out_put:
258 kref_put(&STp->kref, scsi_tape_release);
259 STp = NULL;
260out:
261 write_unlock(&st_dev_arr_lock);
Arjan van de Ven0b950672006-01-11 13:16:10 +0100262 mutex_unlock(&st_ref_mutex);
Kai Makisaraf03a5672005-08-02 13:40:47 +0300263 return STp;
264}
265
266static void scsi_tape_put(struct scsi_tape *STp)
267{
268 struct scsi_device *sdev = STp->device;
269
Arjan van de Ven0b950672006-01-11 13:16:10 +0100270 mutex_lock(&st_ref_mutex);
Kai Makisaraf03a5672005-08-02 13:40:47 +0300271 kref_put(&STp->kref, scsi_tape_release);
272 scsi_device_put(sdev);
Arjan van de Ven0b950672006-01-11 13:16:10 +0100273 mutex_unlock(&st_ref_mutex);
Kai Makisaraf03a5672005-08-02 13:40:47 +0300274}
275
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276struct st_reject_data {
277 char *vendor;
278 char *model;
279 char *rev;
280 char *driver_hint; /* Name of the correct driver, NULL if unknown */
281};
282
283static struct st_reject_data reject_list[] = {
284 /* {"XXX", "Yy-", "", NULL}, example */
285 SIGS_FROM_OSST,
286 {NULL, }};
287
288/* If the device signature is on the list of incompatible drives, the
289 function returns a pointer to the name of the correct driver (if known) */
290static char * st_incompatible(struct scsi_device* SDp)
291{
292 struct st_reject_data *rp;
293
294 for (rp=&(reject_list[0]); rp->vendor != NULL; rp++)
295 if (!strncmp(rp->vendor, SDp->vendor, strlen(rp->vendor)) &&
296 !strncmp(rp->model, SDp->model, strlen(rp->model)) &&
297 !strncmp(rp->rev, SDp->rev, strlen(rp->rev))) {
298 if (rp->driver_hint)
299 return rp->driver_hint;
300 else
301 return "unknown";
302 }
303 return NULL;
304}
305
306
307static inline char *tape_name(struct scsi_tape *tape)
308{
309 return tape->disk->disk_name;
310}
311
312
Mike Christie8b05b772005-11-08 04:06:44 -0600313static void st_analyze_sense(struct st_request *SRpnt, struct st_cmdstatus *s)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314{
315 const u8 *ucp;
Mike Christie8b05b772005-11-08 04:06:44 -0600316 const u8 *sense = SRpnt->sense;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317
Mike Christie8b05b772005-11-08 04:06:44 -0600318 s->have_sense = scsi_normalize_sense(SRpnt->sense,
319 SCSI_SENSE_BUFFERSIZE, &s->sense_hdr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320 s->flags = 0;
321
322 if (s->have_sense) {
323 s->deferred = 0;
324 s->remainder_valid =
325 scsi_get_sense_info_fld(sense, SCSI_SENSE_BUFFERSIZE, &s->uremainder64);
326 switch (sense[0] & 0x7f) {
327 case 0x71:
328 s->deferred = 1;
329 case 0x70:
330 s->fixed_format = 1;
331 s->flags = sense[2] & 0xe0;
332 break;
333 case 0x73:
334 s->deferred = 1;
335 case 0x72:
336 s->fixed_format = 0;
337 ucp = scsi_sense_desc_find(sense, SCSI_SENSE_BUFFERSIZE, 4);
338 s->flags = ucp ? (ucp[3] & 0xe0) : 0;
339 break;
340 }
341 }
342}
343
344
345/* Convert the result to success code */
Mike Christie8b05b772005-11-08 04:06:44 -0600346static int st_chk_result(struct scsi_tape *STp, struct st_request * SRpnt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347{
Mike Christie8b05b772005-11-08 04:06:44 -0600348 int result = SRpnt->result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349 u8 scode;
350 DEB(const char *stp;)
351 char *name = tape_name(STp);
352 struct st_cmdstatus *cmdstatp;
353
354 if (!result)
355 return 0;
356
357 cmdstatp = &STp->buffer->cmdstat;
Kai Makisaraf03a5672005-08-02 13:40:47 +0300358 st_analyze_sense(SRpnt, cmdstatp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359
360 if (cmdstatp->have_sense)
361 scode = STp->buffer->cmdstat.sense_hdr.sense_key;
362 else
363 scode = 0;
364
365 DEB(
366 if (debugging) {
Mike Christie8b05b772005-11-08 04:06:44 -0600367 printk(ST_DEB_MSG "%s: Error: %x, cmd: %x %x %x %x %x %x\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368 name, result,
Mike Christie8b05b772005-11-08 04:06:44 -0600369 SRpnt->cmd[0], SRpnt->cmd[1], SRpnt->cmd[2],
370 SRpnt->cmd[3], SRpnt->cmd[4], SRpnt->cmd[5]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371 if (cmdstatp->have_sense)
Luben Tuikov4e73ea72006-07-07 00:02:18 -0700372 __scsi_print_sense(name, SRpnt->sense, SCSI_SENSE_BUFFERSIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700373 } ) /* end DEB */
374 if (!debugging) { /* Abnormal conditions for tape */
375 if (!cmdstatp->have_sense)
376 printk(KERN_WARNING
Martin K. Petersen1c9fbaf2009-01-04 03:14:11 -0500377 "%s: Error %x (driver bt 0x%x, host bt 0x%x).\n",
378 name, result, driver_byte(result),
379 host_byte(result));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380 else if (cmdstatp->have_sense &&
381 scode != NO_SENSE &&
382 scode != RECOVERED_ERROR &&
383 /* scode != UNIT_ATTENTION && */
384 scode != BLANK_CHECK &&
385 scode != VOLUME_OVERFLOW &&
Mike Christie8b05b772005-11-08 04:06:44 -0600386 SRpnt->cmd[0] != MODE_SENSE &&
387 SRpnt->cmd[0] != TEST_UNIT_READY) {
Luben Tuikov4e73ea72006-07-07 00:02:18 -0700388
389 __scsi_print_sense(name, SRpnt->sense, SCSI_SENSE_BUFFERSIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390 }
391 }
392
393 if (cmdstatp->fixed_format &&
394 STp->cln_mode >= EXTENDED_SENSE_START) { /* Only fixed format sense */
395 if (STp->cln_sense_value)
Mike Christie8b05b772005-11-08 04:06:44 -0600396 STp->cleaning_req |= ((SRpnt->sense[STp->cln_mode] &
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397 STp->cln_sense_mask) == STp->cln_sense_value);
398 else
Mike Christie8b05b772005-11-08 04:06:44 -0600399 STp->cleaning_req |= ((SRpnt->sense[STp->cln_mode] &
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400 STp->cln_sense_mask) != 0);
401 }
402 if (cmdstatp->have_sense &&
403 cmdstatp->sense_hdr.asc == 0 && cmdstatp->sense_hdr.ascq == 0x17)
404 STp->cleaning_req = 1; /* ASC and ASCQ => cleaning requested */
405
406 STp->pos_unknown |= STp->device->was_reset;
407
408 if (cmdstatp->have_sense &&
409 scode == RECOVERED_ERROR
410#if ST_RECOVERED_WRITE_FATAL
Mike Christie8b05b772005-11-08 04:06:44 -0600411 && SRpnt->cmd[0] != WRITE_6
412 && SRpnt->cmd[0] != WRITE_FILEMARKS
Linus Torvalds1da177e2005-04-16 15:20:36 -0700413#endif
414 ) {
415 STp->recover_count++;
416 STp->recover_reg++;
417
418 DEB(
419 if (debugging) {
Mike Christie8b05b772005-11-08 04:06:44 -0600420 if (SRpnt->cmd[0] == READ_6)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421 stp = "read";
Mike Christie8b05b772005-11-08 04:06:44 -0600422 else if (SRpnt->cmd[0] == WRITE_6)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423 stp = "write";
424 else
425 stp = "ioctl";
426 printk(ST_DEB_MSG "%s: Recovered %s error (%d).\n", name, stp,
427 STp->recover_count);
428 } ) /* end DEB */
429
430 if (cmdstatp->flags == 0)
431 return 0;
432 }
433 return (-EIO);
434}
435
FUJITA Tomonori4deba242008-12-05 15:25:20 +0900436static struct st_request *st_allocate_request(struct scsi_tape *stp)
Mike Christie8b05b772005-11-08 04:06:44 -0600437{
FUJITA Tomonori4deba242008-12-05 15:25:20 +0900438 struct st_request *streq;
439
440 streq = kzalloc(sizeof(*streq), GFP_KERNEL);
441 if (streq)
442 streq->stp = stp;
443 else {
444 DEBC(printk(KERN_ERR "%s: Can't get SCSI request.\n",
445 tape_name(stp)););
446 if (signal_pending(current))
447 stp->buffer->syscall_result = -EINTR;
448 else
449 stp->buffer->syscall_result = -EBUSY;
450 }
451
452 return streq;
Mike Christie8b05b772005-11-08 04:06:44 -0600453}
454
455static void st_release_request(struct st_request *streq)
456{
457 kfree(streq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700458}
459
FUJITA Tomonori13b53b42008-12-18 14:49:41 +0900460static void st_scsi_execute_end(struct request *req, int uptodate)
461{
462 struct st_request *SRpnt = req->end_io_data;
463 struct scsi_tape *STp = SRpnt->stp;
464
465 STp->buffer->cmdstat.midlevel_result = SRpnt->result = req->errors;
Tejun Heoc3a4d782009-05-07 22:24:37 +0900466 STp->buffer->cmdstat.residual = req->resid_len;
FUJITA Tomonori13b53b42008-12-18 14:49:41 +0900467
468 if (SRpnt->waiting)
469 complete(SRpnt->waiting);
470
471 blk_rq_unmap_user(SRpnt->bio);
472 __blk_put_request(req->q, req);
473}
474
475static int st_scsi_execute(struct st_request *SRpnt, const unsigned char *cmd,
476 int data_direction, void *buffer, unsigned bufflen,
477 int timeout, int retries)
478{
479 struct request *req;
480 struct rq_map_data *mdata = &SRpnt->stp->buffer->map_data;
481 int err = 0;
482 int write = (data_direction == DMA_TO_DEVICE);
483
484 req = blk_get_request(SRpnt->stp->device->request_queue, write,
485 GFP_KERNEL);
486 if (!req)
487 return DRIVER_ERROR << 24;
488
489 req->cmd_type = REQ_TYPE_BLOCK_PC;
490 req->cmd_flags |= REQ_QUIET;
491
492 mdata->null_mapped = 1;
493
Kai Makisara02ae2c02008-12-18 14:49:50 +0900494 if (bufflen) {
495 err = blk_rq_map_user(req->q, req, mdata, NULL, bufflen,
496 GFP_KERNEL);
497 if (err) {
498 blk_put_request(req);
499 return DRIVER_ERROR << 24;
500 }
FUJITA Tomonori13b53b42008-12-18 14:49:41 +0900501 }
502
503 SRpnt->bio = req->bio;
504 req->cmd_len = COMMAND_SIZE(cmd[0]);
505 memset(req->cmd, 0, BLK_MAX_CDB);
506 memcpy(req->cmd, cmd, req->cmd_len);
507 req->sense = SRpnt->sense;
508 req->sense_len = 0;
509 req->timeout = timeout;
510 req->retries = retries;
511 req->end_io_data = SRpnt;
512
513 blk_execute_rq_nowait(req->q, NULL, req, 1, st_scsi_execute_end);
514 return 0;
515}
516
Linus Torvalds1da177e2005-04-16 15:20:36 -0700517/* Do the scsi command. Waits until command performed if do_wait is true.
518 Otherwise write_behind_check() is used to check that the command
519 has finished. */
Mike Christie8b05b772005-11-08 04:06:44 -0600520static struct st_request *
521st_do_scsi(struct st_request * SRpnt, struct scsi_tape * STp, unsigned char *cmd,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700522 int bytes, int direction, int timeout, int retries, int do_wait)
523{
Kai Makisaraf03a5672005-08-02 13:40:47 +0300524 struct completion *waiting;
FUJITA Tomonori6d476262008-12-18 14:49:42 +0900525 struct rq_map_data *mdata = &STp->buffer->map_data;
526 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700527
Kai Makisaraf03a5672005-08-02 13:40:47 +0300528 /* if async, make sure there's no command outstanding */
529 if (!do_wait && ((STp->buffer)->last_SRpnt)) {
530 printk(KERN_ERR "%s: Async command already active.\n",
531 tape_name(STp));
532 if (signal_pending(current))
533 (STp->buffer)->syscall_result = (-EINTR);
534 else
535 (STp->buffer)->syscall_result = (-EBUSY);
536 return NULL;
537 }
538
FUJITA Tomonori4deba242008-12-05 15:25:20 +0900539 if (!SRpnt) {
540 SRpnt = st_allocate_request(STp);
541 if (!SRpnt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700543 }
544
Kai Makisaraf03a5672005-08-02 13:40:47 +0300545 /* If async IO, set last_SRpnt. This ptr tells write_behind_check
546 which IO is outstanding. It's nulled out when the IO completes. */
547 if (!do_wait)
548 (STp->buffer)->last_SRpnt = SRpnt;
549
550 waiting = &STp->wait;
551 init_completion(waiting);
Mike Christie8b05b772005-11-08 04:06:44 -0600552 SRpnt->waiting = waiting;
553
FUJITA Tomonori66207422008-12-18 14:49:43 +0900554 if (STp->buffer->do_dio) {
FUJITA Tomonoric982c362009-11-26 09:24:13 +0900555 mdata->page_order = 0;
FUJITA Tomonori66207422008-12-18 14:49:43 +0900556 mdata->nr_entries = STp->buffer->sg_segs;
557 mdata->pages = STp->buffer->mapped_pages;
558 } else {
FUJITA Tomonoric982c362009-11-26 09:24:13 +0900559 mdata->page_order = STp->buffer->reserved_page_order;
FUJITA Tomonori6d476262008-12-18 14:49:42 +0900560 mdata->nr_entries =
561 DIV_ROUND_UP(bytes, PAGE_SIZE << mdata->page_order);
FUJITA Tomonoric982c362009-11-26 09:24:13 +0900562 mdata->pages = STp->buffer->reserved_pages;
563 mdata->offset = 0;
FUJITA Tomonori6d476262008-12-18 14:49:42 +0900564 }
565
Mike Christie8b05b772005-11-08 04:06:44 -0600566 memcpy(SRpnt->cmd, cmd, sizeof(SRpnt->cmd));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700567 STp->buffer->cmdstat.have_sense = 0;
Mike Christie8b05b772005-11-08 04:06:44 -0600568 STp->buffer->syscall_result = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569
FUJITA Tomonori66207422008-12-18 14:49:43 +0900570 ret = st_scsi_execute(SRpnt, cmd, direction, NULL, bytes, timeout,
571 retries);
FUJITA Tomonori6d476262008-12-18 14:49:42 +0900572 if (ret) {
Mike Christie8b05b772005-11-08 04:06:44 -0600573 /* could not allocate the buffer or request was too large */
574 (STp->buffer)->syscall_result = (-EBUSY);
Kai Makisara787926b2005-11-13 10:04:44 +0200575 (STp->buffer)->last_SRpnt = NULL;
FUJITA Tomonori6d476262008-12-18 14:49:42 +0900576 } else if (do_wait) {
Kai Makisaraf03a5672005-08-02 13:40:47 +0300577 wait_for_completion(waiting);
Mike Christie8b05b772005-11-08 04:06:44 -0600578 SRpnt->waiting = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579 (STp->buffer)->syscall_result = st_chk_result(STp, SRpnt);
580 }
Mike Christie8b05b772005-11-08 04:06:44 -0600581
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582 return SRpnt;
583}
584
585
586/* Handle the write-behind checking (waits for completion). Returns -ENOSPC if
587 write has been correct but EOM early warning reached, -EIO if write ended in
588 error or zero if write successful. Asynchronous writes are used only in
589 variable block mode. */
590static int write_behind_check(struct scsi_tape * STp)
591{
592 int retval = 0;
593 struct st_buffer *STbuffer;
594 struct st_partstat *STps;
595 struct st_cmdstatus *cmdstatp;
Mike Christie8b05b772005-11-08 04:06:44 -0600596 struct st_request *SRpnt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597
598 STbuffer = STp->buffer;
599 if (!STbuffer->writing)
600 return 0;
601
602 DEB(
603 if (STp->write_pending)
604 STp->nbr_waits++;
605 else
606 STp->nbr_finished++;
607 ) /* end DEB */
608
609 wait_for_completion(&(STp->wait));
Kai Makisaraf03a5672005-08-02 13:40:47 +0300610 SRpnt = STbuffer->last_SRpnt;
611 STbuffer->last_SRpnt = NULL;
Mike Christie8b05b772005-11-08 04:06:44 -0600612 SRpnt->waiting = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700613
Kai Makisaraf03a5672005-08-02 13:40:47 +0300614 (STp->buffer)->syscall_result = st_chk_result(STp, SRpnt);
Mike Christie8b05b772005-11-08 04:06:44 -0600615 st_release_request(SRpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700616
617 STbuffer->buffer_bytes -= STbuffer->writing;
618 STps = &(STp->ps[STp->partition]);
619 if (STps->drv_block >= 0) {
620 if (STp->block_size == 0)
621 STps->drv_block++;
622 else
623 STps->drv_block += STbuffer->writing / STp->block_size;
624 }
625
626 cmdstatp = &STbuffer->cmdstat;
627 if (STbuffer->syscall_result) {
628 retval = -EIO;
629 if (cmdstatp->have_sense && !cmdstatp->deferred &&
630 (cmdstatp->flags & SENSE_EOM) &&
631 (cmdstatp->sense_hdr.sense_key == NO_SENSE ||
632 cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR)) {
633 /* EOM at write-behind, has all data been written? */
634 if (!cmdstatp->remainder_valid ||
635 cmdstatp->uremainder64 == 0)
636 retval = -ENOSPC;
637 }
638 if (retval == -EIO)
639 STps->drv_block = -1;
640 }
641 STbuffer->writing = 0;
642
643 DEB(if (debugging && retval)
644 printk(ST_DEB_MSG "%s: Async write error %x, return value %d.\n",
645 tape_name(STp), STbuffer->cmdstat.midlevel_result, retval);) /* end DEB */
646
647 return retval;
648}
649
650
651/* Step over EOF if it has been inadvertently crossed (ioctl not used because
652 it messes up the block number). */
653static int cross_eof(struct scsi_tape * STp, int forward)
654{
Mike Christie8b05b772005-11-08 04:06:44 -0600655 struct st_request *SRpnt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656 unsigned char cmd[MAX_COMMAND_SIZE];
657
658 cmd[0] = SPACE;
659 cmd[1] = 0x01; /* Space FileMarks */
660 if (forward) {
661 cmd[2] = cmd[3] = 0;
662 cmd[4] = 1;
663 } else
664 cmd[2] = cmd[3] = cmd[4] = 0xff; /* -1 filemarks */
665 cmd[5] = 0;
666
667 DEBC(printk(ST_DEB_MSG "%s: Stepping over filemark %s.\n",
668 tape_name(STp), forward ? "forward" : "backward"));
669
Kai Makisara02ae2c02008-12-18 14:49:50 +0900670 SRpnt = st_do_scsi(NULL, STp, cmd, 0, DMA_NONE,
671 STp->device->request_queue->rq_timeout,
672 MAX_RETRIES, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700673 if (!SRpnt)
Kai Makisara02ae2c02008-12-18 14:49:50 +0900674 return (STp->buffer)->syscall_result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700675
Kai Makisara02ae2c02008-12-18 14:49:50 +0900676 st_release_request(SRpnt);
677 SRpnt = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700678
679 if ((STp->buffer)->cmdstat.midlevel_result != 0)
680 printk(KERN_ERR "%s: Stepping over filemark %s failed.\n",
681 tape_name(STp), forward ? "forward" : "backward");
682
Kai Makisara02ae2c02008-12-18 14:49:50 +0900683 return (STp->buffer)->syscall_result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700684}
685
686
687/* Flush the write buffer (never need to write if variable blocksize). */
Adrian Bunk8ef8d592008-04-14 17:17:16 +0300688static int st_flush_write_buffer(struct scsi_tape * STp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700689{
Kai Makisara786231a2008-07-11 15:06:40 +0300690 int transfer, blks;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700691 int result;
692 unsigned char cmd[MAX_COMMAND_SIZE];
Mike Christie8b05b772005-11-08 04:06:44 -0600693 struct st_request *SRpnt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700694 struct st_partstat *STps;
695
696 result = write_behind_check(STp);
697 if (result)
698 return result;
699
700 result = 0;
701 if (STp->dirty == 1) {
702
Kai Makisara786231a2008-07-11 15:06:40 +0300703 transfer = STp->buffer->buffer_bytes;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700704 DEBC(printk(ST_DEB_MSG "%s: Flushing %d bytes.\n",
705 tape_name(STp), transfer));
706
Linus Torvalds1da177e2005-04-16 15:20:36 -0700707 memset(cmd, 0, MAX_COMMAND_SIZE);
708 cmd[0] = WRITE_6;
709 cmd[1] = 1;
710 blks = transfer / STp->block_size;
711 cmd[2] = blks >> 16;
712 cmd[3] = blks >> 8;
713 cmd[4] = blks;
714
715 SRpnt = st_do_scsi(NULL, STp, cmd, transfer, DMA_TO_DEVICE,
James Bottomleya02488e2008-11-30 10:36:26 -0600716 STp->device->request_queue->rq_timeout,
717 MAX_WRITE_RETRIES, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700718 if (!SRpnt)
719 return (STp->buffer)->syscall_result;
720
721 STps = &(STp->ps[STp->partition]);
722 if ((STp->buffer)->syscall_result != 0) {
723 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
724
725 if (cmdstatp->have_sense && !cmdstatp->deferred &&
726 (cmdstatp->flags & SENSE_EOM) &&
727 (cmdstatp->sense_hdr.sense_key == NO_SENSE ||
728 cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR) &&
729 (!cmdstatp->remainder_valid ||
730 cmdstatp->uremainder64 == 0)) { /* All written at EOM early warning */
731 STp->dirty = 0;
732 (STp->buffer)->buffer_bytes = 0;
733 if (STps->drv_block >= 0)
734 STps->drv_block += blks;
735 result = (-ENOSPC);
736 } else {
737 printk(KERN_ERR "%s: Error on flush.\n",
738 tape_name(STp));
739 STps->drv_block = (-1);
740 result = (-EIO);
741 }
742 } else {
743 if (STps->drv_block >= 0)
744 STps->drv_block += blks;
745 STp->dirty = 0;
746 (STp->buffer)->buffer_bytes = 0;
747 }
Mike Christie8b05b772005-11-08 04:06:44 -0600748 st_release_request(SRpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700749 SRpnt = NULL;
750 }
751 return result;
752}
753
754
755/* Flush the tape buffer. The tape will be positioned correctly unless
756 seek_next is true. */
757static int flush_buffer(struct scsi_tape *STp, int seek_next)
758{
759 int backspace, result;
760 struct st_buffer *STbuffer;
761 struct st_partstat *STps;
762
763 STbuffer = STp->buffer;
764
765 /*
766 * If there was a bus reset, block further access
767 * to this device.
768 */
769 if (STp->pos_unknown)
770 return (-EIO);
771
772 if (STp->ready != ST_READY)
773 return 0;
774 STps = &(STp->ps[STp->partition]);
775 if (STps->rw == ST_WRITING) /* Writing */
Adrian Bunk8ef8d592008-04-14 17:17:16 +0300776 return st_flush_write_buffer(STp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700777
778 if (STp->block_size == 0)
779 return 0;
780
781 backspace = ((STp->buffer)->buffer_bytes +
782 (STp->buffer)->read_pointer) / STp->block_size -
783 ((STp->buffer)->read_pointer + STp->block_size - 1) /
784 STp->block_size;
785 (STp->buffer)->buffer_bytes = 0;
786 (STp->buffer)->read_pointer = 0;
787 result = 0;
788 if (!seek_next) {
789 if (STps->eof == ST_FM_HIT) {
790 result = cross_eof(STp, 0); /* Back over the EOF hit */
791 if (!result)
792 STps->eof = ST_NOEOF;
793 else {
794 if (STps->drv_file >= 0)
795 STps->drv_file++;
796 STps->drv_block = 0;
797 }
798 }
799 if (!result && backspace > 0)
800 result = st_int_ioctl(STp, MTBSR, backspace);
801 } else if (STps->eof == ST_FM_HIT) {
802 if (STps->drv_file >= 0)
803 STps->drv_file++;
804 STps->drv_block = 0;
805 STps->eof = ST_NOEOF;
806 }
807 return result;
808
809}
810
811/* Set the mode parameters */
812static int set_mode_densblk(struct scsi_tape * STp, struct st_modedef * STm)
813{
814 int set_it = 0;
815 unsigned long arg;
816 char *name = tape_name(STp);
817
818 if (!STp->density_changed &&
819 STm->default_density >= 0 &&
820 STm->default_density != STp->density) {
821 arg = STm->default_density;
822 set_it = 1;
823 } else
824 arg = STp->density;
825 arg <<= MT_ST_DENSITY_SHIFT;
826 if (!STp->blksize_changed &&
827 STm->default_blksize >= 0 &&
828 STm->default_blksize != STp->block_size) {
829 arg |= STm->default_blksize;
830 set_it = 1;
831 } else
832 arg |= STp->block_size;
833 if (set_it &&
834 st_int_ioctl(STp, SET_DENS_AND_BLK, arg)) {
835 printk(KERN_WARNING
836 "%s: Can't set default block size to %d bytes and density %x.\n",
837 name, STm->default_blksize, STm->default_density);
838 if (modes_defined)
839 return (-EINVAL);
840 }
841 return 0;
842}
843
844
Mike Christie8b05b772005-11-08 04:06:44 -0600845/* Lock or unlock the drive door. Don't use when st_request allocated. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700846static int do_door_lock(struct scsi_tape * STp, int do_lock)
847{
848 int retval, cmd;
849 DEB(char *name = tape_name(STp);)
850
851
852 cmd = do_lock ? SCSI_IOCTL_DOORLOCK : SCSI_IOCTL_DOORUNLOCK;
853 DEBC(printk(ST_DEB_MSG "%s: %socking drive door.\n", name,
854 do_lock ? "L" : "Unl"));
855 retval = scsi_ioctl(STp->device, cmd, NULL);
856 if (!retval) {
857 STp->door_locked = do_lock ? ST_LOCKED_EXPLICIT : ST_UNLOCKED;
858 }
859 else {
860 STp->door_locked = ST_LOCK_FAILS;
861 }
862 return retval;
863}
864
865
866/* Set the internal state after reset */
867static void reset_state(struct scsi_tape *STp)
868{
869 int i;
870 struct st_partstat *STps;
871
872 STp->pos_unknown = 0;
873 for (i = 0; i < ST_NBR_PARTITIONS; i++) {
874 STps = &(STp->ps[i]);
875 STps->rw = ST_IDLE;
876 STps->eof = ST_NOEOF;
877 STps->at_sm = 0;
878 STps->last_block_valid = 0;
879 STps->drv_block = -1;
880 STps->drv_file = -1;
881 }
882 if (STp->can_partitions) {
883 STp->partition = find_partition(STp);
884 if (STp->partition < 0)
885 STp->partition = 0;
886 STp->new_partition = STp->partition;
887 }
888}
889
890/* Test if the drive is ready. Returns either one of the codes below or a negative system
891 error code. */
892#define CHKRES_READY 0
893#define CHKRES_NEW_SESSION 1
894#define CHKRES_NOT_READY 2
895#define CHKRES_NO_TAPE 3
896
897#define MAX_ATTENTIONS 10
898
899static int test_ready(struct scsi_tape *STp, int do_wait)
900{
901 int attentions, waits, max_wait, scode;
902 int retval = CHKRES_READY, new_session = 0;
903 unsigned char cmd[MAX_COMMAND_SIZE];
Kai Makisara02ae2c02008-12-18 14:49:50 +0900904 struct st_request *SRpnt = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700905 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
906
907 max_wait = do_wait ? ST_BLOCK_SECONDS : 0;
908
909 for (attentions=waits=0; ; ) {
910 memset((void *) &cmd[0], 0, MAX_COMMAND_SIZE);
911 cmd[0] = TEST_UNIT_READY;
Kai Makisara02ae2c02008-12-18 14:49:50 +0900912 SRpnt = st_do_scsi(SRpnt, STp, cmd, 0, DMA_NONE,
913 STp->long_timeout, MAX_READY_RETRIES, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700914
Kai Makisara02ae2c02008-12-18 14:49:50 +0900915 if (!SRpnt) {
916 retval = (STp->buffer)->syscall_result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700917 break;
Kai Makisara02ae2c02008-12-18 14:49:50 +0900918 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700919
920 if (cmdstatp->have_sense) {
921
922 scode = cmdstatp->sense_hdr.sense_key;
923
924 if (scode == UNIT_ATTENTION) { /* New media? */
925 new_session = 1;
926 if (attentions < MAX_ATTENTIONS) {
927 attentions++;
928 continue;
929 }
930 else {
931 retval = (-EIO);
932 break;
933 }
934 }
935
936 if (scode == NOT_READY) {
937 if (waits < max_wait) {
938 if (msleep_interruptible(1000)) {
939 retval = (-EINTR);
940 break;
941 }
942 waits++;
943 continue;
944 }
945 else {
946 if ((STp->device)->scsi_level >= SCSI_2 &&
947 cmdstatp->sense_hdr.asc == 0x3a) /* Check ASC */
948 retval = CHKRES_NO_TAPE;
949 else
950 retval = CHKRES_NOT_READY;
951 break;
952 }
953 }
954 }
955
956 retval = (STp->buffer)->syscall_result;
957 if (!retval)
958 retval = new_session ? CHKRES_NEW_SESSION : CHKRES_READY;
959 break;
960 }
961
Kai Makisara02ae2c02008-12-18 14:49:50 +0900962 if (SRpnt != NULL)
963 st_release_request(SRpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700964 return retval;
965}
966
967
968/* See if the drive is ready and gather information about the tape. Return values:
969 < 0 negative error code from errno.h
970 0 drive ready
971 1 drive not ready (possibly no tape)
972*/
973static int check_tape(struct scsi_tape *STp, struct file *filp)
974{
975 int i, retval, new_session = 0, do_wait;
976 unsigned char cmd[MAX_COMMAND_SIZE], saved_cleaning;
977 unsigned short st_flags = filp->f_flags;
Mike Christie8b05b772005-11-08 04:06:44 -0600978 struct st_request *SRpnt = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700979 struct st_modedef *STm;
980 struct st_partstat *STps;
981 char *name = tape_name(STp);
Josef Sipek7ac62072006-12-08 02:37:37 -0800982 struct inode *inode = filp->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700983 int mode = TAPE_MODE(inode);
984
985 STp->ready = ST_READY;
986
987 if (mode != STp->current_mode) {
988 DEBC(printk(ST_DEB_MSG "%s: Mode change from %d to %d.\n",
989 name, STp->current_mode, mode));
990 new_session = 1;
991 STp->current_mode = mode;
992 }
993 STm = &(STp->modes[STp->current_mode]);
994
995 saved_cleaning = STp->cleaning_req;
996 STp->cleaning_req = 0;
997
998 do_wait = ((filp->f_flags & O_NONBLOCK) == 0);
999 retval = test_ready(STp, do_wait);
1000
1001 if (retval < 0)
1002 goto err_out;
1003
1004 if (retval == CHKRES_NEW_SESSION) {
1005 STp->pos_unknown = 0;
1006 STp->partition = STp->new_partition = 0;
1007 if (STp->can_partitions)
1008 STp->nbr_partitions = 1; /* This guess will be updated later
1009 if necessary */
1010 for (i = 0; i < ST_NBR_PARTITIONS; i++) {
1011 STps = &(STp->ps[i]);
1012 STps->rw = ST_IDLE;
1013 STps->eof = ST_NOEOF;
1014 STps->at_sm = 0;
1015 STps->last_block_valid = 0;
1016 STps->drv_block = 0;
1017 STps->drv_file = 0;
1018 }
1019 new_session = 1;
1020 }
1021 else {
1022 STp->cleaning_req |= saved_cleaning;
1023
1024 if (retval == CHKRES_NOT_READY || retval == CHKRES_NO_TAPE) {
1025 if (retval == CHKRES_NO_TAPE)
1026 STp->ready = ST_NO_TAPE;
1027 else
1028 STp->ready = ST_NOT_READY;
1029
1030 STp->density = 0; /* Clear the erroneous "residue" */
1031 STp->write_prot = 0;
1032 STp->block_size = 0;
1033 STp->ps[0].drv_file = STp->ps[0].drv_block = (-1);
1034 STp->partition = STp->new_partition = 0;
1035 STp->door_locked = ST_UNLOCKED;
1036 return CHKRES_NOT_READY;
1037 }
1038 }
1039
1040 if (STp->omit_blklims)
1041 STp->min_block = STp->max_block = (-1);
1042 else {
1043 memset((void *) &cmd[0], 0, MAX_COMMAND_SIZE);
1044 cmd[0] = READ_BLOCK_LIMITS;
1045
Kai Makisara02ae2c02008-12-18 14:49:50 +09001046 SRpnt = st_do_scsi(SRpnt, STp, cmd, 6, DMA_FROM_DEVICE,
1047 STp->device->request_queue->rq_timeout,
1048 MAX_READY_RETRIES, 1);
1049 if (!SRpnt) {
1050 retval = (STp->buffer)->syscall_result;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001051 goto err_out;
1052 }
1053
Mike Christie8b05b772005-11-08 04:06:44 -06001054 if (!SRpnt->result && !STp->buffer->cmdstat.have_sense) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001055 STp->max_block = ((STp->buffer)->b_data[1] << 16) |
1056 ((STp->buffer)->b_data[2] << 8) | (STp->buffer)->b_data[3];
1057 STp->min_block = ((STp->buffer)->b_data[4] << 8) |
1058 (STp->buffer)->b_data[5];
1059 if ( DEB( debugging || ) !STp->inited)
Kai Makisara42252852006-11-07 21:56:38 +02001060 printk(KERN_INFO
Linus Torvalds1da177e2005-04-16 15:20:36 -07001061 "%s: Block limits %d - %d bytes.\n", name,
1062 STp->min_block, STp->max_block);
1063 } else {
1064 STp->min_block = STp->max_block = (-1);
1065 DEBC(printk(ST_DEB_MSG "%s: Can't read block limits.\n",
1066 name));
1067 }
1068 }
1069
1070 memset((void *) &cmd[0], 0, MAX_COMMAND_SIZE);
1071 cmd[0] = MODE_SENSE;
1072 cmd[4] = 12;
1073
Kai Makisara02ae2c02008-12-18 14:49:50 +09001074 SRpnt = st_do_scsi(SRpnt, STp, cmd, 12, DMA_FROM_DEVICE,
1075 STp->device->request_queue->rq_timeout,
1076 MAX_READY_RETRIES, 1);
1077 if (!SRpnt) {
1078 retval = (STp->buffer)->syscall_result;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001079 goto err_out;
1080 }
1081
1082 if ((STp->buffer)->syscall_result != 0) {
1083 DEBC(printk(ST_DEB_MSG "%s: No Mode Sense.\n", name));
1084 STp->block_size = ST_DEFAULT_BLOCK; /* Educated guess (?) */
1085 (STp->buffer)->syscall_result = 0; /* Prevent error propagation */
1086 STp->drv_write_prot = 0;
1087 } else {
1088 DEBC(printk(ST_DEB_MSG
1089 "%s: Mode sense. Length %d, medium %x, WBS %x, BLL %d\n",
1090 name,
1091 (STp->buffer)->b_data[0], (STp->buffer)->b_data[1],
1092 (STp->buffer)->b_data[2], (STp->buffer)->b_data[3]));
1093
1094 if ((STp->buffer)->b_data[3] >= 8) {
1095 STp->drv_buffer = ((STp->buffer)->b_data[2] >> 4) & 7;
1096 STp->density = (STp->buffer)->b_data[4];
1097 STp->block_size = (STp->buffer)->b_data[9] * 65536 +
1098 (STp->buffer)->b_data[10] * 256 + (STp->buffer)->b_data[11];
1099 DEBC(printk(ST_DEB_MSG
1100 "%s: Density %x, tape length: %x, drv buffer: %d\n",
1101 name, STp->density, (STp->buffer)->b_data[5] * 65536 +
1102 (STp->buffer)->b_data[6] * 256 + (STp->buffer)->b_data[7],
1103 STp->drv_buffer));
1104 }
1105 STp->drv_write_prot = ((STp->buffer)->b_data[2] & 0x80) != 0;
1106 }
Mike Christie8b05b772005-11-08 04:06:44 -06001107 st_release_request(SRpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001108 SRpnt = NULL;
1109 STp->inited = 1;
1110
1111 if (STp->block_size > 0)
1112 (STp->buffer)->buffer_blocks =
1113 (STp->buffer)->buffer_size / STp->block_size;
1114 else
1115 (STp->buffer)->buffer_blocks = 1;
1116 (STp->buffer)->buffer_bytes = (STp->buffer)->read_pointer = 0;
1117
1118 DEBC(printk(ST_DEB_MSG
1119 "%s: Block size: %d, buffer size: %d (%d blocks).\n", name,
1120 STp->block_size, (STp->buffer)->buffer_size,
1121 (STp->buffer)->buffer_blocks));
1122
1123 if (STp->drv_write_prot) {
1124 STp->write_prot = 1;
1125
1126 DEBC(printk(ST_DEB_MSG "%s: Write protected\n", name));
1127
1128 if (do_wait &&
1129 ((st_flags & O_ACCMODE) == O_WRONLY ||
1130 (st_flags & O_ACCMODE) == O_RDWR)) {
1131 retval = (-EROFS);
1132 goto err_out;
1133 }
1134 }
1135
1136 if (STp->can_partitions && STp->nbr_partitions < 1) {
1137 /* This code is reached when the device is opened for the first time
1138 after the driver has been initialized with tape in the drive and the
1139 partition support has been enabled. */
1140 DEBC(printk(ST_DEB_MSG
1141 "%s: Updating partition number in status.\n", name));
1142 if ((STp->partition = find_partition(STp)) < 0) {
1143 retval = STp->partition;
1144 goto err_out;
1145 }
1146 STp->new_partition = STp->partition;
1147 STp->nbr_partitions = 1; /* This guess will be updated when necessary */
1148 }
1149
1150 if (new_session) { /* Change the drive parameters for the new mode */
1151 STp->density_changed = STp->blksize_changed = 0;
1152 STp->compression_changed = 0;
1153 if (!(STm->defaults_for_writes) &&
1154 (retval = set_mode_densblk(STp, STm)) < 0)
1155 goto err_out;
1156
1157 if (STp->default_drvbuffer != 0xff) {
1158 if (st_int_ioctl(STp, MTSETDRVBUFFER, STp->default_drvbuffer))
1159 printk(KERN_WARNING
1160 "%s: Can't set default drive buffering to %d.\n",
1161 name, STp->default_drvbuffer);
1162 }
1163 }
1164
1165 return CHKRES_READY;
1166
1167 err_out:
1168 return retval;
1169}
1170
1171
Jonathan Corbetb3369c62008-05-15 16:08:15 -06001172 /* Open the device. Needs to take the BKL only because of incrementing the SCSI host
Linus Torvalds1da177e2005-04-16 15:20:36 -07001173 module count. */
1174static int st_open(struct inode *inode, struct file *filp)
1175{
1176 int i, retval = (-EIO);
1177 struct scsi_tape *STp;
1178 struct st_partstat *STps;
1179 int dev = TAPE_NR(inode);
1180 char *name;
1181
Jonathan Corbetb3369c62008-05-15 16:08:15 -06001182 lock_kernel();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001183 /*
1184 * We really want to do nonseekable_open(inode, filp); here, but some
1185 * versions of tar incorrectly call lseek on tapes and bail out if that
1186 * fails. So we disallow pread() and pwrite(), but permit lseeks.
1187 */
1188 filp->f_mode &= ~(FMODE_PREAD | FMODE_PWRITE);
1189
Jonathan Corbetb3369c62008-05-15 16:08:15 -06001190 if (!(STp = scsi_tape_get(dev))) {
1191 unlock_kernel();
Kai Makisaraf03a5672005-08-02 13:40:47 +03001192 return -ENXIO;
Jonathan Corbetb3369c62008-05-15 16:08:15 -06001193 }
Kai Makisaraf03a5672005-08-02 13:40:47 +03001194
Linus Torvalds1da177e2005-04-16 15:20:36 -07001195 write_lock(&st_dev_arr_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001196 filp->private_data = STp;
1197 name = tape_name(STp);
1198
1199 if (STp->in_use) {
1200 write_unlock(&st_dev_arr_lock);
Kai Makisaraf03a5672005-08-02 13:40:47 +03001201 scsi_tape_put(STp);
Jonathan Corbetb3369c62008-05-15 16:08:15 -06001202 unlock_kernel();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001203 DEB( printk(ST_DEB_MSG "%s: Device already in use.\n", name); )
1204 return (-EBUSY);
1205 }
1206
Linus Torvalds1da177e2005-04-16 15:20:36 -07001207 STp->in_use = 1;
1208 write_unlock(&st_dev_arr_lock);
1209 STp->rew_at_close = STp->autorew_dev = (iminor(inode) & 0x80) == 0;
1210
1211 if (!scsi_block_when_processing_errors(STp->device)) {
1212 retval = (-ENXIO);
1213 goto err_out;
1214 }
1215
1216 /* See that we have at least a one page buffer available */
1217 if (!enlarge_buffer(STp->buffer, PAGE_SIZE, STp->restr_dma)) {
1218 printk(KERN_WARNING "%s: Can't allocate one page tape buffer.\n",
1219 name);
1220 retval = (-EOVERFLOW);
1221 goto err_out;
1222 }
1223
Kai Makisara40f6b362008-02-24 22:23:24 +02001224 (STp->buffer)->cleared = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001225 (STp->buffer)->writing = 0;
1226 (STp->buffer)->syscall_result = 0;
1227
1228 STp->write_prot = ((filp->f_flags & O_ACCMODE) == O_RDONLY);
1229
1230 STp->dirty = 0;
1231 for (i = 0; i < ST_NBR_PARTITIONS; i++) {
1232 STps = &(STp->ps[i]);
1233 STps->rw = ST_IDLE;
1234 }
Kai Makisara9abe16c2007-02-03 13:21:29 +02001235 STp->try_dio_now = STp->try_dio;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001236 STp->recover_count = 0;
1237 DEB( STp->nbr_waits = STp->nbr_finished = 0;
Kai Makisaradeee13d2008-02-22 20:11:21 +02001238 STp->nbr_requests = STp->nbr_dio = STp->nbr_pages = 0; )
Linus Torvalds1da177e2005-04-16 15:20:36 -07001239
1240 retval = check_tape(STp, filp);
1241 if (retval < 0)
1242 goto err_out;
1243 if ((filp->f_flags & O_NONBLOCK) == 0 &&
1244 retval != CHKRES_READY) {
Kai Makisara413f7322006-10-05 22:59:46 +03001245 if (STp->ready == NO_TAPE)
1246 retval = (-ENOMEDIUM);
1247 else
1248 retval = (-EIO);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001249 goto err_out;
1250 }
Jonathan Corbetb3369c62008-05-15 16:08:15 -06001251 unlock_kernel();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001252 return 0;
1253
1254 err_out:
1255 normalize_buffer(STp->buffer);
1256 STp->in_use = 0;
Kai Makisaraf03a5672005-08-02 13:40:47 +03001257 scsi_tape_put(STp);
Jonathan Corbetb3369c62008-05-15 16:08:15 -06001258 unlock_kernel();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001259 return retval;
1260
1261}
1262
1263
1264/* Flush the tape buffer before close */
Miklos Szeredi75e1fcc2006-06-23 02:05:12 -07001265static int st_flush(struct file *filp, fl_owner_t id)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001266{
1267 int result = 0, result2;
1268 unsigned char cmd[MAX_COMMAND_SIZE];
Mike Christie8b05b772005-11-08 04:06:44 -06001269 struct st_request *SRpnt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001270 struct scsi_tape *STp = filp->private_data;
1271 struct st_modedef *STm = &(STp->modes[STp->current_mode]);
1272 struct st_partstat *STps = &(STp->ps[STp->partition]);
1273 char *name = tape_name(STp);
1274
1275 if (file_count(filp) > 1)
1276 return 0;
1277
1278 if (STps->rw == ST_WRITING && !STp->pos_unknown) {
Adrian Bunk8ef8d592008-04-14 17:17:16 +03001279 result = st_flush_write_buffer(STp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001280 if (result != 0 && result != (-ENOSPC))
1281 goto out;
1282 }
1283
1284 if (STp->can_partitions &&
1285 (result2 = switch_partition(STp)) < 0) {
1286 DEBC(printk(ST_DEB_MSG
1287 "%s: switch_partition at close failed.\n", name));
1288 if (result == 0)
1289 result = result2;
1290 goto out;
1291 }
1292
1293 DEBC( if (STp->nbr_requests)
Kai Makisaradeee13d2008-02-22 20:11:21 +02001294 printk(KERN_DEBUG "%s: Number of r/w requests %d, dio used in %d, pages %d.\n",
1295 name, STp->nbr_requests, STp->nbr_dio, STp->nbr_pages));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001296
1297 if (STps->rw == ST_WRITING && !STp->pos_unknown) {
1298 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
1299
1300 DEBC(printk(ST_DEB_MSG "%s: Async write waits %d, finished %d.\n",
1301 name, STp->nbr_waits, STp->nbr_finished);
1302 )
1303
1304 memset(cmd, 0, MAX_COMMAND_SIZE);
1305 cmd[0] = WRITE_FILEMARKS;
1306 cmd[4] = 1 + STp->two_fm;
1307
Kai Makisara02ae2c02008-12-18 14:49:50 +09001308 SRpnt = st_do_scsi(NULL, STp, cmd, 0, DMA_NONE,
1309 STp->device->request_queue->rq_timeout,
1310 MAX_WRITE_RETRIES, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001311 if (!SRpnt) {
Kai Makisara02ae2c02008-12-18 14:49:50 +09001312 result = (STp->buffer)->syscall_result;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001313 goto out;
1314 }
1315
1316 if (STp->buffer->syscall_result == 0 ||
1317 (cmdstatp->have_sense && !cmdstatp->deferred &&
1318 (cmdstatp->flags & SENSE_EOM) &&
1319 (cmdstatp->sense_hdr.sense_key == NO_SENSE ||
1320 cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR) &&
1321 (!cmdstatp->remainder_valid || cmdstatp->uremainder64 == 0))) {
1322 /* Write successful at EOM */
Mike Christie8b05b772005-11-08 04:06:44 -06001323 st_release_request(SRpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001324 SRpnt = NULL;
1325 if (STps->drv_file >= 0)
1326 STps->drv_file++;
1327 STps->drv_block = 0;
1328 if (STp->two_fm)
1329 cross_eof(STp, 0);
1330 STps->eof = ST_FM;
1331 }
1332 else { /* Write error */
Mike Christie8b05b772005-11-08 04:06:44 -06001333 st_release_request(SRpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001334 SRpnt = NULL;
1335 printk(KERN_ERR "%s: Error on write filemark.\n", name);
1336 if (result == 0)
1337 result = (-EIO);
1338 }
1339
1340 DEBC(printk(ST_DEB_MSG "%s: Buffer flushed, %d EOF(s) written\n",
1341 name, cmd[4]));
1342 } else if (!STp->rew_at_close) {
1343 STps = &(STp->ps[STp->partition]);
1344 if (!STm->sysv || STps->rw != ST_READING) {
1345 if (STp->can_bsr)
1346 result = flush_buffer(STp, 0);
1347 else if (STps->eof == ST_FM_HIT) {
1348 result = cross_eof(STp, 0);
1349 if (result) {
1350 if (STps->drv_file >= 0)
1351 STps->drv_file++;
1352 STps->drv_block = 0;
1353 STps->eof = ST_FM;
1354 } else
1355 STps->eof = ST_NOEOF;
1356 }
1357 } else if ((STps->eof == ST_NOEOF &&
1358 !(result = cross_eof(STp, 1))) ||
1359 STps->eof == ST_FM_HIT) {
1360 if (STps->drv_file >= 0)
1361 STps->drv_file++;
1362 STps->drv_block = 0;
1363 STps->eof = ST_FM;
1364 }
1365 }
1366
1367 out:
1368 if (STp->rew_at_close) {
1369 result2 = st_int_ioctl(STp, MTREW, 1);
1370 if (result == 0)
1371 result = result2;
1372 }
1373 return result;
1374}
1375
1376
1377/* Close the device and release it. BKL is not needed: this is the only thread
1378 accessing this tape. */
1379static int st_release(struct inode *inode, struct file *filp)
1380{
1381 int result = 0;
1382 struct scsi_tape *STp = filp->private_data;
1383
1384 if (STp->door_locked == ST_LOCKED_AUTO)
1385 do_door_lock(STp, 0);
1386
1387 normalize_buffer(STp->buffer);
1388 write_lock(&st_dev_arr_lock);
1389 STp->in_use = 0;
1390 write_unlock(&st_dev_arr_lock);
Kai Makisaraf03a5672005-08-02 13:40:47 +03001391 scsi_tape_put(STp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001392
1393 return result;
1394}
1395
1396/* The checks common to both reading and writing */
1397static ssize_t rw_checks(struct scsi_tape *STp, struct file *filp, size_t count)
1398{
1399 ssize_t retval = 0;
1400
1401 /*
1402 * If we are in the middle of error recovery, don't let anyone
1403 * else try and use this device. Also, if error recovery fails, it
1404 * may try and take the device offline, in which case all further
1405 * access to the device is prohibited.
1406 */
1407 if (!scsi_block_when_processing_errors(STp->device)) {
1408 retval = (-ENXIO);
1409 goto out;
1410 }
1411
1412 if (STp->ready != ST_READY) {
1413 if (STp->ready == ST_NO_TAPE)
1414 retval = (-ENOMEDIUM);
1415 else
1416 retval = (-EIO);
1417 goto out;
1418 }
1419
1420 if (! STp->modes[STp->current_mode].defined) {
1421 retval = (-ENXIO);
1422 goto out;
1423 }
1424
1425
1426 /*
1427 * If there was a bus reset, block further access
1428 * to this device.
1429 */
1430 if (STp->pos_unknown) {
1431 retval = (-EIO);
1432 goto out;
1433 }
1434
1435 if (count == 0)
1436 goto out;
1437
1438 DEB(
1439 if (!STp->in_use) {
1440 printk(ST_DEB_MSG "%s: Incorrect device.\n", tape_name(STp));
1441 retval = (-EIO);
1442 goto out;
1443 } ) /* end DEB */
1444
1445 if (STp->can_partitions &&
1446 (retval = switch_partition(STp)) < 0)
1447 goto out;
1448
1449 if (STp->block_size == 0 && STp->max_block > 0 &&
1450 (count < STp->min_block || count > STp->max_block)) {
1451 retval = (-EINVAL);
1452 goto out;
1453 }
1454
1455 if (STp->do_auto_lock && STp->door_locked == ST_UNLOCKED &&
1456 !do_door_lock(STp, 1))
1457 STp->door_locked = ST_LOCKED_AUTO;
1458
1459 out:
1460 return retval;
1461}
1462
1463
1464static int setup_buffering(struct scsi_tape *STp, const char __user *buf,
1465 size_t count, int is_read)
1466{
1467 int i, bufsize, retval = 0;
1468 struct st_buffer *STbp = STp->buffer;
1469
1470 if (is_read)
Kai Makisara9abe16c2007-02-03 13:21:29 +02001471 i = STp->try_dio_now && try_rdio;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001472 else
Kai Makisara9abe16c2007-02-03 13:21:29 +02001473 i = STp->try_dio_now && try_wdio;
Mike Christie8b05b772005-11-08 04:06:44 -06001474
Linus Torvalds1da177e2005-04-16 15:20:36 -07001475 if (i && ((unsigned long)buf & queue_dma_alignment(
1476 STp->device->request_queue)) == 0) {
FUJITA Tomonori66207422008-12-18 14:49:43 +09001477 i = sgl_map_user_pages(STbp, STbp->use_sg, (unsigned long)buf,
1478 count, (is_read ? READ : WRITE));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001479 if (i > 0) {
1480 STbp->do_dio = i;
1481 STbp->buffer_bytes = 0; /* can be used as transfer counter */
1482 }
1483 else
1484 STbp->do_dio = 0; /* fall back to buffering with any error */
1485 STbp->sg_segs = STbp->do_dio;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001486 DEB(
1487 if (STbp->do_dio) {
1488 STp->nbr_dio++;
1489 STp->nbr_pages += STbp->do_dio;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001490 }
1491 )
1492 } else
1493 STbp->do_dio = 0;
1494 DEB( STp->nbr_requests++; )
1495
1496 if (!STbp->do_dio) {
1497 if (STp->block_size)
1498 bufsize = STp->block_size > st_fixed_buffer_size ?
1499 STp->block_size : st_fixed_buffer_size;
Kai Makisara40f6b362008-02-24 22:23:24 +02001500 else {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001501 bufsize = count;
Kai Makisara40f6b362008-02-24 22:23:24 +02001502 /* Make sure that data from previous user is not leaked even if
1503 HBA does not return correct residual */
1504 if (is_read && STp->sili && !STbp->cleared)
1505 clear_buffer(STbp);
1506 }
1507
Linus Torvalds1da177e2005-04-16 15:20:36 -07001508 if (bufsize > STbp->buffer_size &&
1509 !enlarge_buffer(STbp, bufsize, STp->restr_dma)) {
1510 printk(KERN_WARNING "%s: Can't allocate %d byte tape buffer.\n",
1511 tape_name(STp), bufsize);
1512 retval = (-EOVERFLOW);
1513 goto out;
1514 }
1515 if (STp->block_size)
1516 STbp->buffer_blocks = bufsize / STp->block_size;
1517 }
1518
1519 out:
1520 return retval;
1521}
1522
1523
1524/* Can be called more than once after each setup_buffer() */
Kai Makisara787926b2005-11-13 10:04:44 +02001525static void release_buffering(struct scsi_tape *STp, int is_read)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001526{
1527 struct st_buffer *STbp;
1528
1529 STbp = STp->buffer;
1530 if (STbp->do_dio) {
FUJITA Tomonori66207422008-12-18 14:49:43 +09001531 sgl_unmap_user_pages(STbp, STbp->do_dio, is_read);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001532 STbp->do_dio = 0;
Kai Makisara787926b2005-11-13 10:04:44 +02001533 STbp->sg_segs = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001534 }
1535}
1536
1537
1538/* Write command */
1539static ssize_t
1540st_write(struct file *filp, const char __user *buf, size_t count, loff_t * ppos)
1541{
1542 ssize_t total;
1543 ssize_t i, do_count, blks, transfer;
1544 ssize_t retval;
1545 int undone, retry_eot = 0, scode;
1546 int async_write;
1547 unsigned char cmd[MAX_COMMAND_SIZE];
1548 const char __user *b_point;
Mike Christie8b05b772005-11-08 04:06:44 -06001549 struct st_request *SRpnt = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001550 struct scsi_tape *STp = filp->private_data;
1551 struct st_modedef *STm;
1552 struct st_partstat *STps;
1553 struct st_buffer *STbp;
1554 char *name = tape_name(STp);
1555
Matthias Kaehlcke28f85002007-07-29 23:38:15 +02001556 if (mutex_lock_interruptible(&STp->lock))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001557 return -ERESTARTSYS;
1558
1559 retval = rw_checks(STp, filp, count);
1560 if (retval || count == 0)
1561 goto out;
1562
1563 /* Write must be integral number of blocks */
1564 if (STp->block_size != 0 && (count % STp->block_size) != 0) {
1565 printk(KERN_WARNING "%s: Write not multiple of tape block size.\n",
1566 name);
1567 retval = (-EINVAL);
1568 goto out;
1569 }
1570
1571 STm = &(STp->modes[STp->current_mode]);
1572 STps = &(STp->ps[STp->partition]);
1573
1574 if (STp->write_prot) {
1575 retval = (-EACCES);
1576 goto out;
1577 }
1578
1579
1580 if (STps->rw == ST_READING) {
1581 retval = flush_buffer(STp, 0);
1582 if (retval)
1583 goto out;
1584 STps->rw = ST_WRITING;
1585 } else if (STps->rw != ST_WRITING &&
1586 STps->drv_file == 0 && STps->drv_block == 0) {
1587 if ((retval = set_mode_densblk(STp, STm)) < 0)
1588 goto out;
1589 if (STm->default_compression != ST_DONT_TOUCH &&
1590 !(STp->compression_changed)) {
1591 if (st_compression(STp, (STm->default_compression == ST_YES))) {
1592 printk(KERN_WARNING "%s: Can't set default compression.\n",
1593 name);
1594 if (modes_defined) {
1595 retval = (-EINVAL);
1596 goto out;
1597 }
1598 }
1599 }
1600 }
1601
1602 STbp = STp->buffer;
1603 i = write_behind_check(STp);
1604 if (i) {
1605 if (i == -ENOSPC)
1606 STps->eof = ST_EOM_OK;
1607 else
1608 STps->eof = ST_EOM_ERROR;
1609 }
1610
1611 if (STps->eof == ST_EOM_OK) {
1612 STps->eof = ST_EOD_1; /* allow next write */
1613 retval = (-ENOSPC);
1614 goto out;
1615 }
1616 else if (STps->eof == ST_EOM_ERROR) {
1617 retval = (-EIO);
1618 goto out;
1619 }
1620
1621 /* Check the buffer readability in cases where copy_user might catch
1622 the problems after some tape movement. */
1623 if (STp->block_size != 0 &&
1624 !STbp->do_dio &&
1625 (copy_from_user(&i, buf, 1) != 0 ||
1626 copy_from_user(&i, buf + count - 1, 1) != 0)) {
1627 retval = (-EFAULT);
1628 goto out;
1629 }
1630
1631 retval = setup_buffering(STp, buf, count, 0);
1632 if (retval)
1633 goto out;
1634
1635 total = count;
1636
1637 memset(cmd, 0, MAX_COMMAND_SIZE);
1638 cmd[0] = WRITE_6;
1639 cmd[1] = (STp->block_size != 0);
1640
1641 STps->rw = ST_WRITING;
1642
1643 b_point = buf;
1644 while (count > 0 && !retry_eot) {
1645
1646 if (STbp->do_dio) {
1647 do_count = count;
1648 }
1649 else {
1650 if (STp->block_size == 0)
1651 do_count = count;
1652 else {
1653 do_count = STbp->buffer_blocks * STp->block_size -
1654 STbp->buffer_bytes;
1655 if (do_count > count)
1656 do_count = count;
1657 }
1658
1659 i = append_to_buffer(b_point, STbp, do_count);
1660 if (i) {
1661 retval = i;
1662 goto out;
1663 }
1664 }
1665 count -= do_count;
1666 b_point += do_count;
1667
1668 async_write = STp->block_size == 0 && !STbp->do_dio &&
1669 STm->do_async_writes && STps->eof < ST_EOM_OK;
1670
1671 if (STp->block_size != 0 && STm->do_buffer_writes &&
Kai Makisara9abe16c2007-02-03 13:21:29 +02001672 !(STp->try_dio_now && try_wdio) && STps->eof < ST_EOM_OK &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001673 STbp->buffer_bytes < STbp->buffer_size) {
1674 STp->dirty = 1;
1675 /* Don't write a buffer that is not full enough. */
1676 if (!async_write && count == 0)
1677 break;
1678 }
1679
1680 retry_write:
1681 if (STp->block_size == 0)
1682 blks = transfer = do_count;
1683 else {
1684 if (!STbp->do_dio)
1685 blks = STbp->buffer_bytes;
1686 else
1687 blks = do_count;
1688 blks /= STp->block_size;
1689 transfer = blks * STp->block_size;
1690 }
1691 cmd[2] = blks >> 16;
1692 cmd[3] = blks >> 8;
1693 cmd[4] = blks;
1694
1695 SRpnt = st_do_scsi(SRpnt, STp, cmd, transfer, DMA_TO_DEVICE,
James Bottomleya02488e2008-11-30 10:36:26 -06001696 STp->device->request_queue->rq_timeout,
1697 MAX_WRITE_RETRIES, !async_write);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001698 if (!SRpnt) {
1699 retval = STbp->syscall_result;
1700 goto out;
1701 }
Mike Christie8b05b772005-11-08 04:06:44 -06001702 if (async_write && !STbp->syscall_result) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001703 STbp->writing = transfer;
1704 STp->dirty = !(STbp->writing ==
1705 STbp->buffer_bytes);
1706 SRpnt = NULL; /* Prevent releasing this request! */
1707 DEB( STp->write_pending = 1; )
1708 break;
1709 }
1710
1711 if (STbp->syscall_result != 0) {
1712 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
1713
1714 DEBC(printk(ST_DEB_MSG "%s: Error on write:\n", name));
1715 if (cmdstatp->have_sense && (cmdstatp->flags & SENSE_EOM)) {
1716 scode = cmdstatp->sense_hdr.sense_key;
1717 if (cmdstatp->remainder_valid)
1718 undone = (int)cmdstatp->uremainder64;
1719 else if (STp->block_size == 0 &&
1720 scode == VOLUME_OVERFLOW)
1721 undone = transfer;
1722 else
1723 undone = 0;
1724 if (STp->block_size != 0)
1725 undone *= STp->block_size;
1726 if (undone <= do_count) {
1727 /* Only data from this write is not written */
1728 count += undone;
Kai Makisara626dcb12008-07-11 15:05:25 +03001729 b_point -= undone;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001730 do_count -= undone;
1731 if (STp->block_size)
1732 blks = (transfer - undone) / STp->block_size;
1733 STps->eof = ST_EOM_OK;
1734 /* Continue in fixed block mode if all written
1735 in this request but still something left to write
1736 (retval left to zero)
1737 */
1738 if (STp->block_size == 0 ||
1739 undone > 0 || count == 0)
1740 retval = (-ENOSPC); /* EOM within current request */
1741 DEBC(printk(ST_DEB_MSG
1742 "%s: EOM with %d bytes unwritten.\n",
1743 name, (int)count));
1744 } else {
1745 /* EOT within data buffered earlier (possible only
1746 in fixed block mode without direct i/o) */
1747 if (!retry_eot && !cmdstatp->deferred &&
1748 (scode == NO_SENSE || scode == RECOVERED_ERROR)) {
1749 move_buffer_data(STp->buffer, transfer - undone);
1750 retry_eot = 1;
1751 if (STps->drv_block >= 0) {
1752 STps->drv_block += (transfer - undone) /
1753 STp->block_size;
1754 }
1755 STps->eof = ST_EOM_OK;
1756 DEBC(printk(ST_DEB_MSG
1757 "%s: Retry write of %d bytes at EOM.\n",
1758 name, STp->buffer->buffer_bytes));
1759 goto retry_write;
1760 }
1761 else {
1762 /* Either error within data buffered by driver or
1763 failed retry */
1764 count -= do_count;
1765 blks = do_count = 0;
1766 STps->eof = ST_EOM_ERROR;
1767 STps->drv_block = (-1); /* Too cautious? */
1768 retval = (-EIO); /* EOM for old data */
1769 DEBC(printk(ST_DEB_MSG
1770 "%s: EOM with lost data.\n",
1771 name));
1772 }
1773 }
1774 } else {
1775 count += do_count;
1776 STps->drv_block = (-1); /* Too cautious? */
Mike Christie8b05b772005-11-08 04:06:44 -06001777 retval = STbp->syscall_result;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001778 }
1779
1780 }
1781
1782 if (STps->drv_block >= 0) {
1783 if (STp->block_size == 0)
1784 STps->drv_block += (do_count > 0);
1785 else
1786 STps->drv_block += blks;
1787 }
1788
1789 STbp->buffer_bytes = 0;
1790 STp->dirty = 0;
1791
1792 if (retval || retry_eot) {
1793 if (count < total)
1794 retval = total - count;
1795 goto out;
1796 }
1797 }
1798
1799 if (STps->eof == ST_EOD_1)
1800 STps->eof = ST_EOM_OK;
1801 else if (STps->eof != ST_EOM_OK)
1802 STps->eof = ST_NOEOF;
1803 retval = total - count;
1804
1805 out:
1806 if (SRpnt != NULL)
Mike Christie8b05b772005-11-08 04:06:44 -06001807 st_release_request(SRpnt);
Kai Makisara787926b2005-11-13 10:04:44 +02001808 release_buffering(STp, 0);
Matthias Kaehlcke28f85002007-07-29 23:38:15 +02001809 mutex_unlock(&STp->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001810
1811 return retval;
1812}
1813
1814/* Read data from the tape. Returns zero in the normal case, one if the
1815 eof status has changed, and the negative error code in case of a
1816 fatal error. Otherwise updates the buffer and the eof state.
1817
1818 Does release user buffer mapping if it is set.
1819*/
1820static long read_tape(struct scsi_tape *STp, long count,
Mike Christie8b05b772005-11-08 04:06:44 -06001821 struct st_request ** aSRpnt)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001822{
1823 int transfer, blks, bytes;
1824 unsigned char cmd[MAX_COMMAND_SIZE];
Mike Christie8b05b772005-11-08 04:06:44 -06001825 struct st_request *SRpnt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001826 struct st_modedef *STm;
1827 struct st_partstat *STps;
1828 struct st_buffer *STbp;
1829 int retval = 0;
1830 char *name = tape_name(STp);
1831
1832 if (count == 0)
1833 return 0;
1834
1835 STm = &(STp->modes[STp->current_mode]);
1836 STps = &(STp->ps[STp->partition]);
1837 if (STps->eof == ST_FM_HIT)
1838 return 1;
1839 STbp = STp->buffer;
1840
1841 if (STp->block_size == 0)
1842 blks = bytes = count;
1843 else {
Kai Makisara9abe16c2007-02-03 13:21:29 +02001844 if (!(STp->try_dio_now && try_rdio) && STm->do_read_ahead) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001845 blks = (STp->buffer)->buffer_blocks;
1846 bytes = blks * STp->block_size;
1847 } else {
1848 bytes = count;
1849 if (!STbp->do_dio && bytes > (STp->buffer)->buffer_size)
1850 bytes = (STp->buffer)->buffer_size;
1851 blks = bytes / STp->block_size;
1852 bytes = blks * STp->block_size;
1853 }
1854 }
1855
1856 memset(cmd, 0, MAX_COMMAND_SIZE);
1857 cmd[0] = READ_6;
1858 cmd[1] = (STp->block_size != 0);
Kai Makisara40f6b362008-02-24 22:23:24 +02001859 if (!cmd[1] && STp->sili)
1860 cmd[1] |= 2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001861 cmd[2] = blks >> 16;
1862 cmd[3] = blks >> 8;
1863 cmd[4] = blks;
1864
1865 SRpnt = *aSRpnt;
1866 SRpnt = st_do_scsi(SRpnt, STp, cmd, bytes, DMA_FROM_DEVICE,
James Bottomleya02488e2008-11-30 10:36:26 -06001867 STp->device->request_queue->rq_timeout,
1868 MAX_RETRIES, 1);
Kai Makisara787926b2005-11-13 10:04:44 +02001869 release_buffering(STp, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001870 *aSRpnt = SRpnt;
1871 if (!SRpnt)
1872 return STbp->syscall_result;
1873
1874 STbp->read_pointer = 0;
1875 STps->at_sm = 0;
1876
1877 /* Something to check */
1878 if (STbp->syscall_result) {
1879 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
1880
1881 retval = 1;
1882 DEBC(printk(ST_DEB_MSG "%s: Sense: %2x %2x %2x %2x %2x %2x %2x %2x\n",
1883 name,
Mike Christie8b05b772005-11-08 04:06:44 -06001884 SRpnt->sense[0], SRpnt->sense[1],
1885 SRpnt->sense[2], SRpnt->sense[3],
1886 SRpnt->sense[4], SRpnt->sense[5],
1887 SRpnt->sense[6], SRpnt->sense[7]));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001888 if (cmdstatp->have_sense) {
1889
1890 if (cmdstatp->sense_hdr.sense_key == BLANK_CHECK)
1891 cmdstatp->flags &= 0xcf; /* No need for EOM in this case */
1892
1893 if (cmdstatp->flags != 0) { /* EOF, EOM, or ILI */
1894 /* Compute the residual count */
1895 if (cmdstatp->remainder_valid)
1896 transfer = (int)cmdstatp->uremainder64;
1897 else
1898 transfer = 0;
1899 if (STp->block_size == 0 &&
1900 cmdstatp->sense_hdr.sense_key == MEDIUM_ERROR)
1901 transfer = bytes;
1902
1903 if (cmdstatp->flags & SENSE_ILI) { /* ILI */
1904 if (STp->block_size == 0) {
1905 if (transfer <= 0) {
1906 if (transfer < 0)
1907 printk(KERN_NOTICE
1908 "%s: Failed to read %d byte block with %d byte transfer.\n",
1909 name, bytes - transfer, bytes);
1910 if (STps->drv_block >= 0)
1911 STps->drv_block += 1;
1912 STbp->buffer_bytes = 0;
1913 return (-ENOMEM);
1914 }
1915 STbp->buffer_bytes = bytes - transfer;
1916 } else {
Mike Christie8b05b772005-11-08 04:06:44 -06001917 st_release_request(SRpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001918 SRpnt = *aSRpnt = NULL;
1919 if (transfer == blks) { /* We did not get anything, error */
1920 printk(KERN_NOTICE "%s: Incorrect block size.\n", name);
1921 if (STps->drv_block >= 0)
1922 STps->drv_block += blks - transfer + 1;
1923 st_int_ioctl(STp, MTBSR, 1);
1924 return (-EIO);
1925 }
1926 /* We have some data, deliver it */
1927 STbp->buffer_bytes = (blks - transfer) *
1928 STp->block_size;
1929 DEBC(printk(ST_DEB_MSG
1930 "%s: ILI but enough data received %ld %d.\n",
1931 name, count, STbp->buffer_bytes));
1932 if (STps->drv_block >= 0)
1933 STps->drv_block += 1;
1934 if (st_int_ioctl(STp, MTBSR, 1))
1935 return (-EIO);
1936 }
1937 } else if (cmdstatp->flags & SENSE_FMK) { /* FM overrides EOM */
1938 if (STps->eof != ST_FM_HIT)
1939 STps->eof = ST_FM_HIT;
1940 else
1941 STps->eof = ST_EOD_2;
1942 if (STp->block_size == 0)
1943 STbp->buffer_bytes = 0;
1944 else
1945 STbp->buffer_bytes =
1946 bytes - transfer * STp->block_size;
1947 DEBC(printk(ST_DEB_MSG
1948 "%s: EOF detected (%d bytes read).\n",
1949 name, STbp->buffer_bytes));
1950 } else if (cmdstatp->flags & SENSE_EOM) {
1951 if (STps->eof == ST_FM)
1952 STps->eof = ST_EOD_1;
1953 else
1954 STps->eof = ST_EOM_OK;
1955 if (STp->block_size == 0)
1956 STbp->buffer_bytes = bytes - transfer;
1957 else
1958 STbp->buffer_bytes =
1959 bytes - transfer * STp->block_size;
1960
1961 DEBC(printk(ST_DEB_MSG "%s: EOM detected (%d bytes read).\n",
1962 name, STbp->buffer_bytes));
1963 }
1964 }
1965 /* end of EOF, EOM, ILI test */
1966 else { /* nonzero sense key */
1967 DEBC(printk(ST_DEB_MSG
1968 "%s: Tape error while reading.\n", name));
1969 STps->drv_block = (-1);
1970 if (STps->eof == ST_FM &&
1971 cmdstatp->sense_hdr.sense_key == BLANK_CHECK) {
1972 DEBC(printk(ST_DEB_MSG
1973 "%s: Zero returned for first BLANK CHECK after EOF.\n",
1974 name));
1975 STps->eof = ST_EOD_2; /* First BLANK_CHECK after FM */
1976 } else /* Some other extended sense code */
1977 retval = (-EIO);
1978 }
1979
1980 if (STbp->buffer_bytes < 0) /* Caused by bogus sense data */
1981 STbp->buffer_bytes = 0;
1982 }
1983 /* End of extended sense test */
1984 else { /* Non-extended sense */
1985 retval = STbp->syscall_result;
1986 }
1987
1988 }
1989 /* End of error handling */
Kai Makisara40f6b362008-02-24 22:23:24 +02001990 else { /* Read successful */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001991 STbp->buffer_bytes = bytes;
Kai Makisara40f6b362008-02-24 22:23:24 +02001992 if (STp->sili) /* In fixed block mode residual is always zero here */
1993 STbp->buffer_bytes -= STp->buffer->cmdstat.residual;
1994 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001995
1996 if (STps->drv_block >= 0) {
1997 if (STp->block_size == 0)
1998 STps->drv_block++;
1999 else
2000 STps->drv_block += STbp->buffer_bytes / STp->block_size;
2001 }
2002 return retval;
2003}
2004
2005
2006/* Read command */
2007static ssize_t
2008st_read(struct file *filp, char __user *buf, size_t count, loff_t * ppos)
2009{
2010 ssize_t total;
2011 ssize_t retval = 0;
2012 ssize_t i, transfer;
2013 int special, do_dio = 0;
Mike Christie8b05b772005-11-08 04:06:44 -06002014 struct st_request *SRpnt = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002015 struct scsi_tape *STp = filp->private_data;
2016 struct st_modedef *STm;
2017 struct st_partstat *STps;
2018 struct st_buffer *STbp = STp->buffer;
2019 DEB( char *name = tape_name(STp); )
2020
Matthias Kaehlcke28f85002007-07-29 23:38:15 +02002021 if (mutex_lock_interruptible(&STp->lock))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002022 return -ERESTARTSYS;
2023
2024 retval = rw_checks(STp, filp, count);
2025 if (retval || count == 0)
2026 goto out;
2027
2028 STm = &(STp->modes[STp->current_mode]);
Kai Makisara9abe16c2007-02-03 13:21:29 +02002029 if (STp->block_size != 0 && (count % STp->block_size) != 0) {
2030 if (!STm->do_read_ahead) {
2031 retval = (-EINVAL); /* Read must be integral number of blocks */
2032 goto out;
2033 }
2034 STp->try_dio_now = 0; /* Direct i/o can't handle split blocks */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002035 }
2036
2037 STps = &(STp->ps[STp->partition]);
2038 if (STps->rw == ST_WRITING) {
2039 retval = flush_buffer(STp, 0);
2040 if (retval)
2041 goto out;
2042 STps->rw = ST_READING;
2043 }
2044 DEB(
2045 if (debugging && STps->eof != ST_NOEOF)
2046 printk(ST_DEB_MSG "%s: EOF/EOM flag up (%d). Bytes %d\n", name,
2047 STps->eof, STbp->buffer_bytes);
2048 ) /* end DEB */
2049
2050 retval = setup_buffering(STp, buf, count, 1);
2051 if (retval)
2052 goto out;
2053 do_dio = STbp->do_dio;
2054
2055 if (STbp->buffer_bytes == 0 &&
2056 STps->eof >= ST_EOD_1) {
2057 if (STps->eof < ST_EOD) {
2058 STps->eof += 1;
2059 retval = 0;
2060 goto out;
2061 }
2062 retval = (-EIO); /* EOM or Blank Check */
2063 goto out;
2064 }
2065
2066 if (do_dio) {
2067 /* Check the buffer writability before any tape movement. Don't alter
2068 buffer data. */
2069 if (copy_from_user(&i, buf, 1) != 0 ||
2070 copy_to_user(buf, &i, 1) != 0 ||
2071 copy_from_user(&i, buf + count - 1, 1) != 0 ||
2072 copy_to_user(buf + count - 1, &i, 1) != 0) {
2073 retval = (-EFAULT);
2074 goto out;
2075 }
2076 }
2077
2078 STps->rw = ST_READING;
2079
2080
2081 /* Loop until enough data in buffer or a special condition found */
2082 for (total = 0, special = 0; total < count && !special;) {
2083
2084 /* Get new data if the buffer is empty */
2085 if (STbp->buffer_bytes == 0) {
2086 special = read_tape(STp, count - total, &SRpnt);
2087 if (special < 0) { /* No need to continue read */
2088 retval = special;
2089 goto out;
2090 }
2091 }
2092
2093 /* Move the data from driver buffer to user buffer */
2094 if (STbp->buffer_bytes > 0) {
2095 DEB(
2096 if (debugging && STps->eof != ST_NOEOF)
2097 printk(ST_DEB_MSG
2098 "%s: EOF up (%d). Left %d, needed %d.\n", name,
2099 STps->eof, STbp->buffer_bytes,
2100 (int)(count - total));
2101 ) /* end DEB */
2102 transfer = STbp->buffer_bytes < count - total ?
2103 STbp->buffer_bytes : count - total;
2104 if (!do_dio) {
2105 i = from_buffer(STbp, buf, transfer);
2106 if (i) {
2107 retval = i;
2108 goto out;
2109 }
2110 }
2111 buf += transfer;
2112 total += transfer;
2113 }
2114
2115 if (STp->block_size == 0)
2116 break; /* Read only one variable length block */
2117
2118 } /* for (total = 0, special = 0;
2119 total < count && !special; ) */
2120
2121 /* Change the eof state if no data from tape or buffer */
2122 if (total == 0) {
2123 if (STps->eof == ST_FM_HIT) {
2124 STps->eof = ST_FM;
2125 STps->drv_block = 0;
2126 if (STps->drv_file >= 0)
2127 STps->drv_file++;
2128 } else if (STps->eof == ST_EOD_1) {
2129 STps->eof = ST_EOD_2;
2130 STps->drv_block = 0;
2131 if (STps->drv_file >= 0)
2132 STps->drv_file++;
2133 } else if (STps->eof == ST_EOD_2)
2134 STps->eof = ST_EOD;
2135 } else if (STps->eof == ST_FM)
2136 STps->eof = ST_NOEOF;
2137 retval = total;
2138
2139 out:
2140 if (SRpnt != NULL) {
Mike Christie8b05b772005-11-08 04:06:44 -06002141 st_release_request(SRpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002142 SRpnt = NULL;
2143 }
2144 if (do_dio) {
Kai Makisara787926b2005-11-13 10:04:44 +02002145 release_buffering(STp, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002146 STbp->buffer_bytes = 0;
2147 }
Matthias Kaehlcke28f85002007-07-29 23:38:15 +02002148 mutex_unlock(&STp->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002149
2150 return retval;
2151}
2152
2153
2154
2155DEB(
2156/* Set the driver options */
2157static void st_log_options(struct scsi_tape * STp, struct st_modedef * STm, char *name)
2158{
2159 if (debugging) {
2160 printk(KERN_INFO
2161 "%s: Mode %d options: buffer writes: %d, async writes: %d, read ahead: %d\n",
2162 name, STp->current_mode, STm->do_buffer_writes, STm->do_async_writes,
2163 STm->do_read_ahead);
2164 printk(KERN_INFO
2165 "%s: can bsr: %d, two FMs: %d, fast mteom: %d, auto lock: %d,\n",
2166 name, STp->can_bsr, STp->two_fm, STp->fast_mteom, STp->do_auto_lock);
2167 printk(KERN_INFO
2168 "%s: defs for wr: %d, no block limits: %d, partitions: %d, s2 log: %d\n",
2169 name, STm->defaults_for_writes, STp->omit_blklims, STp->can_partitions,
2170 STp->scsi2_logical);
2171 printk(KERN_INFO
Kai Makisara40f6b362008-02-24 22:23:24 +02002172 "%s: sysv: %d nowait: %d sili: %d\n", name, STm->sysv, STp->immediate,
2173 STp->sili);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002174 printk(KERN_INFO "%s: debugging: %d\n",
2175 name, debugging);
2176 }
2177}
2178 )
2179
2180
2181static int st_set_options(struct scsi_tape *STp, long options)
2182{
2183 int value;
2184 long code;
2185 struct st_modedef *STm;
2186 char *name = tape_name(STp);
2187 struct cdev *cd0, *cd1;
2188
2189 STm = &(STp->modes[STp->current_mode]);
2190 if (!STm->defined) {
2191 cd0 = STm->cdevs[0]; cd1 = STm->cdevs[1];
2192 memcpy(STm, &(STp->modes[0]), sizeof(struct st_modedef));
2193 STm->cdevs[0] = cd0; STm->cdevs[1] = cd1;
2194 modes_defined = 1;
2195 DEBC(printk(ST_DEB_MSG
2196 "%s: Initialized mode %d definition from mode 0\n",
2197 name, STp->current_mode));
2198 }
2199
2200 code = options & MT_ST_OPTIONS;
2201 if (code == MT_ST_BOOLEANS) {
2202 STm->do_buffer_writes = (options & MT_ST_BUFFER_WRITES) != 0;
2203 STm->do_async_writes = (options & MT_ST_ASYNC_WRITES) != 0;
2204 STm->defaults_for_writes = (options & MT_ST_DEF_WRITES) != 0;
2205 STm->do_read_ahead = (options & MT_ST_READ_AHEAD) != 0;
2206 STp->two_fm = (options & MT_ST_TWO_FM) != 0;
2207 STp->fast_mteom = (options & MT_ST_FAST_MTEOM) != 0;
2208 STp->do_auto_lock = (options & MT_ST_AUTO_LOCK) != 0;
2209 STp->can_bsr = (options & MT_ST_CAN_BSR) != 0;
2210 STp->omit_blklims = (options & MT_ST_NO_BLKLIMS) != 0;
2211 if ((STp->device)->scsi_level >= SCSI_2)
2212 STp->can_partitions = (options & MT_ST_CAN_PARTITIONS) != 0;
2213 STp->scsi2_logical = (options & MT_ST_SCSI2LOGICAL) != 0;
2214 STp->immediate = (options & MT_ST_NOWAIT) != 0;
2215 STm->sysv = (options & MT_ST_SYSV) != 0;
Kai Makisara40f6b362008-02-24 22:23:24 +02002216 STp->sili = (options & MT_ST_SILI) != 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002217 DEB( debugging = (options & MT_ST_DEBUGGING) != 0;
2218 st_log_options(STp, STm, name); )
2219 } else if (code == MT_ST_SETBOOLEANS || code == MT_ST_CLEARBOOLEANS) {
2220 value = (code == MT_ST_SETBOOLEANS);
2221 if ((options & MT_ST_BUFFER_WRITES) != 0)
2222 STm->do_buffer_writes = value;
2223 if ((options & MT_ST_ASYNC_WRITES) != 0)
2224 STm->do_async_writes = value;
2225 if ((options & MT_ST_DEF_WRITES) != 0)
2226 STm->defaults_for_writes = value;
2227 if ((options & MT_ST_READ_AHEAD) != 0)
2228 STm->do_read_ahead = value;
2229 if ((options & MT_ST_TWO_FM) != 0)
2230 STp->two_fm = value;
2231 if ((options & MT_ST_FAST_MTEOM) != 0)
2232 STp->fast_mteom = value;
2233 if ((options & MT_ST_AUTO_LOCK) != 0)
2234 STp->do_auto_lock = value;
2235 if ((options & MT_ST_CAN_BSR) != 0)
2236 STp->can_bsr = value;
2237 if ((options & MT_ST_NO_BLKLIMS) != 0)
2238 STp->omit_blklims = value;
2239 if ((STp->device)->scsi_level >= SCSI_2 &&
2240 (options & MT_ST_CAN_PARTITIONS) != 0)
2241 STp->can_partitions = value;
2242 if ((options & MT_ST_SCSI2LOGICAL) != 0)
2243 STp->scsi2_logical = value;
2244 if ((options & MT_ST_NOWAIT) != 0)
2245 STp->immediate = value;
2246 if ((options & MT_ST_SYSV) != 0)
2247 STm->sysv = value;
Kai Makisara40f6b362008-02-24 22:23:24 +02002248 if ((options & MT_ST_SILI) != 0)
2249 STp->sili = value;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002250 DEB(
2251 if ((options & MT_ST_DEBUGGING) != 0)
2252 debugging = value;
2253 st_log_options(STp, STm, name); )
2254 } else if (code == MT_ST_WRITE_THRESHOLD) {
2255 /* Retained for compatibility */
2256 } else if (code == MT_ST_DEF_BLKSIZE) {
2257 value = (options & ~MT_ST_OPTIONS);
2258 if (value == ~MT_ST_OPTIONS) {
2259 STm->default_blksize = (-1);
2260 DEBC( printk(KERN_INFO "%s: Default block size disabled.\n", name));
2261 } else {
2262 STm->default_blksize = value;
2263 DEBC( printk(KERN_INFO "%s: Default block size set to %d bytes.\n",
2264 name, STm->default_blksize));
2265 if (STp->ready == ST_READY) {
2266 STp->blksize_changed = 0;
2267 set_mode_densblk(STp, STm);
2268 }
2269 }
2270 } else if (code == MT_ST_TIMEOUTS) {
2271 value = (options & ~MT_ST_OPTIONS);
2272 if ((value & MT_ST_SET_LONG_TIMEOUT) != 0) {
2273 STp->long_timeout = (value & ~MT_ST_SET_LONG_TIMEOUT) * HZ;
2274 DEBC( printk(KERN_INFO "%s: Long timeout set to %d seconds.\n", name,
2275 (value & ~MT_ST_SET_LONG_TIMEOUT)));
2276 } else {
James Bottomleya02488e2008-11-30 10:36:26 -06002277 blk_queue_rq_timeout(STp->device->request_queue,
2278 value * HZ);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002279 DEBC( printk(KERN_INFO "%s: Normal timeout set to %d seconds.\n",
2280 name, value) );
2281 }
2282 } else if (code == MT_ST_SET_CLN) {
2283 value = (options & ~MT_ST_OPTIONS) & 0xff;
2284 if (value != 0 &&
Roel Kluin832151f2009-11-17 14:53:22 -08002285 (value < EXTENDED_SENSE_START ||
2286 value >= SCSI_SENSE_BUFFERSIZE))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002287 return (-EINVAL);
2288 STp->cln_mode = value;
2289 STp->cln_sense_mask = (options >> 8) & 0xff;
2290 STp->cln_sense_value = (options >> 16) & 0xff;
2291 printk(KERN_INFO
2292 "%s: Cleaning request mode %d, mask %02x, value %02x\n",
2293 name, value, STp->cln_sense_mask, STp->cln_sense_value);
2294 } else if (code == MT_ST_DEF_OPTIONS) {
2295 code = (options & ~MT_ST_CLEAR_DEFAULT);
2296 value = (options & MT_ST_CLEAR_DEFAULT);
2297 if (code == MT_ST_DEF_DENSITY) {
2298 if (value == MT_ST_CLEAR_DEFAULT) {
2299 STm->default_density = (-1);
2300 DEBC( printk(KERN_INFO "%s: Density default disabled.\n",
2301 name));
2302 } else {
2303 STm->default_density = value & 0xff;
2304 DEBC( printk(KERN_INFO "%s: Density default set to %x\n",
2305 name, STm->default_density));
2306 if (STp->ready == ST_READY) {
2307 STp->density_changed = 0;
2308 set_mode_densblk(STp, STm);
2309 }
2310 }
2311 } else if (code == MT_ST_DEF_DRVBUFFER) {
2312 if (value == MT_ST_CLEAR_DEFAULT) {
2313 STp->default_drvbuffer = 0xff;
2314 DEBC( printk(KERN_INFO
2315 "%s: Drive buffer default disabled.\n", name));
2316 } else {
2317 STp->default_drvbuffer = value & 7;
2318 DEBC( printk(KERN_INFO
2319 "%s: Drive buffer default set to %x\n",
2320 name, STp->default_drvbuffer));
2321 if (STp->ready == ST_READY)
2322 st_int_ioctl(STp, MTSETDRVBUFFER, STp->default_drvbuffer);
2323 }
2324 } else if (code == MT_ST_DEF_COMPRESSION) {
2325 if (value == MT_ST_CLEAR_DEFAULT) {
2326 STm->default_compression = ST_DONT_TOUCH;
2327 DEBC( printk(KERN_INFO
2328 "%s: Compression default disabled.\n", name));
2329 } else {
2330 if ((value & 0xff00) != 0) {
2331 STp->c_algo = (value & 0xff00) >> 8;
2332 DEBC( printk(KERN_INFO "%s: Compression algorithm set to 0x%x.\n",
2333 name, STp->c_algo));
2334 }
2335 if ((value & 0xff) != 0xff) {
2336 STm->default_compression = (value & 1 ? ST_YES : ST_NO);
2337 DEBC( printk(KERN_INFO "%s: Compression default set to %x\n",
2338 name, (value & 1)));
2339 if (STp->ready == ST_READY) {
2340 STp->compression_changed = 0;
2341 st_compression(STp, (STm->default_compression == ST_YES));
2342 }
2343 }
2344 }
2345 }
2346 } else
2347 return (-EIO);
2348
2349 return 0;
2350}
2351
2352#define MODE_HEADER_LENGTH 4
2353
2354/* Mode header and page byte offsets */
2355#define MH_OFF_DATA_LENGTH 0
2356#define MH_OFF_MEDIUM_TYPE 1
2357#define MH_OFF_DEV_SPECIFIC 2
2358#define MH_OFF_BDESCS_LENGTH 3
2359#define MP_OFF_PAGE_NBR 0
2360#define MP_OFF_PAGE_LENGTH 1
2361
2362/* Mode header and page bit masks */
2363#define MH_BIT_WP 0x80
2364#define MP_MSK_PAGE_NBR 0x3f
2365
2366/* Don't return block descriptors */
2367#define MODE_SENSE_OMIT_BDESCS 0x08
2368
2369#define MODE_SELECT_PAGE_FORMAT 0x10
2370
2371/* Read a mode page into the tape buffer. The block descriptors are included
2372 if incl_block_descs is true. The page control is ored to the page number
2373 parameter, if necessary. */
2374static int read_mode_page(struct scsi_tape *STp, int page, int omit_block_descs)
2375{
2376 unsigned char cmd[MAX_COMMAND_SIZE];
FUJITA Tomonori8ecf0d92008-12-05 15:25:28 +09002377 struct st_request *SRpnt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002378
2379 memset(cmd, 0, MAX_COMMAND_SIZE);
2380 cmd[0] = MODE_SENSE;
2381 if (omit_block_descs)
2382 cmd[1] = MODE_SENSE_OMIT_BDESCS;
2383 cmd[2] = page;
2384 cmd[4] = 255;
2385
Kai Makisara02ae2c02008-12-18 14:49:50 +09002386 SRpnt = st_do_scsi(NULL, STp, cmd, cmd[4], DMA_FROM_DEVICE,
2387 STp->device->request_queue->rq_timeout, 0, 1);
2388 if (SRpnt == NULL)
2389 return (STp->buffer)->syscall_result;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002390
Mike Christie8b05b772005-11-08 04:06:44 -06002391 st_release_request(SRpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002392
Kai Makisara02ae2c02008-12-18 14:49:50 +09002393 return STp->buffer->syscall_result;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002394}
2395
2396
2397/* Send the mode page in the tape buffer to the drive. Assumes that the mode data
2398 in the buffer is correctly formatted. The long timeout is used if slow is non-zero. */
2399static int write_mode_page(struct scsi_tape *STp, int page, int slow)
2400{
Kai Makisara02ae2c02008-12-18 14:49:50 +09002401 int pgo;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002402 unsigned char cmd[MAX_COMMAND_SIZE];
FUJITA Tomonori18c87012008-12-05 15:25:29 +09002403 struct st_request *SRpnt;
Kai Makisara02ae2c02008-12-18 14:49:50 +09002404 int timeout;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002405
2406 memset(cmd, 0, MAX_COMMAND_SIZE);
2407 cmd[0] = MODE_SELECT;
2408 cmd[1] = MODE_SELECT_PAGE_FORMAT;
2409 pgo = MODE_HEADER_LENGTH + (STp->buffer)->b_data[MH_OFF_BDESCS_LENGTH];
2410 cmd[4] = pgo + (STp->buffer)->b_data[pgo + MP_OFF_PAGE_LENGTH] + 2;
2411
2412 /* Clear reserved fields */
2413 (STp->buffer)->b_data[MH_OFF_DATA_LENGTH] = 0;
2414 (STp->buffer)->b_data[MH_OFF_MEDIUM_TYPE] = 0;
2415 (STp->buffer)->b_data[MH_OFF_DEV_SPECIFIC] &= ~MH_BIT_WP;
2416 (STp->buffer)->b_data[pgo + MP_OFF_PAGE_NBR] &= MP_MSK_PAGE_NBR;
2417
Kai Makisara02ae2c02008-12-18 14:49:50 +09002418 timeout = slow ?
2419 STp->long_timeout : STp->device->request_queue->rq_timeout;
2420 SRpnt = st_do_scsi(NULL, STp, cmd, cmd[4], DMA_TO_DEVICE,
2421 timeout, 0, 1);
2422 if (SRpnt == NULL)
2423 return (STp->buffer)->syscall_result;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002424
Mike Christie8b05b772005-11-08 04:06:44 -06002425 st_release_request(SRpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002426
Kai Makisara02ae2c02008-12-18 14:49:50 +09002427 return STp->buffer->syscall_result;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002428}
2429
2430
2431#define COMPRESSION_PAGE 0x0f
2432#define COMPRESSION_PAGE_LENGTH 16
2433
2434#define CP_OFF_DCE_DCC 2
2435#define CP_OFF_C_ALGO 7
2436
2437#define DCE_MASK 0x80
2438#define DCC_MASK 0x40
2439#define RED_MASK 0x60
2440
2441
2442/* Control the compression with mode page 15. Algorithm not changed if zero.
2443
2444 The block descriptors are read and written because Sony SDT-7000 does not
2445 work without this (suggestion from Michael Schaefer <Michael.Schaefer@dlr.de>).
2446 Including block descriptors should not cause any harm to other drives. */
2447
2448static int st_compression(struct scsi_tape * STp, int state)
2449{
2450 int retval;
2451 int mpoffs; /* Offset to mode page start */
2452 unsigned char *b_data = (STp->buffer)->b_data;
2453 DEB( char *name = tape_name(STp); )
2454
2455 if (STp->ready != ST_READY)
2456 return (-EIO);
2457
2458 /* Read the current page contents */
2459 retval = read_mode_page(STp, COMPRESSION_PAGE, 0);
2460 if (retval) {
2461 DEBC(printk(ST_DEB_MSG "%s: Compression mode page not supported.\n",
2462 name));
2463 return (-EIO);
2464 }
2465
2466 mpoffs = MODE_HEADER_LENGTH + b_data[MH_OFF_BDESCS_LENGTH];
2467 DEBC(printk(ST_DEB_MSG "%s: Compression state is %d.\n", name,
2468 (b_data[mpoffs + CP_OFF_DCE_DCC] & DCE_MASK ? 1 : 0)));
2469
2470 /* Check if compression can be changed */
2471 if ((b_data[mpoffs + CP_OFF_DCE_DCC] & DCC_MASK) == 0) {
2472 DEBC(printk(ST_DEB_MSG "%s: Compression not supported.\n", name));
2473 return (-EIO);
2474 }
2475
2476 /* Do the change */
2477 if (state) {
2478 b_data[mpoffs + CP_OFF_DCE_DCC] |= DCE_MASK;
2479 if (STp->c_algo != 0)
2480 b_data[mpoffs + CP_OFF_C_ALGO] = STp->c_algo;
2481 }
2482 else {
2483 b_data[mpoffs + CP_OFF_DCE_DCC] &= ~DCE_MASK;
2484 if (STp->c_algo != 0)
2485 b_data[mpoffs + CP_OFF_C_ALGO] = 0; /* no compression */
2486 }
2487
2488 retval = write_mode_page(STp, COMPRESSION_PAGE, 0);
2489 if (retval) {
2490 DEBC(printk(ST_DEB_MSG "%s: Compression change failed.\n", name));
2491 return (-EIO);
2492 }
2493 DEBC(printk(ST_DEB_MSG "%s: Compression state changed to %d.\n",
2494 name, state));
2495
2496 STp->compression_changed = 1;
2497 return 0;
2498}
2499
2500
2501/* Process the load and unload commands (does unload if the load code is zero) */
2502static int do_load_unload(struct scsi_tape *STp, struct file *filp, int load_code)
2503{
2504 int retval = (-EIO), timeout;
2505 DEB( char *name = tape_name(STp); )
2506 unsigned char cmd[MAX_COMMAND_SIZE];
2507 struct st_partstat *STps;
Mike Christie8b05b772005-11-08 04:06:44 -06002508 struct st_request *SRpnt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002509
2510 if (STp->ready != ST_READY && !load_code) {
2511 if (STp->ready == ST_NO_TAPE)
2512 return (-ENOMEDIUM);
2513 else
2514 return (-EIO);
2515 }
2516
2517 memset(cmd, 0, MAX_COMMAND_SIZE);
2518 cmd[0] = START_STOP;
2519 if (load_code)
2520 cmd[4] |= 1;
2521 /*
2522 * If arg >= 1 && arg <= 6 Enhanced load/unload in HP C1553A
2523 */
2524 if (load_code >= 1 + MT_ST_HPLOADER_OFFSET
2525 && load_code <= 6 + MT_ST_HPLOADER_OFFSET) {
2526 DEBC(printk(ST_DEB_MSG "%s: Enhanced %sload slot %2d.\n",
2527 name, (cmd[4]) ? "" : "un",
2528 load_code - MT_ST_HPLOADER_OFFSET));
2529 cmd[3] = load_code - MT_ST_HPLOADER_OFFSET; /* MediaID field of C1553A */
2530 }
2531 if (STp->immediate) {
2532 cmd[1] = 1; /* Don't wait for completion */
James Bottomleya02488e2008-11-30 10:36:26 -06002533 timeout = STp->device->request_queue->rq_timeout;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002534 }
2535 else
2536 timeout = STp->long_timeout;
2537
2538 DEBC(
2539 if (!load_code)
2540 printk(ST_DEB_MSG "%s: Unloading tape.\n", name);
2541 else
2542 printk(ST_DEB_MSG "%s: Loading tape.\n", name);
2543 );
2544
Kai Makisara02ae2c02008-12-18 14:49:50 +09002545 SRpnt = st_do_scsi(NULL, STp, cmd, 0, DMA_NONE,
2546 timeout, MAX_RETRIES, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002547 if (!SRpnt)
Kai Makisara02ae2c02008-12-18 14:49:50 +09002548 return (STp->buffer)->syscall_result;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002549
2550 retval = (STp->buffer)->syscall_result;
Kai Makisara02ae2c02008-12-18 14:49:50 +09002551 st_release_request(SRpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002552
2553 if (!retval) { /* SCSI command successful */
2554
2555 if (!load_code) {
2556 STp->rew_at_close = 0;
2557 STp->ready = ST_NO_TAPE;
2558 }
2559 else {
2560 STp->rew_at_close = STp->autorew_dev;
2561 retval = check_tape(STp, filp);
2562 if (retval > 0)
2563 retval = 0;
2564 }
2565 }
2566 else {
2567 STps = &(STp->ps[STp->partition]);
2568 STps->drv_file = STps->drv_block = (-1);
2569 }
2570
2571 return retval;
2572}
2573
2574#if DEBUG
2575#define ST_DEB_FORWARD 0
2576#define ST_DEB_BACKWARD 1
2577static void deb_space_print(char *name, int direction, char *units, unsigned char *cmd)
2578{
2579 s32 sc;
2580
2581 sc = cmd[2] & 0x80 ? 0xff000000 : 0;
2582 sc |= (cmd[2] << 16) | (cmd[3] << 8) | cmd[4];
2583 if (direction)
2584 sc = -sc;
2585 printk(ST_DEB_MSG "%s: Spacing tape %s over %d %s.\n", name,
2586 direction ? "backward" : "forward", sc, units);
2587}
2588#endif
2589
2590
2591/* Internal ioctl function */
2592static int st_int_ioctl(struct scsi_tape *STp, unsigned int cmd_in, unsigned long arg)
2593{
2594 int timeout;
2595 long ltmp;
2596 int ioctl_result;
2597 int chg_eof = 1;
2598 unsigned char cmd[MAX_COMMAND_SIZE];
Mike Christie8b05b772005-11-08 04:06:44 -06002599 struct st_request *SRpnt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002600 struct st_partstat *STps;
2601 int fileno, blkno, at_sm, undone;
2602 int datalen = 0, direction = DMA_NONE;
2603 char *name = tape_name(STp);
2604
2605 WARN_ON(STp->buffer->do_dio != 0);
2606 if (STp->ready != ST_READY) {
2607 if (STp->ready == ST_NO_TAPE)
2608 return (-ENOMEDIUM);
2609 else
2610 return (-EIO);
2611 }
2612 timeout = STp->long_timeout;
2613 STps = &(STp->ps[STp->partition]);
2614 fileno = STps->drv_file;
2615 blkno = STps->drv_block;
2616 at_sm = STps->at_sm;
2617
2618 memset(cmd, 0, MAX_COMMAND_SIZE);
2619 switch (cmd_in) {
2620 case MTFSFM:
2621 chg_eof = 0; /* Changed from the FSF after this */
2622 case MTFSF:
2623 cmd[0] = SPACE;
2624 cmd[1] = 0x01; /* Space FileMarks */
2625 cmd[2] = (arg >> 16);
2626 cmd[3] = (arg >> 8);
2627 cmd[4] = arg;
2628 DEBC(deb_space_print(name, ST_DEB_FORWARD, "filemarks", cmd);)
2629 if (fileno >= 0)
2630 fileno += arg;
2631 blkno = 0;
2632 at_sm &= (arg == 0);
2633 break;
2634 case MTBSFM:
2635 chg_eof = 0; /* Changed from the FSF after this */
2636 case MTBSF:
2637 cmd[0] = SPACE;
2638 cmd[1] = 0x01; /* Space FileMarks */
2639 ltmp = (-arg);
2640 cmd[2] = (ltmp >> 16);
2641 cmd[3] = (ltmp >> 8);
2642 cmd[4] = ltmp;
2643 DEBC(deb_space_print(name, ST_DEB_BACKWARD, "filemarks", cmd);)
2644 if (fileno >= 0)
2645 fileno -= arg;
2646 blkno = (-1); /* We can't know the block number */
2647 at_sm &= (arg == 0);
2648 break;
2649 case MTFSR:
2650 cmd[0] = SPACE;
2651 cmd[1] = 0x00; /* Space Blocks */
2652 cmd[2] = (arg >> 16);
2653 cmd[3] = (arg >> 8);
2654 cmd[4] = arg;
2655 DEBC(deb_space_print(name, ST_DEB_FORWARD, "blocks", cmd);)
2656 if (blkno >= 0)
2657 blkno += arg;
2658 at_sm &= (arg == 0);
2659 break;
2660 case MTBSR:
2661 cmd[0] = SPACE;
2662 cmd[1] = 0x00; /* Space Blocks */
2663 ltmp = (-arg);
2664 cmd[2] = (ltmp >> 16);
2665 cmd[3] = (ltmp >> 8);
2666 cmd[4] = ltmp;
2667 DEBC(deb_space_print(name, ST_DEB_BACKWARD, "blocks", cmd);)
2668 if (blkno >= 0)
2669 blkno -= arg;
2670 at_sm &= (arg == 0);
2671 break;
2672 case MTFSS:
2673 cmd[0] = SPACE;
2674 cmd[1] = 0x04; /* Space Setmarks */
2675 cmd[2] = (arg >> 16);
2676 cmd[3] = (arg >> 8);
2677 cmd[4] = arg;
2678 DEBC(deb_space_print(name, ST_DEB_FORWARD, "setmarks", cmd);)
2679 if (arg != 0) {
2680 blkno = fileno = (-1);
2681 at_sm = 1;
2682 }
2683 break;
2684 case MTBSS:
2685 cmd[0] = SPACE;
2686 cmd[1] = 0x04; /* Space Setmarks */
2687 ltmp = (-arg);
2688 cmd[2] = (ltmp >> 16);
2689 cmd[3] = (ltmp >> 8);
2690 cmd[4] = ltmp;
2691 DEBC(deb_space_print(name, ST_DEB_BACKWARD, "setmarks", cmd);)
2692 if (arg != 0) {
2693 blkno = fileno = (-1);
2694 at_sm = 1;
2695 }
2696 break;
2697 case MTWEOF:
2698 case MTWSM:
2699 if (STp->write_prot)
2700 return (-EACCES);
2701 cmd[0] = WRITE_FILEMARKS;
2702 if (cmd_in == MTWSM)
2703 cmd[1] = 2;
2704 cmd[2] = (arg >> 16);
2705 cmd[3] = (arg >> 8);
2706 cmd[4] = arg;
James Bottomleya02488e2008-11-30 10:36:26 -06002707 timeout = STp->device->request_queue->rq_timeout;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002708 DEBC(
2709 if (cmd_in == MTWEOF)
2710 printk(ST_DEB_MSG "%s: Writing %d filemarks.\n", name,
2711 cmd[2] * 65536 + cmd[3] * 256 + cmd[4]);
2712 else
2713 printk(ST_DEB_MSG "%s: Writing %d setmarks.\n", name,
2714 cmd[2] * 65536 + cmd[3] * 256 + cmd[4]);
2715 )
2716 if (fileno >= 0)
2717 fileno += arg;
2718 blkno = 0;
2719 at_sm = (cmd_in == MTWSM);
2720 break;
2721 case MTREW:
2722 cmd[0] = REZERO_UNIT;
2723 if (STp->immediate) {
2724 cmd[1] = 1; /* Don't wait for completion */
James Bottomleya02488e2008-11-30 10:36:26 -06002725 timeout = STp->device->request_queue->rq_timeout;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002726 }
2727 DEBC(printk(ST_DEB_MSG "%s: Rewinding tape.\n", name));
2728 fileno = blkno = at_sm = 0;
2729 break;
2730 case MTNOP:
2731 DEBC(printk(ST_DEB_MSG "%s: No op on tape.\n", name));
2732 return 0; /* Should do something ? */
2733 break;
2734 case MTRETEN:
2735 cmd[0] = START_STOP;
2736 if (STp->immediate) {
2737 cmd[1] = 1; /* Don't wait for completion */
James Bottomleya02488e2008-11-30 10:36:26 -06002738 timeout = STp->device->request_queue->rq_timeout;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002739 }
2740 cmd[4] = 3;
2741 DEBC(printk(ST_DEB_MSG "%s: Retensioning tape.\n", name));
2742 fileno = blkno = at_sm = 0;
2743 break;
2744 case MTEOM:
2745 if (!STp->fast_mteom) {
2746 /* space to the end of tape */
2747 ioctl_result = st_int_ioctl(STp, MTFSF, 0x7fffff);
2748 fileno = STps->drv_file;
2749 if (STps->eof >= ST_EOD_1)
2750 return 0;
2751 /* The next lines would hide the number of spaced FileMarks
2752 That's why I inserted the previous lines. I had no luck
2753 with detecting EOM with FSF, so we go now to EOM.
2754 Joerg Weule */
2755 } else
2756 fileno = (-1);
2757 cmd[0] = SPACE;
2758 cmd[1] = 3;
2759 DEBC(printk(ST_DEB_MSG "%s: Spacing to end of recorded medium.\n",
2760 name));
2761 blkno = -1;
2762 at_sm = 0;
2763 break;
2764 case MTERASE:
2765 if (STp->write_prot)
2766 return (-EACCES);
2767 cmd[0] = ERASE;
2768 cmd[1] = (arg ? 1 : 0); /* Long erase with non-zero argument */
2769 if (STp->immediate) {
2770 cmd[1] |= 2; /* Don't wait for completion */
James Bottomleya02488e2008-11-30 10:36:26 -06002771 timeout = STp->device->request_queue->rq_timeout;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002772 }
2773 else
2774 timeout = STp->long_timeout * 8;
2775
2776 DEBC(printk(ST_DEB_MSG "%s: Erasing tape.\n", name));
2777 fileno = blkno = at_sm = 0;
2778 break;
2779 case MTSETBLK: /* Set block length */
2780 case MTSETDENSITY: /* Set tape density */
2781 case MTSETDRVBUFFER: /* Set drive buffering */
2782 case SET_DENS_AND_BLK: /* Set density and block size */
2783 chg_eof = 0;
2784 if (STp->dirty || (STp->buffer)->buffer_bytes != 0)
2785 return (-EIO); /* Not allowed if data in buffer */
2786 if ((cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) &&
2787 (arg & MT_ST_BLKSIZE_MASK) != 0 &&
2788 STp->max_block > 0 &&
2789 ((arg & MT_ST_BLKSIZE_MASK) < STp->min_block ||
2790 (arg & MT_ST_BLKSIZE_MASK) > STp->max_block)) {
2791 printk(KERN_WARNING "%s: Illegal block size.\n", name);
2792 return (-EINVAL);
2793 }
2794 cmd[0] = MODE_SELECT;
2795 if ((STp->use_pf & USE_PF))
2796 cmd[1] = MODE_SELECT_PAGE_FORMAT;
2797 cmd[4] = datalen = 12;
2798 direction = DMA_TO_DEVICE;
2799
2800 memset((STp->buffer)->b_data, 0, 12);
2801 if (cmd_in == MTSETDRVBUFFER)
2802 (STp->buffer)->b_data[2] = (arg & 7) << 4;
2803 else
2804 (STp->buffer)->b_data[2] =
2805 STp->drv_buffer << 4;
2806 (STp->buffer)->b_data[3] = 8; /* block descriptor length */
2807 if (cmd_in == MTSETDENSITY) {
2808 (STp->buffer)->b_data[4] = arg;
2809 STp->density_changed = 1; /* At least we tried ;-) */
2810 } else if (cmd_in == SET_DENS_AND_BLK)
2811 (STp->buffer)->b_data[4] = arg >> 24;
2812 else
2813 (STp->buffer)->b_data[4] = STp->density;
2814 if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) {
2815 ltmp = arg & MT_ST_BLKSIZE_MASK;
2816 if (cmd_in == MTSETBLK)
2817 STp->blksize_changed = 1; /* At least we tried ;-) */
2818 } else
2819 ltmp = STp->block_size;
2820 (STp->buffer)->b_data[9] = (ltmp >> 16);
2821 (STp->buffer)->b_data[10] = (ltmp >> 8);
2822 (STp->buffer)->b_data[11] = ltmp;
James Bottomleya02488e2008-11-30 10:36:26 -06002823 timeout = STp->device->request_queue->rq_timeout;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002824 DEBC(
2825 if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK)
2826 printk(ST_DEB_MSG
2827 "%s: Setting block size to %d bytes.\n", name,
2828 (STp->buffer)->b_data[9] * 65536 +
2829 (STp->buffer)->b_data[10] * 256 +
2830 (STp->buffer)->b_data[11]);
2831 if (cmd_in == MTSETDENSITY || cmd_in == SET_DENS_AND_BLK)
2832 printk(ST_DEB_MSG
2833 "%s: Setting density code to %x.\n", name,
2834 (STp->buffer)->b_data[4]);
2835 if (cmd_in == MTSETDRVBUFFER)
2836 printk(ST_DEB_MSG
2837 "%s: Setting drive buffer code to %d.\n", name,
2838 ((STp->buffer)->b_data[2] >> 4) & 7);
2839 )
2840 break;
2841 default:
2842 return (-ENOSYS);
2843 }
2844
Kai Makisara02ae2c02008-12-18 14:49:50 +09002845 SRpnt = st_do_scsi(NULL, STp, cmd, datalen, direction,
2846 timeout, MAX_RETRIES, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002847 if (!SRpnt)
2848 return (STp->buffer)->syscall_result;
2849
Kai Makisara02ae2c02008-12-18 14:49:50 +09002850 ioctl_result = (STp->buffer)->syscall_result;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002851
2852 if (!ioctl_result) { /* SCSI command successful */
Mike Christie8b05b772005-11-08 04:06:44 -06002853 st_release_request(SRpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002854 SRpnt = NULL;
2855 STps->drv_block = blkno;
2856 STps->drv_file = fileno;
2857 STps->at_sm = at_sm;
2858
2859 if (cmd_in == MTBSFM)
2860 ioctl_result = st_int_ioctl(STp, MTFSF, 1);
2861 else if (cmd_in == MTFSFM)
2862 ioctl_result = st_int_ioctl(STp, MTBSF, 1);
2863
2864 if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002865 STp->block_size = arg & MT_ST_BLKSIZE_MASK;
2866 if (STp->block_size != 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002867 (STp->buffer)->buffer_blocks =
2868 (STp->buffer)->buffer_size / STp->block_size;
2869 }
2870 (STp->buffer)->buffer_bytes = (STp->buffer)->read_pointer = 0;
2871 if (cmd_in == SET_DENS_AND_BLK)
2872 STp->density = arg >> MT_ST_DENSITY_SHIFT;
2873 } else if (cmd_in == MTSETDRVBUFFER)
2874 STp->drv_buffer = (arg & 7);
2875 else if (cmd_in == MTSETDENSITY)
2876 STp->density = arg;
2877
2878 if (cmd_in == MTEOM)
2879 STps->eof = ST_EOD;
2880 else if (cmd_in == MTFSF)
2881 STps->eof = ST_FM;
2882 else if (chg_eof)
2883 STps->eof = ST_NOEOF;
2884
2885 if (cmd_in == MTWEOF)
2886 STps->rw = ST_IDLE;
2887 } else { /* SCSI command was not completely successful. Don't return
2888 from this block without releasing the SCSI command block! */
2889 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
2890
2891 if (cmdstatp->flags & SENSE_EOM) {
2892 if (cmd_in != MTBSF && cmd_in != MTBSFM &&
2893 cmd_in != MTBSR && cmd_in != MTBSS)
2894 STps->eof = ST_EOM_OK;
2895 STps->drv_block = 0;
2896 }
2897
2898 if (cmdstatp->remainder_valid)
2899 undone = (int)cmdstatp->uremainder64;
2900 else
2901 undone = 0;
2902
2903 if (cmd_in == MTWEOF &&
2904 cmdstatp->have_sense &&
Kai Makisara91614c02007-01-26 00:38:39 +02002905 (cmdstatp->flags & SENSE_EOM)) {
2906 if (cmdstatp->sense_hdr.sense_key == NO_SENSE ||
2907 cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR) {
2908 ioctl_result = 0; /* EOF(s) written successfully at EOM */
2909 STps->eof = ST_NOEOF;
2910 } else { /* Writing EOF(s) failed */
2911 if (fileno >= 0)
2912 fileno -= undone;
2913 if (undone < arg)
2914 STps->eof = ST_NOEOF;
2915 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002916 STps->drv_file = fileno;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002917 } else if ((cmd_in == MTFSF) || (cmd_in == MTFSFM)) {
2918 if (fileno >= 0)
2919 STps->drv_file = fileno - undone;
2920 else
2921 STps->drv_file = fileno;
2922 STps->drv_block = -1;
2923 STps->eof = ST_NOEOF;
2924 } else if ((cmd_in == MTBSF) || (cmd_in == MTBSFM)) {
2925 if (arg > 0 && undone < 0) /* Some drives get this wrong */
2926 undone = (-undone);
2927 if (STps->drv_file >= 0)
2928 STps->drv_file = fileno + undone;
2929 STps->drv_block = 0;
2930 STps->eof = ST_NOEOF;
2931 } else if (cmd_in == MTFSR) {
2932 if (cmdstatp->flags & SENSE_FMK) { /* Hit filemark */
2933 if (STps->drv_file >= 0)
2934 STps->drv_file++;
2935 STps->drv_block = 0;
2936 STps->eof = ST_FM;
2937 } else {
2938 if (blkno >= undone)
2939 STps->drv_block = blkno - undone;
2940 else
2941 STps->drv_block = (-1);
2942 STps->eof = ST_NOEOF;
2943 }
2944 } else if (cmd_in == MTBSR) {
2945 if (cmdstatp->flags & SENSE_FMK) { /* Hit filemark */
2946 STps->drv_file--;
2947 STps->drv_block = (-1);
2948 } else {
2949 if (arg > 0 && undone < 0) /* Some drives get this wrong */
2950 undone = (-undone);
2951 if (STps->drv_block >= 0)
2952 STps->drv_block = blkno + undone;
2953 }
2954 STps->eof = ST_NOEOF;
2955 } else if (cmd_in == MTEOM) {
2956 STps->drv_file = (-1);
2957 STps->drv_block = (-1);
2958 STps->eof = ST_EOD;
2959 } else if (cmd_in == MTSETBLK ||
2960 cmd_in == MTSETDENSITY ||
2961 cmd_in == MTSETDRVBUFFER ||
2962 cmd_in == SET_DENS_AND_BLK) {
2963 if (cmdstatp->sense_hdr.sense_key == ILLEGAL_REQUEST &&
2964 !(STp->use_pf & PF_TESTED)) {
2965 /* Try the other possible state of Page Format if not
2966 already tried */
Kai Makisara1da20192009-05-02 08:49:34 +03002967 STp->use_pf = (STp->use_pf ^ USE_PF) | PF_TESTED;
Mike Christie8b05b772005-11-08 04:06:44 -06002968 st_release_request(SRpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002969 SRpnt = NULL;
2970 return st_int_ioctl(STp, cmd_in, arg);
2971 }
2972 } else if (chg_eof)
2973 STps->eof = ST_NOEOF;
2974
2975 if (cmdstatp->sense_hdr.sense_key == BLANK_CHECK)
2976 STps->eof = ST_EOD;
2977
Mike Christie8b05b772005-11-08 04:06:44 -06002978 st_release_request(SRpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002979 SRpnt = NULL;
2980 }
2981
2982 return ioctl_result;
2983}
2984
2985
2986/* Get the tape position. If bt == 2, arg points into a kernel space mt_loc
2987 structure. */
2988
2989static int get_location(struct scsi_tape *STp, unsigned int *block, int *partition,
2990 int logical)
2991{
2992 int result;
2993 unsigned char scmd[MAX_COMMAND_SIZE];
Mike Christie8b05b772005-11-08 04:06:44 -06002994 struct st_request *SRpnt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002995 DEB( char *name = tape_name(STp); )
2996
2997 if (STp->ready != ST_READY)
2998 return (-EIO);
2999
3000 memset(scmd, 0, MAX_COMMAND_SIZE);
3001 if ((STp->device)->scsi_level < SCSI_2) {
3002 scmd[0] = QFA_REQUEST_BLOCK;
3003 scmd[4] = 3;
3004 } else {
3005 scmd[0] = READ_POSITION;
3006 if (!logical && !STp->scsi2_logical)
3007 scmd[1] = 1;
3008 }
Kai Makisara02ae2c02008-12-18 14:49:50 +09003009 SRpnt = st_do_scsi(NULL, STp, scmd, 20, DMA_FROM_DEVICE,
3010 STp->device->request_queue->rq_timeout,
3011 MAX_READY_RETRIES, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003012 if (!SRpnt)
Kai Makisara02ae2c02008-12-18 14:49:50 +09003013 return (STp->buffer)->syscall_result;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003014
3015 if ((STp->buffer)->syscall_result != 0 ||
3016 (STp->device->scsi_level >= SCSI_2 &&
3017 ((STp->buffer)->b_data[0] & 4) != 0)) {
3018 *block = *partition = 0;
3019 DEBC(printk(ST_DEB_MSG "%s: Can't read tape position.\n", name));
3020 result = (-EIO);
3021 } else {
3022 result = 0;
3023 if ((STp->device)->scsi_level < SCSI_2) {
3024 *block = ((STp->buffer)->b_data[0] << 16)
3025 + ((STp->buffer)->b_data[1] << 8)
3026 + (STp->buffer)->b_data[2];
3027 *partition = 0;
3028 } else {
3029 *block = ((STp->buffer)->b_data[4] << 24)
3030 + ((STp->buffer)->b_data[5] << 16)
3031 + ((STp->buffer)->b_data[6] << 8)
3032 + (STp->buffer)->b_data[7];
3033 *partition = (STp->buffer)->b_data[1];
3034 if (((STp->buffer)->b_data[0] & 0x80) &&
3035 (STp->buffer)->b_data[1] == 0) /* BOP of partition 0 */
3036 STp->ps[0].drv_block = STp->ps[0].drv_file = 0;
3037 }
3038 DEBC(printk(ST_DEB_MSG "%s: Got tape pos. blk %d part %d.\n", name,
3039 *block, *partition));
3040 }
Mike Christie8b05b772005-11-08 04:06:44 -06003041 st_release_request(SRpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003042 SRpnt = NULL;
3043
3044 return result;
3045}
3046
3047
3048/* Set the tape block and partition. Negative partition means that only the
3049 block should be set in vendor specific way. */
3050static int set_location(struct scsi_tape *STp, unsigned int block, int partition,
3051 int logical)
3052{
3053 struct st_partstat *STps;
3054 int result, p;
3055 unsigned int blk;
3056 int timeout;
3057 unsigned char scmd[MAX_COMMAND_SIZE];
Mike Christie8b05b772005-11-08 04:06:44 -06003058 struct st_request *SRpnt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003059 DEB( char *name = tape_name(STp); )
3060
3061 if (STp->ready != ST_READY)
3062 return (-EIO);
3063 timeout = STp->long_timeout;
3064 STps = &(STp->ps[STp->partition]);
3065
3066 DEBC(printk(ST_DEB_MSG "%s: Setting block to %d and partition to %d.\n",
3067 name, block, partition));
3068 DEB(if (partition < 0)
3069 return (-EIO); )
3070
3071 /* Update the location at the partition we are leaving */
3072 if ((!STp->can_partitions && partition != 0) ||
3073 partition >= ST_NBR_PARTITIONS)
3074 return (-EINVAL);
3075 if (partition != STp->partition) {
3076 if (get_location(STp, &blk, &p, 1))
3077 STps->last_block_valid = 0;
3078 else {
3079 STps->last_block_valid = 1;
3080 STps->last_block_visited = blk;
3081 DEBC(printk(ST_DEB_MSG
3082 "%s: Visited block %d for partition %d saved.\n",
3083 name, blk, STp->partition));
3084 }
3085 }
3086
3087 memset(scmd, 0, MAX_COMMAND_SIZE);
3088 if ((STp->device)->scsi_level < SCSI_2) {
3089 scmd[0] = QFA_SEEK_BLOCK;
3090 scmd[2] = (block >> 16);
3091 scmd[3] = (block >> 8);
3092 scmd[4] = block;
3093 scmd[5] = 0;
3094 } else {
3095 scmd[0] = SEEK_10;
3096 scmd[3] = (block >> 24);
3097 scmd[4] = (block >> 16);
3098 scmd[5] = (block >> 8);
3099 scmd[6] = block;
3100 if (!logical && !STp->scsi2_logical)
3101 scmd[1] = 4;
3102 if (STp->partition != partition) {
3103 scmd[1] |= 2;
3104 scmd[8] = partition;
3105 DEBC(printk(ST_DEB_MSG
3106 "%s: Trying to change partition from %d to %d\n",
3107 name, STp->partition, partition));
3108 }
3109 }
3110 if (STp->immediate) {
3111 scmd[1] |= 1; /* Don't wait for completion */
James Bottomleya02488e2008-11-30 10:36:26 -06003112 timeout = STp->device->request_queue->rq_timeout;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003113 }
3114
Kai Makisara02ae2c02008-12-18 14:49:50 +09003115 SRpnt = st_do_scsi(NULL, STp, scmd, 0, DMA_NONE,
3116 timeout, MAX_READY_RETRIES, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003117 if (!SRpnt)
Kai Makisara02ae2c02008-12-18 14:49:50 +09003118 return (STp->buffer)->syscall_result;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003119
3120 STps->drv_block = STps->drv_file = (-1);
3121 STps->eof = ST_NOEOF;
3122 if ((STp->buffer)->syscall_result != 0) {
3123 result = (-EIO);
3124 if (STp->can_partitions &&
3125 (STp->device)->scsi_level >= SCSI_2 &&
3126 (p = find_partition(STp)) >= 0)
3127 STp->partition = p;
3128 } else {
3129 if (STp->can_partitions) {
3130 STp->partition = partition;
3131 STps = &(STp->ps[partition]);
3132 if (!STps->last_block_valid ||
3133 STps->last_block_visited != block) {
3134 STps->at_sm = 0;
3135 STps->rw = ST_IDLE;
3136 }
3137 } else
3138 STps->at_sm = 0;
3139 if (block == 0)
3140 STps->drv_block = STps->drv_file = 0;
3141 result = 0;
3142 }
Kai Makisara02ae2c02008-12-18 14:49:50 +09003143
Mike Christie8b05b772005-11-08 04:06:44 -06003144 st_release_request(SRpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003145 SRpnt = NULL;
3146
3147 return result;
3148}
3149
3150
3151/* Find the current partition number for the drive status. Called from open and
3152 returns either partition number of negative error code. */
3153static int find_partition(struct scsi_tape *STp)
3154{
3155 int i, partition;
3156 unsigned int block;
3157
3158 if ((i = get_location(STp, &block, &partition, 1)) < 0)
3159 return i;
3160 if (partition >= ST_NBR_PARTITIONS)
3161 return (-EIO);
3162 return partition;
3163}
3164
3165
3166/* Change the partition if necessary */
3167static int switch_partition(struct scsi_tape *STp)
3168{
3169 struct st_partstat *STps;
3170
3171 if (STp->partition == STp->new_partition)
3172 return 0;
3173 STps = &(STp->ps[STp->new_partition]);
3174 if (!STps->last_block_valid)
3175 STps->last_block_visited = 0;
3176 return set_location(STp, STps->last_block_visited, STp->new_partition, 1);
3177}
3178
3179/* Functions for reading and writing the medium partition mode page. */
3180
3181#define PART_PAGE 0x11
3182#define PART_PAGE_FIXED_LENGTH 8
3183
3184#define PP_OFF_MAX_ADD_PARTS 2
3185#define PP_OFF_NBR_ADD_PARTS 3
3186#define PP_OFF_FLAGS 4
3187#define PP_OFF_PART_UNITS 6
3188#define PP_OFF_RESERVED 7
3189
3190#define PP_BIT_IDP 0x20
3191#define PP_MSK_PSUM_MB 0x10
3192
3193/* Get the number of partitions on the tape. As a side effect reads the
3194 mode page into the tape buffer. */
3195static int nbr_partitions(struct scsi_tape *STp)
3196{
3197 int result;
3198 DEB( char *name = tape_name(STp); )
3199
3200 if (STp->ready != ST_READY)
3201 return (-EIO);
3202
3203 result = read_mode_page(STp, PART_PAGE, 1);
3204
3205 if (result) {
3206 DEBC(printk(ST_DEB_MSG "%s: Can't read medium partition page.\n",
3207 name));
3208 result = (-EIO);
3209 } else {
3210 result = (STp->buffer)->b_data[MODE_HEADER_LENGTH +
3211 PP_OFF_NBR_ADD_PARTS] + 1;
3212 DEBC(printk(ST_DEB_MSG "%s: Number of partitions %d.\n", name, result));
3213 }
3214
3215 return result;
3216}
3217
3218
3219/* Partition the tape into two partitions if size > 0 or one partition if
3220 size == 0.
3221
3222 The block descriptors are read and written because Sony SDT-7000 does not
3223 work without this (suggestion from Michael Schaefer <Michael.Schaefer@dlr.de>).
3224
3225 My HP C1533A drive returns only one partition size field. This is used to
3226 set the size of partition 1. There is no size field for the default partition.
3227 Michael Schaefer's Sony SDT-7000 returns two descriptors and the second is
3228 used to set the size of partition 1 (this is what the SCSI-3 standard specifies).
3229 The following algorithm is used to accommodate both drives: if the number of
3230 partition size fields is greater than the maximum number of additional partitions
3231 in the mode page, the second field is used. Otherwise the first field is used.
3232
3233 For Seagate DDS drives the page length must be 8 when no partitions is defined
3234 and 10 when 1 partition is defined (information from Eric Lee Green). This is
3235 is acceptable also to some other old drives and enforced if the first partition
3236 size field is used for the first additional partition size.
3237 */
3238static int partition_tape(struct scsi_tape *STp, int size)
3239{
3240 char *name = tape_name(STp);
3241 int result;
3242 int pgo, psd_cnt, psdo;
3243 unsigned char *bp;
3244
3245 result = read_mode_page(STp, PART_PAGE, 0);
3246 if (result) {
3247 DEBC(printk(ST_DEB_MSG "%s: Can't read partition mode page.\n", name));
3248 return result;
3249 }
3250 /* The mode page is in the buffer. Let's modify it and write it. */
3251 bp = (STp->buffer)->b_data;
3252 pgo = MODE_HEADER_LENGTH + bp[MH_OFF_BDESCS_LENGTH];
3253 DEBC(printk(ST_DEB_MSG "%s: Partition page length is %d bytes.\n",
3254 name, bp[pgo + MP_OFF_PAGE_LENGTH] + 2));
3255
3256 psd_cnt = (bp[pgo + MP_OFF_PAGE_LENGTH] + 2 - PART_PAGE_FIXED_LENGTH) / 2;
3257 psdo = pgo + PART_PAGE_FIXED_LENGTH;
3258 if (psd_cnt > bp[pgo + PP_OFF_MAX_ADD_PARTS]) {
3259 bp[psdo] = bp[psdo + 1] = 0xff; /* Rest of the tape */
3260 psdo += 2;
3261 }
3262 memset(bp + psdo, 0, bp[pgo + PP_OFF_NBR_ADD_PARTS] * 2);
3263
3264 DEBC(printk("%s: psd_cnt %d, max.parts %d, nbr_parts %d\n", name,
3265 psd_cnt, bp[pgo + PP_OFF_MAX_ADD_PARTS],
3266 bp[pgo + PP_OFF_NBR_ADD_PARTS]));
3267
3268 if (size <= 0) {
3269 bp[pgo + PP_OFF_NBR_ADD_PARTS] = 0;
3270 if (psd_cnt <= bp[pgo + PP_OFF_MAX_ADD_PARTS])
3271 bp[pgo + MP_OFF_PAGE_LENGTH] = 6;
3272 DEBC(printk(ST_DEB_MSG "%s: Formatting tape with one partition.\n",
3273 name));
3274 } else {
3275 bp[psdo] = (size >> 8) & 0xff;
3276 bp[psdo + 1] = size & 0xff;
3277 bp[pgo + 3] = 1;
3278 if (bp[pgo + MP_OFF_PAGE_LENGTH] < 8)
3279 bp[pgo + MP_OFF_PAGE_LENGTH] = 8;
3280 DEBC(printk(ST_DEB_MSG
3281 "%s: Formatting tape with two partitions (1 = %d MB).\n",
3282 name, size));
3283 }
3284 bp[pgo + PP_OFF_PART_UNITS] = 0;
3285 bp[pgo + PP_OFF_RESERVED] = 0;
3286 bp[pgo + PP_OFF_FLAGS] = PP_BIT_IDP | PP_MSK_PSUM_MB;
3287
3288 result = write_mode_page(STp, PART_PAGE, 1);
3289 if (result) {
3290 printk(KERN_INFO "%s: Partitioning of tape failed.\n", name);
3291 result = (-EIO);
3292 }
3293
3294 return result;
3295}
3296
3297
3298
3299/* The ioctl command */
Kai Makisarafd66c1b2008-01-17 22:45:22 +02003300static long st_ioctl(struct file *file, unsigned int cmd_in, unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003301{
3302 int i, cmd_nr, cmd_type, bt;
3303 int retval = 0;
3304 unsigned int blk;
3305 struct scsi_tape *STp = file->private_data;
3306 struct st_modedef *STm;
3307 struct st_partstat *STps;
3308 char *name = tape_name(STp);
3309 void __user *p = (void __user *)arg;
3310
Matthias Kaehlcke28f85002007-07-29 23:38:15 +02003311 if (mutex_lock_interruptible(&STp->lock))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003312 return -ERESTARTSYS;
3313
3314 DEB(
3315 if (debugging && !STp->in_use) {
3316 printk(ST_DEB_MSG "%s: Incorrect device.\n", name);
3317 retval = (-EIO);
3318 goto out;
3319 } ) /* end DEB */
3320
3321 STm = &(STp->modes[STp->current_mode]);
3322 STps = &(STp->ps[STp->partition]);
3323
3324 /*
3325 * If we are in the middle of error recovery, don't let anyone
3326 * else try and use this device. Also, if error recovery fails, it
3327 * may try and take the device offline, in which case all further
3328 * access to the device is prohibited.
3329 */
Al Viro83ff6fe2008-03-02 08:15:49 -05003330 retval = scsi_nonblockable_ioctl(STp->device, cmd_in, p,
3331 file->f_flags & O_NDELAY);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003332 if (!scsi_block_when_processing_errors(STp->device) || retval != -ENODEV)
3333 goto out;
3334 retval = 0;
3335
3336 cmd_type = _IOC_TYPE(cmd_in);
3337 cmd_nr = _IOC_NR(cmd_in);
3338
3339 if (cmd_type == _IOC_TYPE(MTIOCTOP) && cmd_nr == _IOC_NR(MTIOCTOP)) {
3340 struct mtop mtc;
3341
3342 if (_IOC_SIZE(cmd_in) != sizeof(mtc)) {
3343 retval = (-EINVAL);
3344 goto out;
3345 }
3346
3347 i = copy_from_user(&mtc, p, sizeof(struct mtop));
3348 if (i) {
3349 retval = (-EFAULT);
3350 goto out;
3351 }
3352
3353 if (mtc.mt_op == MTSETDRVBUFFER && !capable(CAP_SYS_ADMIN)) {
3354 printk(KERN_WARNING
3355 "%s: MTSETDRVBUFFER only allowed for root.\n", name);
3356 retval = (-EPERM);
3357 goto out;
3358 }
3359 if (!STm->defined &&
3360 (mtc.mt_op != MTSETDRVBUFFER &&
3361 (mtc.mt_count & MT_ST_OPTIONS) == 0)) {
3362 retval = (-ENXIO);
3363 goto out;
3364 }
3365
3366 if (!STp->pos_unknown) {
3367
3368 if (STps->eof == ST_FM_HIT) {
3369 if (mtc.mt_op == MTFSF || mtc.mt_op == MTFSFM ||
3370 mtc.mt_op == MTEOM) {
3371 mtc.mt_count -= 1;
3372 if (STps->drv_file >= 0)
3373 STps->drv_file += 1;
3374 } else if (mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM) {
3375 mtc.mt_count += 1;
3376 if (STps->drv_file >= 0)
3377 STps->drv_file += 1;
3378 }
3379 }
3380
3381 if (mtc.mt_op == MTSEEK) {
3382 /* Old position must be restored if partition will be
3383 changed */
3384 i = !STp->can_partitions ||
3385 (STp->new_partition != STp->partition);
3386 } else {
3387 i = mtc.mt_op == MTREW || mtc.mt_op == MTOFFL ||
3388 mtc.mt_op == MTRETEN || mtc.mt_op == MTEOM ||
3389 mtc.mt_op == MTLOCK || mtc.mt_op == MTLOAD ||
3390 mtc.mt_op == MTFSF || mtc.mt_op == MTFSFM ||
3391 mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM ||
3392 mtc.mt_op == MTCOMPRESSION;
3393 }
3394 i = flush_buffer(STp, i);
3395 if (i < 0) {
3396 retval = i;
3397 goto out;
3398 }
3399 if (STps->rw == ST_WRITING &&
3400 (mtc.mt_op == MTREW || mtc.mt_op == MTOFFL ||
3401 mtc.mt_op == MTSEEK ||
3402 mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM)) {
3403 i = st_int_ioctl(STp, MTWEOF, 1);
3404 if (i < 0) {
3405 retval = i;
3406 goto out;
3407 }
3408 if (mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM)
3409 mtc.mt_count++;
3410 STps->rw = ST_IDLE;
3411 }
3412
3413 } else {
3414 /*
3415 * If there was a bus reset, block further access
3416 * to this device. If the user wants to rewind the tape,
3417 * then reset the flag and allow access again.
3418 */
3419 if (mtc.mt_op != MTREW &&
3420 mtc.mt_op != MTOFFL &&
3421 mtc.mt_op != MTRETEN &&
3422 mtc.mt_op != MTERASE &&
3423 mtc.mt_op != MTSEEK &&
3424 mtc.mt_op != MTEOM) {
3425 retval = (-EIO);
3426 goto out;
3427 }
3428 reset_state(STp);
3429 /* remove this when the midlevel properly clears was_reset */
3430 STp->device->was_reset = 0;
3431 }
3432
3433 if (mtc.mt_op != MTNOP && mtc.mt_op != MTSETBLK &&
3434 mtc.mt_op != MTSETDENSITY && mtc.mt_op != MTWSM &&
3435 mtc.mt_op != MTSETDRVBUFFER && mtc.mt_op != MTSETPART)
3436 STps->rw = ST_IDLE; /* Prevent automatic WEOF and fsf */
3437
3438 if (mtc.mt_op == MTOFFL && STp->door_locked != ST_UNLOCKED)
3439 do_door_lock(STp, 0); /* Ignore result! */
3440
3441 if (mtc.mt_op == MTSETDRVBUFFER &&
3442 (mtc.mt_count & MT_ST_OPTIONS) != 0) {
3443 retval = st_set_options(STp, mtc.mt_count);
3444 goto out;
3445 }
3446
3447 if (mtc.mt_op == MTSETPART) {
3448 if (!STp->can_partitions ||
3449 mtc.mt_count < 0 || mtc.mt_count >= ST_NBR_PARTITIONS) {
3450 retval = (-EINVAL);
3451 goto out;
3452 }
3453 if (mtc.mt_count >= STp->nbr_partitions &&
3454 (STp->nbr_partitions = nbr_partitions(STp)) < 0) {
3455 retval = (-EIO);
3456 goto out;
3457 }
3458 if (mtc.mt_count >= STp->nbr_partitions) {
3459 retval = (-EINVAL);
3460 goto out;
3461 }
3462 STp->new_partition = mtc.mt_count;
3463 retval = 0;
3464 goto out;
3465 }
3466
3467 if (mtc.mt_op == MTMKPART) {
3468 if (!STp->can_partitions) {
3469 retval = (-EINVAL);
3470 goto out;
3471 }
3472 if ((i = st_int_ioctl(STp, MTREW, 0)) < 0 ||
3473 (i = partition_tape(STp, mtc.mt_count)) < 0) {
3474 retval = i;
3475 goto out;
3476 }
3477 for (i = 0; i < ST_NBR_PARTITIONS; i++) {
3478 STp->ps[i].rw = ST_IDLE;
3479 STp->ps[i].at_sm = 0;
3480 STp->ps[i].last_block_valid = 0;
3481 }
3482 STp->partition = STp->new_partition = 0;
3483 STp->nbr_partitions = 1; /* Bad guess ?-) */
3484 STps->drv_block = STps->drv_file = 0;
3485 retval = 0;
3486 goto out;
3487 }
3488
3489 if (mtc.mt_op == MTSEEK) {
3490 i = set_location(STp, mtc.mt_count, STp->new_partition, 0);
3491 if (!STp->can_partitions)
3492 STp->ps[0].rw = ST_IDLE;
3493 retval = i;
3494 goto out;
3495 }
3496
3497 if (mtc.mt_op == MTUNLOAD || mtc.mt_op == MTOFFL) {
3498 retval = do_load_unload(STp, file, 0);
3499 goto out;
3500 }
3501
3502 if (mtc.mt_op == MTLOAD) {
3503 retval = do_load_unload(STp, file, max(1, mtc.mt_count));
3504 goto out;
3505 }
3506
3507 if (mtc.mt_op == MTLOCK || mtc.mt_op == MTUNLOCK) {
3508 retval = do_door_lock(STp, (mtc.mt_op == MTLOCK));
3509 goto out;
3510 }
3511
3512 if (STp->can_partitions && STp->ready == ST_READY &&
3513 (i = switch_partition(STp)) < 0) {
3514 retval = i;
3515 goto out;
3516 }
3517
3518 if (mtc.mt_op == MTCOMPRESSION)
3519 retval = st_compression(STp, (mtc.mt_count & 1));
3520 else
3521 retval = st_int_ioctl(STp, mtc.mt_op, mtc.mt_count);
3522 goto out;
3523 }
3524 if (!STm->defined) {
3525 retval = (-ENXIO);
3526 goto out;
3527 }
3528
3529 if ((i = flush_buffer(STp, 0)) < 0) {
3530 retval = i;
3531 goto out;
3532 }
3533 if (STp->can_partitions &&
3534 (i = switch_partition(STp)) < 0) {
3535 retval = i;
3536 goto out;
3537 }
3538
3539 if (cmd_type == _IOC_TYPE(MTIOCGET) && cmd_nr == _IOC_NR(MTIOCGET)) {
3540 struct mtget mt_status;
3541
3542 if (_IOC_SIZE(cmd_in) != sizeof(struct mtget)) {
3543 retval = (-EINVAL);
3544 goto out;
3545 }
3546
3547 mt_status.mt_type = STp->tape_type;
3548 mt_status.mt_dsreg =
3549 ((STp->block_size << MT_ST_BLKSIZE_SHIFT) & MT_ST_BLKSIZE_MASK) |
3550 ((STp->density << MT_ST_DENSITY_SHIFT) & MT_ST_DENSITY_MASK);
3551 mt_status.mt_blkno = STps->drv_block;
3552 mt_status.mt_fileno = STps->drv_file;
3553 if (STp->block_size != 0) {
3554 if (STps->rw == ST_WRITING)
3555 mt_status.mt_blkno +=
3556 (STp->buffer)->buffer_bytes / STp->block_size;
3557 else if (STps->rw == ST_READING)
3558 mt_status.mt_blkno -=
3559 ((STp->buffer)->buffer_bytes +
3560 STp->block_size - 1) / STp->block_size;
3561 }
3562
3563 mt_status.mt_gstat = 0;
3564 if (STp->drv_write_prot)
3565 mt_status.mt_gstat |= GMT_WR_PROT(0xffffffff);
3566 if (mt_status.mt_blkno == 0) {
3567 if (mt_status.mt_fileno == 0)
3568 mt_status.mt_gstat |= GMT_BOT(0xffffffff);
3569 else
3570 mt_status.mt_gstat |= GMT_EOF(0xffffffff);
3571 }
3572 mt_status.mt_erreg = (STp->recover_reg << MT_ST_SOFTERR_SHIFT);
3573 mt_status.mt_resid = STp->partition;
3574 if (STps->eof == ST_EOM_OK || STps->eof == ST_EOM_ERROR)
3575 mt_status.mt_gstat |= GMT_EOT(0xffffffff);
3576 else if (STps->eof >= ST_EOM_OK)
3577 mt_status.mt_gstat |= GMT_EOD(0xffffffff);
3578 if (STp->density == 1)
3579 mt_status.mt_gstat |= GMT_D_800(0xffffffff);
3580 else if (STp->density == 2)
3581 mt_status.mt_gstat |= GMT_D_1600(0xffffffff);
3582 else if (STp->density == 3)
3583 mt_status.mt_gstat |= GMT_D_6250(0xffffffff);
3584 if (STp->ready == ST_READY)
3585 mt_status.mt_gstat |= GMT_ONLINE(0xffffffff);
3586 if (STp->ready == ST_NO_TAPE)
3587 mt_status.mt_gstat |= GMT_DR_OPEN(0xffffffff);
3588 if (STps->at_sm)
3589 mt_status.mt_gstat |= GMT_SM(0xffffffff);
3590 if (STm->do_async_writes ||
3591 (STm->do_buffer_writes && STp->block_size != 0) ||
3592 STp->drv_buffer != 0)
3593 mt_status.mt_gstat |= GMT_IM_REP_EN(0xffffffff);
3594 if (STp->cleaning_req)
3595 mt_status.mt_gstat |= GMT_CLN(0xffffffff);
3596
3597 i = copy_to_user(p, &mt_status, sizeof(struct mtget));
3598 if (i) {
3599 retval = (-EFAULT);
3600 goto out;
3601 }
3602
3603 STp->recover_reg = 0; /* Clear after read */
3604 retval = 0;
3605 goto out;
3606 } /* End of MTIOCGET */
3607 if (cmd_type == _IOC_TYPE(MTIOCPOS) && cmd_nr == _IOC_NR(MTIOCPOS)) {
3608 struct mtpos mt_pos;
3609 if (_IOC_SIZE(cmd_in) != sizeof(struct mtpos)) {
3610 retval = (-EINVAL);
3611 goto out;
3612 }
3613 if ((i = get_location(STp, &blk, &bt, 0)) < 0) {
3614 retval = i;
3615 goto out;
3616 }
3617 mt_pos.mt_blkno = blk;
3618 i = copy_to_user(p, &mt_pos, sizeof(struct mtpos));
3619 if (i)
3620 retval = (-EFAULT);
3621 goto out;
3622 }
Matthias Kaehlcke28f85002007-07-29 23:38:15 +02003623 mutex_unlock(&STp->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003624 switch (cmd_in) {
3625 case SCSI_IOCTL_GET_IDLUN:
3626 case SCSI_IOCTL_GET_BUS_NUMBER:
3627 break;
3628 default:
Kai Makisara 16c4b3e2005-05-01 18:11:55 +03003629 if ((cmd_in == SG_IO ||
3630 cmd_in == SCSI_IOCTL_SEND_COMMAND ||
3631 cmd_in == CDROM_SEND_PACKET) &&
3632 !capable(CAP_SYS_RAWIO))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003633 i = -EPERM;
3634 else
Al Viro74f3c8a2007-08-27 15:38:10 -04003635 i = scsi_cmd_ioctl(STp->disk->queue, STp->disk,
3636 file->f_mode, cmd_in, p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003637 if (i != -ENOTTY)
3638 return i;
3639 break;
3640 }
Kai Makisara 16c4b3e2005-05-01 18:11:55 +03003641 retval = scsi_ioctl(STp->device, cmd_in, p);
3642 if (!retval && cmd_in == SCSI_IOCTL_STOP_UNIT) { /* unload */
3643 STp->rew_at_close = 0;
3644 STp->ready = ST_NO_TAPE;
3645 }
3646 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003647
3648 out:
Matthias Kaehlcke28f85002007-07-29 23:38:15 +02003649 mutex_unlock(&STp->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003650 return retval;
3651}
3652
3653#ifdef CONFIG_COMPAT
3654static long st_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
3655{
3656 struct scsi_tape *STp = file->private_data;
3657 struct scsi_device *sdev = STp->device;
3658 int ret = -ENOIOCTLCMD;
3659 if (sdev->host->hostt->compat_ioctl) {
3660
3661 ret = sdev->host->hostt->compat_ioctl(sdev, cmd, (void __user *)arg);
3662
3663 }
3664 return ret;
3665}
3666#endif
3667
3668
3669
3670/* Try to allocate a new tape buffer. Calling function must not hold
3671 dev_arr_lock. */
FUJITA Tomonorif409d6c2008-12-18 14:49:47 +09003672static struct st_buffer *new_tape_buffer(int need_dma, int max_sg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003673{
Linus Torvalds1da177e2005-04-16 15:20:36 -07003674 struct st_buffer *tb;
3675
FUJITA Tomonorif409d6c2008-12-18 14:49:47 +09003676 tb = kzalloc(sizeof(struct st_buffer), GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003677 if (!tb) {
3678 printk(KERN_NOTICE "st: Can't allocate new tape buffer.\n");
3679 return NULL;
3680 }
FUJITA Tomonori1ac63cf2008-12-18 14:49:48 +09003681 tb->frp_segs = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003682 tb->use_sg = max_sg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003683 tb->dma = need_dma;
FUJITA Tomonorif409d6c2008-12-18 14:49:47 +09003684 tb->buffer_size = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003685
FUJITA Tomonorif409d6c2008-12-18 14:49:47 +09003686 tb->reserved_pages = kzalloc(max_sg * sizeof(struct page *),
3687 GFP_ATOMIC);
FUJITA Tomonorid0e1ae32008-12-18 14:49:40 +09003688 if (!tb->reserved_pages) {
3689 kfree(tb);
3690 return NULL;
3691 }
3692
Linus Torvalds1da177e2005-04-16 15:20:36 -07003693 return tb;
3694}
3695
3696
3697/* Try to allocate enough space in the tape buffer */
Kai Makisara8f78fc52008-12-18 14:49:51 +09003698#define ST_MAX_ORDER 6
3699
Linus Torvalds1da177e2005-04-16 15:20:36 -07003700static int enlarge_buffer(struct st_buffer * STbuffer, int new_size, int need_dma)
3701{
Al Viroc53033f2005-10-21 03:22:08 -04003702 int segs, nbr, max_segs, b_size, order, got;
3703 gfp_t priority;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003704
3705 if (new_size <= STbuffer->buffer_size)
3706 return 1;
3707
3708 if (STbuffer->buffer_size <= PAGE_SIZE)
3709 normalize_buffer(STbuffer); /* Avoid extra segment */
3710
3711 max_segs = STbuffer->use_sg;
3712 nbr = max_segs - STbuffer->frp_segs;
3713 if (nbr <= 0)
3714 return 0;
3715
3716 priority = GFP_KERNEL | __GFP_NOWARN;
3717 if (need_dma)
3718 priority |= GFP_DMA;
FUJITA Tomonori9c905962008-12-18 14:49:39 +09003719
FUJITA Tomonori08c95832008-12-18 14:49:45 +09003720 if (STbuffer->cleared)
3721 priority |= __GFP_ZERO;
3722
FUJITA Tomonori9c905962008-12-18 14:49:39 +09003723 if (STbuffer->frp_segs) {
FUJITA Tomonoric982c362009-11-26 09:24:13 +09003724 order = STbuffer->reserved_page_order;
FUJITA Tomonori08c95832008-12-18 14:49:45 +09003725 b_size = PAGE_SIZE << order;
FUJITA Tomonori9c905962008-12-18 14:49:39 +09003726 } else {
3727 for (b_size = PAGE_SIZE, order = 0;
Kai Makisara8f78fc52008-12-18 14:49:51 +09003728 order < ST_MAX_ORDER && b_size < new_size;
3729 order++, b_size *= 2)
FUJITA Tomonori9c905962008-12-18 14:49:39 +09003730 ; /* empty */
3731 }
Kai Makisara8f78fc52008-12-18 14:49:51 +09003732 if (max_segs * (PAGE_SIZE << order) < new_size) {
3733 if (order == ST_MAX_ORDER)
3734 return 0;
3735 normalize_buffer(STbuffer);
3736 return enlarge_buffer(STbuffer, new_size, need_dma);
3737 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003738
3739 for (segs = STbuffer->frp_segs, got = STbuffer->buffer_size;
3740 segs < max_segs && got < new_size;) {
FUJITA Tomonori08c95832008-12-18 14:49:45 +09003741 struct page *page;
3742
3743 page = alloc_pages(priority, order);
3744 if (!page) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003745 DEB(STbuffer->buffer_size = got);
3746 normalize_buffer(STbuffer);
3747 return 0;
3748 }
FUJITA Tomonori08c95832008-12-18 14:49:45 +09003749
Linus Torvalds1da177e2005-04-16 15:20:36 -07003750 STbuffer->frp_segs += 1;
3751 got += b_size;
3752 STbuffer->buffer_size = got;
FUJITA Tomonori08c95832008-12-18 14:49:45 +09003753 STbuffer->reserved_pages[segs] = page;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003754 segs++;
3755 }
FUJITA Tomonori08c95832008-12-18 14:49:45 +09003756 STbuffer->b_data = page_address(STbuffer->reserved_pages[0]);
FUJITA Tomonoric982c362009-11-26 09:24:13 +09003757 STbuffer->reserved_page_order = order;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003758
3759 return 1;
3760}
3761
3762
Kai Makisara40f6b362008-02-24 22:23:24 +02003763/* Make sure that no data from previous user is in the internal buffer */
3764static void clear_buffer(struct st_buffer * st_bp)
3765{
3766 int i;
3767
3768 for (i=0; i < st_bp->frp_segs; i++)
FUJITA Tomonori08c95832008-12-18 14:49:45 +09003769 memset(page_address(st_bp->reserved_pages[i]), 0,
FUJITA Tomonoric982c362009-11-26 09:24:13 +09003770 PAGE_SIZE << st_bp->reserved_page_order);
Kai Makisara40f6b362008-02-24 22:23:24 +02003771 st_bp->cleared = 1;
3772}
3773
3774
Linus Torvalds1da177e2005-04-16 15:20:36 -07003775/* Release the extra buffer */
3776static void normalize_buffer(struct st_buffer * STbuffer)
3777{
FUJITA Tomonoric982c362009-11-26 09:24:13 +09003778 int i, order = STbuffer->reserved_page_order;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003779
FUJITA Tomonori1ac63cf2008-12-18 14:49:48 +09003780 for (i = 0; i < STbuffer->frp_segs; i++) {
FUJITA Tomonori08c95832008-12-18 14:49:45 +09003781 __free_pages(STbuffer->reserved_pages[i], order);
3782 STbuffer->buffer_size -= (PAGE_SIZE << order);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003783 }
FUJITA Tomonori1ac63cf2008-12-18 14:49:48 +09003784 STbuffer->frp_segs = 0;
Mike Christie8b05b772005-11-08 04:06:44 -06003785 STbuffer->sg_segs = 0;
FUJITA Tomonoric982c362009-11-26 09:24:13 +09003786 STbuffer->reserved_page_order = 0;
FUJITA Tomonorid0e1ae32008-12-18 14:49:40 +09003787 STbuffer->map_data.offset = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003788}
3789
3790
3791/* Move data from the user buffer to the tape buffer. Returns zero (success) or
3792 negative error code. */
3793static int append_to_buffer(const char __user *ubp, struct st_buffer * st_bp, int do_count)
3794{
3795 int i, cnt, res, offset;
FUJITA Tomonoric982c362009-11-26 09:24:13 +09003796 int length = PAGE_SIZE << st_bp->reserved_page_order;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003797
3798 for (i = 0, offset = st_bp->buffer_bytes;
FUJITA Tomonori08c95832008-12-18 14:49:45 +09003799 i < st_bp->frp_segs && offset >= length; i++)
3800 offset -= length;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003801 if (i == st_bp->frp_segs) { /* Should never happen */
3802 printk(KERN_WARNING "st: append_to_buffer offset overflow.\n");
3803 return (-EIO);
3804 }
3805 for (; i < st_bp->frp_segs && do_count > 0; i++) {
FUJITA Tomonori08c95832008-12-18 14:49:45 +09003806 struct page *page = st_bp->reserved_pages[i];
3807 cnt = length - offset < do_count ? length - offset : do_count;
3808 res = copy_from_user(page_address(page) + offset, ubp, cnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003809 if (res)
3810 return (-EFAULT);
3811 do_count -= cnt;
3812 st_bp->buffer_bytes += cnt;
3813 ubp += cnt;
3814 offset = 0;
3815 }
3816 if (do_count) /* Should never happen */
3817 return (-EIO);
3818
3819 return 0;
3820}
3821
3822
3823/* Move data from the tape buffer to the user buffer. Returns zero (success) or
3824 negative error code. */
3825static int from_buffer(struct st_buffer * st_bp, char __user *ubp, int do_count)
3826{
3827 int i, cnt, res, offset;
FUJITA Tomonoric982c362009-11-26 09:24:13 +09003828 int length = PAGE_SIZE << st_bp->reserved_page_order;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003829
3830 for (i = 0, offset = st_bp->read_pointer;
FUJITA Tomonori08c95832008-12-18 14:49:45 +09003831 i < st_bp->frp_segs && offset >= length; i++)
3832 offset -= length;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003833 if (i == st_bp->frp_segs) { /* Should never happen */
3834 printk(KERN_WARNING "st: from_buffer offset overflow.\n");
3835 return (-EIO);
3836 }
3837 for (; i < st_bp->frp_segs && do_count > 0; i++) {
FUJITA Tomonori08c95832008-12-18 14:49:45 +09003838 struct page *page = st_bp->reserved_pages[i];
3839 cnt = length - offset < do_count ? length - offset : do_count;
3840 res = copy_to_user(ubp, page_address(page) + offset, cnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003841 if (res)
3842 return (-EFAULT);
3843 do_count -= cnt;
3844 st_bp->buffer_bytes -= cnt;
3845 st_bp->read_pointer += cnt;
3846 ubp += cnt;
3847 offset = 0;
3848 }
3849 if (do_count) /* Should never happen */
3850 return (-EIO);
3851
3852 return 0;
3853}
3854
3855
3856/* Move data towards start of buffer */
3857static void move_buffer_data(struct st_buffer * st_bp, int offset)
3858{
3859 int src_seg, dst_seg, src_offset = 0, dst_offset;
3860 int count, total;
FUJITA Tomonoric982c362009-11-26 09:24:13 +09003861 int length = PAGE_SIZE << st_bp->reserved_page_order;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003862
3863 if (offset == 0)
3864 return;
3865
3866 total=st_bp->buffer_bytes - offset;
3867 for (src_seg=0; src_seg < st_bp->frp_segs; src_seg++) {
3868 src_offset = offset;
FUJITA Tomonori08c95832008-12-18 14:49:45 +09003869 if (src_offset < length)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003870 break;
FUJITA Tomonori08c95832008-12-18 14:49:45 +09003871 offset -= length;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003872 }
3873
3874 st_bp->buffer_bytes = st_bp->read_pointer = total;
3875 for (dst_seg=dst_offset=0; total > 0; ) {
FUJITA Tomonori08c95832008-12-18 14:49:45 +09003876 struct page *dpage = st_bp->reserved_pages[dst_seg];
3877 struct page *spage = st_bp->reserved_pages[src_seg];
3878
3879 count = min(length - dst_offset, length - src_offset);
3880 memmove(page_address(dpage) + dst_offset,
3881 page_address(spage) + src_offset, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003882 src_offset += count;
FUJITA Tomonori08c95832008-12-18 14:49:45 +09003883 if (src_offset >= length) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003884 src_seg++;
3885 src_offset = 0;
3886 }
3887 dst_offset += count;
FUJITA Tomonori08c95832008-12-18 14:49:45 +09003888 if (dst_offset >= length) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003889 dst_seg++;
3890 dst_offset = 0;
3891 }
3892 total -= count;
3893 }
3894}
3895
Linus Torvalds1da177e2005-04-16 15:20:36 -07003896/* Validate the options from command line or module parameters */
3897static void validate_options(void)
3898{
3899 if (buffer_kbs > 0)
3900 st_fixed_buffer_size = buffer_kbs * ST_KILOBYTE;
3901 if (max_sg_segs >= ST_FIRST_SG)
3902 st_max_sg_segs = max_sg_segs;
3903}
3904
3905#ifndef MODULE
3906/* Set the boot options. Syntax is defined in Documenation/scsi/st.txt.
3907 */
3908static int __init st_setup(char *str)
3909{
3910 int i, len, ints[5];
3911 char *stp;
3912
3913 stp = get_options(str, ARRAY_SIZE(ints), ints);
3914
3915 if (ints[0] > 0) {
3916 for (i = 0; i < ints[0] && i < ARRAY_SIZE(parms); i++)
3917 if (parms[i].val)
3918 *parms[i].val = ints[i + 1];
3919 } else {
3920 while (stp != NULL) {
3921 for (i = 0; i < ARRAY_SIZE(parms); i++) {
3922 len = strlen(parms[i].name);
3923 if (!strncmp(stp, parms[i].name, len) &&
3924 (*(stp + len) == ':' || *(stp + len) == '=')) {
3925 if (parms[i].val)
3926 *parms[i].val =
3927 simple_strtoul(stp + len + 1, NULL, 0);
3928 else
3929 printk(KERN_WARNING "st: Obsolete parameter %s\n",
3930 parms[i].name);
3931 break;
3932 }
3933 }
Tobias Klauser6391a112006-06-08 22:23:48 -07003934 if (i >= ARRAY_SIZE(parms))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003935 printk(KERN_WARNING "st: invalid parameter in '%s'\n",
3936 stp);
3937 stp = strchr(stp, ',');
3938 if (stp)
3939 stp++;
3940 }
3941 }
3942
3943 validate_options();
3944
3945 return 1;
3946}
3947
3948__setup("st=", st_setup);
3949
3950#endif
3951
Arjan van de Ven00977a52007-02-12 00:55:34 -08003952static const struct file_operations st_fops =
Linus Torvalds1da177e2005-04-16 15:20:36 -07003953{
3954 .owner = THIS_MODULE,
3955 .read = st_read,
3956 .write = st_write,
Kai Makisarafd66c1b2008-01-17 22:45:22 +02003957 .unlocked_ioctl = st_ioctl,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003958#ifdef CONFIG_COMPAT
3959 .compat_ioctl = st_compat_ioctl,
3960#endif
3961 .open = st_open,
3962 .flush = st_flush,
3963 .release = st_release,
3964};
3965
3966static int st_probe(struct device *dev)
3967{
3968 struct scsi_device *SDp = to_scsi_device(dev);
3969 struct gendisk *disk = NULL;
3970 struct cdev *cdev = NULL;
3971 struct scsi_tape *tpnt = NULL;
3972 struct st_modedef *STm;
3973 struct st_partstat *STps;
3974 struct st_buffer *buffer;
3975 int i, j, mode, dev_num, error;
3976 char *stp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003977
3978 if (SDp->type != TYPE_TAPE)
3979 return -ENODEV;
3980 if ((stp = st_incompatible(SDp))) {
Jeff Garzik3bf743e2005-10-24 18:04:06 -04003981 sdev_printk(KERN_INFO, SDp, "Found incompatible tape\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003982 printk(KERN_INFO "st: The suggested driver is %s.\n", stp);
3983 return -ENODEV;
3984 }
3985
Martin K. Petersenae03bf62009-05-22 17:17:50 -04003986 i = min(queue_max_hw_segments(SDp->request_queue),
3987 queue_max_phys_segments(SDp->request_queue));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003988 if (st_max_sg_segs < i)
3989 i = st_max_sg_segs;
FUJITA Tomonorif409d6c2008-12-18 14:49:47 +09003990 buffer = new_tape_buffer((SDp->host)->unchecked_isa_dma, i);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003991 if (buffer == NULL) {
3992 printk(KERN_ERR
3993 "st: Can't allocate new tape buffer. Device not attached.\n");
3994 goto out;
3995 }
3996
3997 disk = alloc_disk(1);
3998 if (!disk) {
3999 printk(KERN_ERR "st: out of memory. Device not attached.\n");
4000 goto out_buffer_free;
4001 }
4002
4003 write_lock(&st_dev_arr_lock);
4004 if (st_nr_dev >= st_dev_max) {
4005 struct scsi_tape **tmp_da;
4006 int tmp_dev_max;
4007
4008 tmp_dev_max = max(st_nr_dev * 2, 8);
4009 if (tmp_dev_max > ST_MAX_TAPES)
4010 tmp_dev_max = ST_MAX_TAPES;
4011 if (tmp_dev_max <= st_nr_dev) {
4012 write_unlock(&st_dev_arr_lock);
4013 printk(KERN_ERR "st: Too many tape devices (max. %d).\n",
4014 ST_MAX_TAPES);
4015 goto out_put_disk;
4016 }
4017
Jes Sorensen24669f752006-01-16 10:31:18 -05004018 tmp_da = kzalloc(tmp_dev_max * sizeof(struct scsi_tape *), GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004019 if (tmp_da == NULL) {
4020 write_unlock(&st_dev_arr_lock);
4021 printk(KERN_ERR "st: Can't extend device array.\n");
4022 goto out_put_disk;
4023 }
4024
Linus Torvalds1da177e2005-04-16 15:20:36 -07004025 if (scsi_tapes != NULL) {
4026 memcpy(tmp_da, scsi_tapes,
4027 st_dev_max * sizeof(struct scsi_tape *));
4028 kfree(scsi_tapes);
4029 }
4030 scsi_tapes = tmp_da;
4031
4032 st_dev_max = tmp_dev_max;
4033 }
4034
4035 for (i = 0; i < st_dev_max; i++)
4036 if (scsi_tapes[i] == NULL)
4037 break;
4038 if (i >= st_dev_max)
4039 panic("scsi_devices corrupt (st)");
4040
Jes Sorensen24669f752006-01-16 10:31:18 -05004041 tpnt = kzalloc(sizeof(struct scsi_tape), GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004042 if (tpnt == NULL) {
4043 write_unlock(&st_dev_arr_lock);
4044 printk(KERN_ERR "st: Can't allocate device descriptor.\n");
4045 goto out_put_disk;
4046 }
Kai Makisaraf03a5672005-08-02 13:40:47 +03004047 kref_init(&tpnt->kref);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004048 tpnt->disk = disk;
4049 sprintf(disk->disk_name, "st%d", i);
4050 disk->private_data = &tpnt->driver;
4051 disk->queue = SDp->request_queue;
4052 tpnt->driver = &st_template;
4053 scsi_tapes[i] = tpnt;
4054 dev_num = i;
4055
4056 tpnt->device = SDp;
4057 if (SDp->scsi_level <= 2)
4058 tpnt->tape_type = MT_ISSCSI1;
4059 else
4060 tpnt->tape_type = MT_ISSCSI2;
4061
4062 tpnt->buffer = buffer;
Kai Makisaraf03a5672005-08-02 13:40:47 +03004063 tpnt->buffer->last_SRpnt = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004064
4065 tpnt->inited = 0;
4066 tpnt->dirty = 0;
4067 tpnt->in_use = 0;
4068 tpnt->drv_buffer = 1; /* Try buffering if no mode sense */
4069 tpnt->restr_dma = (SDp->host)->unchecked_isa_dma;
4070 tpnt->use_pf = (SDp->scsi_level >= SCSI_2);
4071 tpnt->density = 0;
4072 tpnt->do_auto_lock = ST_AUTO_LOCK;
4073 tpnt->can_bsr = (SDp->scsi_level > 2 ? 1 : ST_IN_FILE_POS); /* BSR mandatory in SCSI3 */
4074 tpnt->can_partitions = 0;
4075 tpnt->two_fm = ST_TWO_FM;
4076 tpnt->fast_mteom = ST_FAST_MTEOM;
4077 tpnt->scsi2_logical = ST_SCSI2LOGICAL;
Kai Makisara40f6b362008-02-24 22:23:24 +02004078 tpnt->sili = ST_SILI;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004079 tpnt->immediate = ST_NOWAIT;
4080 tpnt->default_drvbuffer = 0xff; /* No forced buffering */
4081 tpnt->partition = 0;
4082 tpnt->new_partition = 0;
4083 tpnt->nbr_partitions = 0;
James Bottomleya02488e2008-11-30 10:36:26 -06004084 blk_queue_rq_timeout(tpnt->device->request_queue, ST_TIMEOUT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004085 tpnt->long_timeout = ST_LONG_TIMEOUT;
4086 tpnt->try_dio = try_direct_io && !SDp->host->unchecked_isa_dma;
4087
Linus Torvalds1da177e2005-04-16 15:20:36 -07004088 for (i = 0; i < ST_NBR_MODES; i++) {
4089 STm = &(tpnt->modes[i]);
4090 STm->defined = 0;
4091 STm->sysv = ST_SYSV;
4092 STm->defaults_for_writes = 0;
4093 STm->do_async_writes = ST_ASYNC_WRITES;
4094 STm->do_buffer_writes = ST_BUFFER_WRITES;
4095 STm->do_read_ahead = ST_READ_AHEAD;
4096 STm->default_compression = ST_DONT_TOUCH;
4097 STm->default_blksize = (-1); /* No forced size */
4098 STm->default_density = (-1); /* No forced density */
4099 }
4100
4101 for (i = 0; i < ST_NBR_PARTITIONS; i++) {
4102 STps = &(tpnt->ps[i]);
4103 STps->rw = ST_IDLE;
4104 STps->eof = ST_NOEOF;
4105 STps->at_sm = 0;
4106 STps->last_block_valid = 0;
4107 STps->drv_block = (-1);
4108 STps->drv_file = (-1);
4109 }
4110
4111 tpnt->current_mode = 0;
4112 tpnt->modes[0].defined = 1;
4113
4114 tpnt->density_changed = tpnt->compression_changed =
4115 tpnt->blksize_changed = 0;
Matthias Kaehlcke28f85002007-07-29 23:38:15 +02004116 mutex_init(&tpnt->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004117
4118 st_nr_dev++;
4119 write_unlock(&st_dev_arr_lock);
4120
4121 for (mode = 0; mode < ST_NBR_MODES; ++mode) {
4122 STm = &(tpnt->modes[mode]);
4123 for (j=0; j < 2; j++) {
4124 cdev = cdev_alloc();
4125 if (!cdev) {
4126 printk(KERN_ERR
4127 "st%d: out of memory. Device not attached.\n",
4128 dev_num);
4129 goto out_free_tape;
4130 }
4131 cdev->owner = THIS_MODULE;
4132 cdev->ops = &st_fops;
4133
4134 error = cdev_add(cdev,
4135 MKDEV(SCSI_TAPE_MAJOR, TAPE_MINOR(dev_num, mode, j)),
4136 1);
4137 if (error) {
4138 printk(KERN_ERR "st%d: Can't add %s-rewind mode %d\n",
4139 dev_num, j ? "non" : "auto", mode);
4140 printk(KERN_ERR "st%d: Device not attached.\n", dev_num);
4141 goto out_free_tape;
4142 }
4143 STm->cdevs[j] = cdev;
4144
4145 }
Jeff Garzik13026a62006-10-04 06:00:38 -04004146 error = do_create_class_files(tpnt, dev_num, mode);
4147 if (error)
4148 goto out_free_tape;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004149 }
4150
Kai Makisara42252852006-11-07 21:56:38 +02004151 sdev_printk(KERN_NOTICE, SDp,
Rene Herman8b1ea242006-05-20 15:00:22 -07004152 "Attached scsi tape %s\n", tape_name(tpnt));
Kai Makisara42252852006-11-07 21:56:38 +02004153 sdev_printk(KERN_INFO, SDp, "%s: try direct i/o: %s (alignment %d B)\n",
4154 tape_name(tpnt), tpnt->try_dio ? "yes" : "no",
4155 queue_dma_alignment(SDp->request_queue) + 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004156
4157 return 0;
4158
4159out_free_tape:
4160 for (mode=0; mode < ST_NBR_MODES; mode++) {
4161 STm = &(tpnt->modes[mode]);
4162 sysfs_remove_link(&tpnt->device->sdev_gendev.kobj,
4163 "tape");
4164 for (j=0; j < 2; j++) {
4165 if (STm->cdevs[j]) {
4166 if (cdev == STm->cdevs[j])
4167 cdev = NULL;
Tony Jonesee959b02008-02-22 00:13:36 +01004168 device_destroy(st_sysfs_class,
4169 MKDEV(SCSI_TAPE_MAJOR,
4170 TAPE_MINOR(i, mode, j)));
Linus Torvalds1da177e2005-04-16 15:20:36 -07004171 cdev_del(STm->cdevs[j]);
4172 }
4173 }
4174 }
4175 if (cdev)
4176 cdev_del(cdev);
4177 write_lock(&st_dev_arr_lock);
4178 scsi_tapes[dev_num] = NULL;
4179 st_nr_dev--;
4180 write_unlock(&st_dev_arr_lock);
4181out_put_disk:
4182 put_disk(disk);
Jesper Juhlc9475cb2005-11-07 01:01:26 -08004183 kfree(tpnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004184out_buffer_free:
4185 kfree(buffer);
4186out:
4187 return -ENODEV;
4188};
4189
4190
4191static int st_remove(struct device *dev)
4192{
4193 struct scsi_device *SDp = to_scsi_device(dev);
4194 struct scsi_tape *tpnt;
4195 int i, j, mode;
4196
4197 write_lock(&st_dev_arr_lock);
4198 for (i = 0; i < st_dev_max; i++) {
4199 tpnt = scsi_tapes[i];
4200 if (tpnt != NULL && tpnt->device == SDp) {
4201 scsi_tapes[i] = NULL;
4202 st_nr_dev--;
4203 write_unlock(&st_dev_arr_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004204 sysfs_remove_link(&tpnt->device->sdev_gendev.kobj,
4205 "tape");
4206 for (mode = 0; mode < ST_NBR_MODES; ++mode) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004207 for (j=0; j < 2; j++) {
Tony Jonesee959b02008-02-22 00:13:36 +01004208 device_destroy(st_sysfs_class,
4209 MKDEV(SCSI_TAPE_MAJOR,
4210 TAPE_MINOR(i, mode, j)));
Linus Torvalds1da177e2005-04-16 15:20:36 -07004211 cdev_del(tpnt->modes[mode].cdevs[j]);
4212 tpnt->modes[mode].cdevs[j] = NULL;
4213 }
4214 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004215
Arjan van de Ven0b950672006-01-11 13:16:10 +01004216 mutex_lock(&st_ref_mutex);
Kai Makisaraf03a5672005-08-02 13:40:47 +03004217 kref_put(&tpnt->kref, scsi_tape_release);
Arjan van de Ven0b950672006-01-11 13:16:10 +01004218 mutex_unlock(&st_ref_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004219 return 0;
4220 }
4221 }
4222
4223 write_unlock(&st_dev_arr_lock);
4224 return 0;
4225}
4226
Kai Makisaraf03a5672005-08-02 13:40:47 +03004227/**
4228 * scsi_tape_release - Called to free the Scsi_Tape structure
4229 * @kref: pointer to embedded kref
4230 *
Arjan van de Ven0b950672006-01-11 13:16:10 +01004231 * st_ref_mutex must be held entering this routine. Because it is
Kai Makisaraf03a5672005-08-02 13:40:47 +03004232 * called on last put, you should always use the scsi_tape_get()
4233 * scsi_tape_put() helpers which manipulate the semaphore directly
4234 * and never do a direct kref_put().
4235 **/
4236static void scsi_tape_release(struct kref *kref)
4237{
4238 struct scsi_tape *tpnt = to_scsi_tape(kref);
4239 struct gendisk *disk = tpnt->disk;
4240
4241 tpnt->device = NULL;
4242
4243 if (tpnt->buffer) {
Kai Makisaraf03a5672005-08-02 13:40:47 +03004244 normalize_buffer(tpnt->buffer);
FUJITA Tomonorid0e1ae32008-12-18 14:49:40 +09004245 kfree(tpnt->buffer->reserved_pages);
Kai Makisaraf03a5672005-08-02 13:40:47 +03004246 kfree(tpnt->buffer);
4247 }
4248
4249 disk->private_data = NULL;
4250 put_disk(disk);
4251 kfree(tpnt);
4252 return;
4253}
4254
Linus Torvalds1da177e2005-04-16 15:20:36 -07004255static int __init init_st(void)
4256{
Jeff Garzik13026a62006-10-04 06:00:38 -04004257 int err;
4258
Linus Torvalds1da177e2005-04-16 15:20:36 -07004259 validate_options();
4260
Jeff Garzik13026a62006-10-04 06:00:38 -04004261 printk(KERN_INFO "st: Version %s, fixed bufsize %d, s/g segs %d\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07004262 verstr, st_fixed_buffer_size, st_max_sg_segs);
4263
gregkh@suse.ded2538782005-03-23 09:55:22 -08004264 st_sysfs_class = class_create(THIS_MODULE, "scsi_tape");
Linus Torvalds1da177e2005-04-16 15:20:36 -07004265 if (IS_ERR(st_sysfs_class)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004266 printk(KERN_ERR "Unable create sysfs class for SCSI tapes\n");
Jeff Garzik13026a62006-10-04 06:00:38 -04004267 return PTR_ERR(st_sysfs_class);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004268 }
4269
Jeff Garzik13026a62006-10-04 06:00:38 -04004270 err = register_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0),
4271 ST_MAX_TAPE_ENTRIES, "st");
4272 if (err) {
4273 printk(KERN_ERR "Unable to get major %d for SCSI tapes\n",
4274 SCSI_TAPE_MAJOR);
4275 goto err_class;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004276 }
Jeff Garzik13026a62006-10-04 06:00:38 -04004277
4278 err = scsi_register_driver(&st_template.gendrv);
4279 if (err)
4280 goto err_chrdev;
4281
Robert P. J. Day405ae7d2007-02-17 19:13:42 +01004282 err = do_create_sysfs_files();
Jeff Garzik13026a62006-10-04 06:00:38 -04004283 if (err)
4284 goto err_scsidrv;
4285
4286 return 0;
4287
4288err_scsidrv:
4289 scsi_unregister_driver(&st_template.gendrv);
4290err_chrdev:
4291 unregister_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0),
4292 ST_MAX_TAPE_ENTRIES);
4293err_class:
Kai Makisarac2c96f42005-08-02 12:21:51 +03004294 class_destroy(st_sysfs_class);
Jeff Garzik13026a62006-10-04 06:00:38 -04004295 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004296}
4297
4298static void __exit exit_st(void)
4299{
Robert P. J. Day405ae7d2007-02-17 19:13:42 +01004300 do_remove_sysfs_files();
Linus Torvalds1da177e2005-04-16 15:20:36 -07004301 scsi_unregister_driver(&st_template.gendrv);
4302 unregister_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0),
4303 ST_MAX_TAPE_ENTRIES);
Kai Makisarac2c96f42005-08-02 12:21:51 +03004304 class_destroy(st_sysfs_class);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004305 kfree(scsi_tapes);
4306 printk(KERN_INFO "st: Unloaded.\n");
4307}
4308
4309module_init(init_st);
4310module_exit(exit_st);
4311
4312
4313/* The sysfs driver interface. Read-only at the moment */
4314static ssize_t st_try_direct_io_show(struct device_driver *ddp, char *buf)
4315{
4316 return snprintf(buf, PAGE_SIZE, "%d\n", try_direct_io);
4317}
4318static DRIVER_ATTR(try_direct_io, S_IRUGO, st_try_direct_io_show, NULL);
4319
4320static ssize_t st_fixed_buffer_size_show(struct device_driver *ddp, char *buf)
4321{
4322 return snprintf(buf, PAGE_SIZE, "%d\n", st_fixed_buffer_size);
4323}
4324static DRIVER_ATTR(fixed_buffer_size, S_IRUGO, st_fixed_buffer_size_show, NULL);
4325
4326static ssize_t st_max_sg_segs_show(struct device_driver *ddp, char *buf)
4327{
4328 return snprintf(buf, PAGE_SIZE, "%d\n", st_max_sg_segs);
4329}
4330static DRIVER_ATTR(max_sg_segs, S_IRUGO, st_max_sg_segs_show, NULL);
4331
4332static ssize_t st_version_show(struct device_driver *ddd, char *buf)
4333{
4334 return snprintf(buf, PAGE_SIZE, "[%s]\n", verstr);
4335}
4336static DRIVER_ATTR(version, S_IRUGO, st_version_show, NULL);
4337
Robert P. J. Day405ae7d2007-02-17 19:13:42 +01004338static int do_create_sysfs_files(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004339{
Robert P. J. Day405ae7d2007-02-17 19:13:42 +01004340 struct device_driver *sysfs = &st_template.gendrv;
Jeff Garzik13026a62006-10-04 06:00:38 -04004341 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004342
Robert P. J. Day405ae7d2007-02-17 19:13:42 +01004343 err = driver_create_file(sysfs, &driver_attr_try_direct_io);
Jeff Garzik13026a62006-10-04 06:00:38 -04004344 if (err)
4345 return err;
Robert P. J. Day405ae7d2007-02-17 19:13:42 +01004346 err = driver_create_file(sysfs, &driver_attr_fixed_buffer_size);
Jeff Garzik13026a62006-10-04 06:00:38 -04004347 if (err)
4348 goto err_try_direct_io;
Robert P. J. Day405ae7d2007-02-17 19:13:42 +01004349 err = driver_create_file(sysfs, &driver_attr_max_sg_segs);
Jeff Garzik13026a62006-10-04 06:00:38 -04004350 if (err)
4351 goto err_attr_fixed_buf;
Robert P. J. Day405ae7d2007-02-17 19:13:42 +01004352 err = driver_create_file(sysfs, &driver_attr_version);
Jeff Garzik13026a62006-10-04 06:00:38 -04004353 if (err)
4354 goto err_attr_max_sg;
4355
4356 return 0;
4357
4358err_attr_max_sg:
Robert P. J. Day405ae7d2007-02-17 19:13:42 +01004359 driver_remove_file(sysfs, &driver_attr_max_sg_segs);
Jeff Garzik13026a62006-10-04 06:00:38 -04004360err_attr_fixed_buf:
Robert P. J. Day405ae7d2007-02-17 19:13:42 +01004361 driver_remove_file(sysfs, &driver_attr_fixed_buffer_size);
Jeff Garzik13026a62006-10-04 06:00:38 -04004362err_try_direct_io:
Robert P. J. Day405ae7d2007-02-17 19:13:42 +01004363 driver_remove_file(sysfs, &driver_attr_try_direct_io);
Jeff Garzik13026a62006-10-04 06:00:38 -04004364 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004365}
4366
Robert P. J. Day405ae7d2007-02-17 19:13:42 +01004367static void do_remove_sysfs_files(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004368{
Robert P. J. Day405ae7d2007-02-17 19:13:42 +01004369 struct device_driver *sysfs = &st_template.gendrv;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004370
Robert P. J. Day405ae7d2007-02-17 19:13:42 +01004371 driver_remove_file(sysfs, &driver_attr_version);
4372 driver_remove_file(sysfs, &driver_attr_max_sg_segs);
4373 driver_remove_file(sysfs, &driver_attr_fixed_buffer_size);
4374 driver_remove_file(sysfs, &driver_attr_try_direct_io);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004375}
4376
4377
4378/* The sysfs simple class interface */
Tony Jonesee959b02008-02-22 00:13:36 +01004379static ssize_t
4380st_defined_show(struct device *dev, struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004381{
James Bottomley7d15d6a2008-03-14 14:12:43 -07004382 struct st_modedef *STm = dev_get_drvdata(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004383 ssize_t l = 0;
4384
4385 l = snprintf(buf, PAGE_SIZE, "%d\n", STm->defined);
4386 return l;
4387}
4388
Tony Jonesee959b02008-02-22 00:13:36 +01004389DEVICE_ATTR(defined, S_IRUGO, st_defined_show, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004390
Tony Jonesee959b02008-02-22 00:13:36 +01004391static ssize_t
4392st_defblk_show(struct device *dev, struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004393{
James Bottomley7d15d6a2008-03-14 14:12:43 -07004394 struct st_modedef *STm = dev_get_drvdata(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004395 ssize_t l = 0;
4396
4397 l = snprintf(buf, PAGE_SIZE, "%d\n", STm->default_blksize);
4398 return l;
4399}
4400
Tony Jonesee959b02008-02-22 00:13:36 +01004401DEVICE_ATTR(default_blksize, S_IRUGO, st_defblk_show, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004402
Tony Jonesee959b02008-02-22 00:13:36 +01004403static ssize_t
4404st_defdensity_show(struct device *dev, struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004405{
James Bottomley7d15d6a2008-03-14 14:12:43 -07004406 struct st_modedef *STm = dev_get_drvdata(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004407 ssize_t l = 0;
4408 char *fmt;
4409
4410 fmt = STm->default_density >= 0 ? "0x%02x\n" : "%d\n";
4411 l = snprintf(buf, PAGE_SIZE, fmt, STm->default_density);
4412 return l;
4413}
4414
Tony Jonesee959b02008-02-22 00:13:36 +01004415DEVICE_ATTR(default_density, S_IRUGO, st_defdensity_show, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004416
Tony Jonesee959b02008-02-22 00:13:36 +01004417static ssize_t
4418st_defcompression_show(struct device *dev, struct device_attribute *attr,
4419 char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004420{
James Bottomley7d15d6a2008-03-14 14:12:43 -07004421 struct st_modedef *STm = dev_get_drvdata(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004422 ssize_t l = 0;
4423
4424 l = snprintf(buf, PAGE_SIZE, "%d\n", STm->default_compression - 1);
4425 return l;
4426}
4427
Tony Jonesee959b02008-02-22 00:13:36 +01004428DEVICE_ATTR(default_compression, S_IRUGO, st_defcompression_show, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004429
Tony Jonesee959b02008-02-22 00:13:36 +01004430static ssize_t
4431st_options_show(struct device *dev, struct device_attribute *attr, char *buf)
Kai Makisarab174be02008-02-24 22:29:12 +02004432{
James Bottomley7d15d6a2008-03-14 14:12:43 -07004433 struct st_modedef *STm = dev_get_drvdata(dev);
Kai Makisarab174be02008-02-24 22:29:12 +02004434 struct scsi_tape *STp;
4435 int i, j, options;
4436 ssize_t l = 0;
4437
4438 for (i=0; i < st_dev_max; i++) {
4439 for (j=0; j < ST_NBR_MODES; j++)
4440 if (&scsi_tapes[i]->modes[j] == STm)
4441 break;
4442 if (j < ST_NBR_MODES)
4443 break;
4444 }
4445 if (i == st_dev_max)
4446 return 0; /* should never happen */
4447
4448 STp = scsi_tapes[i];
4449
4450 options = STm->do_buffer_writes ? MT_ST_BUFFER_WRITES : 0;
4451 options |= STm->do_async_writes ? MT_ST_ASYNC_WRITES : 0;
4452 options |= STm->do_read_ahead ? MT_ST_READ_AHEAD : 0;
4453 DEB( options |= debugging ? MT_ST_DEBUGGING : 0 );
4454 options |= STp->two_fm ? MT_ST_TWO_FM : 0;
4455 options |= STp->fast_mteom ? MT_ST_FAST_MTEOM : 0;
4456 options |= STm->defaults_for_writes ? MT_ST_DEF_WRITES : 0;
4457 options |= STp->can_bsr ? MT_ST_CAN_BSR : 0;
4458 options |= STp->omit_blklims ? MT_ST_NO_BLKLIMS : 0;
4459 options |= STp->can_partitions ? MT_ST_CAN_PARTITIONS : 0;
4460 options |= STp->scsi2_logical ? MT_ST_SCSI2LOGICAL : 0;
4461 options |= STm->sysv ? MT_ST_SYSV : 0;
4462 options |= STp->immediate ? MT_ST_NOWAIT : 0;
4463 options |= STp->sili ? MT_ST_SILI : 0;
4464
4465 l = snprintf(buf, PAGE_SIZE, "0x%08x\n", options);
4466 return l;
4467}
4468
Tony Jonesee959b02008-02-22 00:13:36 +01004469DEVICE_ATTR(options, S_IRUGO, st_options_show, NULL);
Kai Makisarab174be02008-02-24 22:29:12 +02004470
Jeff Garzik13026a62006-10-04 06:00:38 -04004471static int do_create_class_files(struct scsi_tape *STp, int dev_num, int mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004472{
4473 int i, rew, error;
4474 char name[10];
Tony Jonesee959b02008-02-22 00:13:36 +01004475 struct device *st_class_member;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004476
Linus Torvalds1da177e2005-04-16 15:20:36 -07004477 for (rew=0; rew < 2; rew++) {
4478 /* Make sure that the minor numbers corresponding to the four
4479 first modes always get the same names */
4480 i = mode << (4 - ST_NBR_MODE_BITS);
4481 snprintf(name, 10, "%s%s%s", rew ? "n" : "",
4482 STp->disk->disk_name, st_formats[i]);
4483 st_class_member =
Greg Kroah-Hartmand73a1a62008-07-21 20:03:34 -07004484 device_create(st_sysfs_class, &STp->device->sdev_gendev,
4485 MKDEV(SCSI_TAPE_MAJOR,
4486 TAPE_MINOR(dev_num, mode, rew)),
4487 &STp->modes[mode], "%s", name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004488 if (IS_ERR(st_class_member)) {
Tony Jonesee959b02008-02-22 00:13:36 +01004489 printk(KERN_WARNING "st%d: device_create failed\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07004490 dev_num);
Jeff Garzik13026a62006-10-04 06:00:38 -04004491 error = PTR_ERR(st_class_member);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004492 goto out;
4493 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004494
Tony Jonesee959b02008-02-22 00:13:36 +01004495 error = device_create_file(st_class_member,
4496 &dev_attr_defined);
Jeff Garzik13026a62006-10-04 06:00:38 -04004497 if (error) goto out;
Tony Jonesee959b02008-02-22 00:13:36 +01004498 error = device_create_file(st_class_member,
4499 &dev_attr_default_blksize);
Jeff Garzik13026a62006-10-04 06:00:38 -04004500 if (error) goto out;
Tony Jonesee959b02008-02-22 00:13:36 +01004501 error = device_create_file(st_class_member,
4502 &dev_attr_default_density);
Jeff Garzik13026a62006-10-04 06:00:38 -04004503 if (error) goto out;
Tony Jonesee959b02008-02-22 00:13:36 +01004504 error = device_create_file(st_class_member,
4505 &dev_attr_default_compression);
Jeff Garzik13026a62006-10-04 06:00:38 -04004506 if (error) goto out;
Tony Jonesee959b02008-02-22 00:13:36 +01004507 error = device_create_file(st_class_member,
4508 &dev_attr_options);
Kai Makisarab174be02008-02-24 22:29:12 +02004509 if (error) goto out;
Jeff Garzik13026a62006-10-04 06:00:38 -04004510
Linus Torvalds1da177e2005-04-16 15:20:36 -07004511 if (mode == 0 && rew == 0) {
4512 error = sysfs_create_link(&STp->device->sdev_gendev.kobj,
4513 &st_class_member->kobj,
4514 "tape");
4515 if (error) {
4516 printk(KERN_ERR
4517 "st%d: Can't create sysfs link from SCSI device.\n",
4518 dev_num);
Jeff Garzik13026a62006-10-04 06:00:38 -04004519 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004520 }
4521 }
4522 }
Jeff Garzik13026a62006-10-04 06:00:38 -04004523
4524 return 0;
4525
4526out:
4527 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004528}
4529
Linus Torvalds1da177e2005-04-16 15:20:36 -07004530/* The following functions may be useful for a larger audience. */
FUJITA Tomonori66207422008-12-18 14:49:43 +09004531static int sgl_map_user_pages(struct st_buffer *STbp,
4532 const unsigned int max_pages, unsigned long uaddr,
4533 size_t count, int rw)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004534{
James Bottomley07542b82005-08-31 20:27:22 -04004535 unsigned long end = (uaddr + count + PAGE_SIZE - 1) >> PAGE_SHIFT;
4536 unsigned long start = uaddr >> PAGE_SHIFT;
4537 const int nr_pages = end - start;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004538 int res, i, j;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004539 struct page **pages;
FUJITA Tomonori66207422008-12-18 14:49:43 +09004540 struct rq_map_data *mdata = &STbp->map_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004541
Linus Torvalds1da177e2005-04-16 15:20:36 -07004542 /* User attempted Overflow! */
4543 if ((uaddr + count) < uaddr)
4544 return -EINVAL;
4545
4546 /* Too big */
4547 if (nr_pages > max_pages)
4548 return -ENOMEM;
4549
4550 /* Hmm? */
4551 if (count == 0)
4552 return 0;
4553
4554 if ((pages = kmalloc(max_pages * sizeof(*pages), GFP_KERNEL)) == NULL)
4555 return -ENOMEM;
4556
4557 /* Try to fault in all of the necessary pages */
4558 down_read(&current->mm->mmap_sem);
4559 /* rw==READ means read from drive, write into memory area */
4560 res = get_user_pages(
4561 current,
4562 current->mm,
4563 uaddr,
4564 nr_pages,
4565 rw == READ,
4566 0, /* don't force */
4567 pages,
4568 NULL);
4569 up_read(&current->mm->mmap_sem);
4570
4571 /* Errors and no page mapped should return here */
4572 if (res < nr_pages)
4573 goto out_unmap;
4574
4575 for (i=0; i < nr_pages; i++) {
4576 /* FIXME: flush superflous for rw==READ,
4577 * probably wrong function for rw==WRITE
4578 */
4579 flush_dcache_page(pages[i]);
4580 }
4581
FUJITA Tomonori66207422008-12-18 14:49:43 +09004582 mdata->offset = uaddr & ~PAGE_MASK;
FUJITA Tomonori66207422008-12-18 14:49:43 +09004583 STbp->mapped_pages = pages;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004584
Linus Torvalds1da177e2005-04-16 15:20:36 -07004585 return nr_pages;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004586 out_unmap:
4587 if (res > 0) {
4588 for (j=0; j < res; j++)
4589 page_cache_release(pages[j]);
Hugh Dickins6bc733e2005-12-01 20:21:57 +00004590 res = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004591 }
4592 kfree(pages);
4593 return res;
4594}
4595
4596
4597/* And unmap them... */
FUJITA Tomonori66207422008-12-18 14:49:43 +09004598static int sgl_unmap_user_pages(struct st_buffer *STbp,
4599 const unsigned int nr_pages, int dirtied)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004600{
4601 int i;
4602
4603 for (i=0; i < nr_pages; i++) {
FUJITA Tomonori66207422008-12-18 14:49:43 +09004604 struct page *page = STbp->mapped_pages[i];
Nick Pigginb5810032005-10-29 18:16:12 -07004605
Nick Pigginb5810032005-10-29 18:16:12 -07004606 if (dirtied)
4607 SetPageDirty(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004608 /* FIXME: cache flush missing for rw==READ
4609 * FIXME: call the correct reference counting function
4610 */
Nick Pigginb5810032005-10-29 18:16:12 -07004611 page_cache_release(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004612 }
FUJITA Tomonori66207422008-12-18 14:49:43 +09004613 kfree(STbp->mapped_pages);
4614 STbp->mapped_pages = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004615
4616 return 0;
4617}