]> bbs.cooldavid.org Git - net-next-2.6.git/blame - drivers/scsi/st.c
git://bbs.cooldavid.org / net-next-2.6.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[SCSI] st: Move buffer pointer back when data could not be written.
[net-next-2.6.git] / drivers / scsi / st.c
CommitLineData
1da177e4
LT		 1/*
2 SCSI Tape Driver for Linux version 1.1 and newer. See the accompanying
3 file Documentation/scsi/st.txt for more information.
4
5 History:
6 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
fd66c1b4 12 Copyright 1992 - 2008 Kai Makisara
1da177e4
LT		 13 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
626dcb1e 20static const char *verstr = "20080504";
1da177e4
LT		 21
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>
16c4b3e2 32#include <linux/cdrom.h>
1da177e4
LT		 33#include <linux/ioctl.h>
34#include <linux/fcntl.h>
35#include <linux/spinlock.h>
36#include <linux/blkdev.h>
37#include <linux/moduleparam.h>
1da177e4
LT		 38#include <linux/cdev.h>
39#include <linux/delay.h>
0b950672 40#include <linux/mutex.h>
b3369c68 41#include <linux/smp_lock.h>
1da177e4
LT		 42
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>
16c4b3e2 54#include <scsi/sg.h>
1da177e4
LT		 55
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
d253878b 87static struct class *st_sysfs_class;
1da177e4
LT		 88
89MODULE_AUTHOR("Kai Makisara");
f018fa55 90MODULE_DESCRIPTION("SCSI tape (st) driver");
1da177e4 91MODULE_LICENSE("GPL");
f018fa55 92MODULE_ALIAS_CHARDEV_MAJOR(SCSI_TAPE_MAJOR);
d7b8bcb0 93MODULE_ALIAS_SCSI_DEVICE(TYPE_TAPE);
1da177e4
LT		 94
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 */
0ad78200 139static const char *st_formats[] = {
1da177e4
LT		 140 "", "r", "k", "s", "l", "t", "o", "u",
141 "m", "v", "p", "x", "a", "y", "q", "z"};
142
143/* The default definitions have been moved to st_options.h */
144
145#define ST_FIXED_BUFFER_SIZE (ST_FIXED_BUFFER_BLOCKS * ST_KILOBYTE)
146
147/* The buffer size should fit into the 24 bits for length in the
148 6-byte SCSI read and write commands. */
149#if ST_FIXED_BUFFER_SIZE >= (2 << 24 - 1)
150#error "Buffer size should not exceed (2 << 24 - 1) bytes!"
151#endif
152
153static int debugging = DEBUG;
154
155#define MAX_RETRIES 0
156#define MAX_WRITE_RETRIES 0
157#define MAX_READY_RETRIES 0
158#define NO_TAPE NOT_READY
159
160#define ST_TIMEOUT (900 * HZ)
161#define ST_LONG_TIMEOUT (14000 * HZ)
162
163/* Remove mode bits and auto-rewind bit (7) */
164#define TAPE_NR(x) ( ((iminor(x) & ~255) >> (ST_NBR_MODE_BITS + 1)) | \
165 (iminor(x) & ~(-1 << ST_MODE_SHIFT)) )
166#define TAPE_MODE(x) ((iminor(x) & ST_MODE_MASK) >> ST_MODE_SHIFT)
167
168/* Construct the minor number from the device (d), mode (m), and non-rewind (n) data */
169#define TAPE_MINOR(d, m, n) (((d & ~(255 >> (ST_NBR_MODE_BITS + 1))) << (ST_NBR_MODE_BITS + 1)) | \
170 (d & (255 >> (ST_NBR_MODE_BITS + 1))) | (m << ST_MODE_SHIFT) | ((n != 0) << 7) )
171
172/* Internal ioctl to set both density (uppermost 8 bits) and blocksize (lower
173 24 bits) */
174#define SET_DENS_AND_BLK 0x10001
175
176static DEFINE_RWLOCK(st_dev_arr_lock);
177
178static int st_fixed_buffer_size = ST_FIXED_BUFFER_SIZE;
179static int st_max_sg_segs = ST_MAX_SG;
180
181static struct scsi_tape **scsi_tapes = NULL;
182
183static int modes_defined;
184
185static struct st_buffer *new_tape_buffer(int, int, int);
186static int enlarge_buffer(struct st_buffer *, int, int);
40f6b36c 187static void clear_buffer(struct st_buffer *);
1da177e4
LT		 188static void normalize_buffer(struct st_buffer *);
189static int append_to_buffer(const char __user *, struct st_buffer *, int);
190static int from_buffer(struct st_buffer *, char __user *, int);
191static void move_buffer_data(struct st_buffer *, int);
192static void buf_to_sg(struct st_buffer *, unsigned int);
193
1da177e4
LT		 194static int sgl_map_user_pages(struct scatterlist *, const unsigned int,
195 unsigned long, size_t, int);
196static int sgl_unmap_user_pages(struct scatterlist *, const unsigned int, int);
197
198static int st_probe(struct device *);
199static int st_remove(struct device *);
1da177e4 200
405ae7d3
RD		 201static int do_create_sysfs_files(void);
202static void do_remove_sysfs_files(void);
13026a6b 203static int do_create_class_files(struct scsi_tape *, int, int);
1da177e4
LT		 204
205static struct scsi_driver st_template = {
206 .owner = THIS_MODULE,
207 .gendrv = {
208 .name = "st",
209 .probe = st_probe,
210 .remove = st_remove,
211 },
1da177e4
LT		 212};
213
214static int st_compression(struct scsi_tape *, int);
215
216static int find_partition(struct scsi_tape *);
217static int switch_partition(struct scsi_tape *);
218
219static int st_int_ioctl(struct scsi_tape *, unsigned int, unsigned long);
220
f03a5670
KM		 221static void scsi_tape_release(struct kref *);
222
223#define to_scsi_tape(obj) container_of(obj, struct scsi_tape, kref)
224
0b950672 225static DEFINE_MUTEX(st_ref_mutex);
f03a5670 226
1da177e4
LT		 227\f
228#include "osst_detect.h"
229#ifndef SIGS_FROM_OSST
230#define SIGS_FROM_OSST \
231 {"OnStream", "SC-", "", "osst"}, \
232 {"OnStream", "DI-", "", "osst"}, \
233 {"OnStream", "DP-", "", "osst"}, \
234 {"OnStream", "USB", "", "osst"}, \
235 {"OnStream", "FW-", "", "osst"}
236#endif
237
f03a5670
KM		 238static struct scsi_tape *scsi_tape_get(int dev)
239{
240 struct scsi_tape *STp = NULL;
241
0b950672 242 mutex_lock(&st_ref_mutex);
f03a5670
KM		 243 write_lock(&st_dev_arr_lock);
244
245 if (dev < st_dev_max && scsi_tapes != NULL)
246 STp = scsi_tapes[dev];
247 if (!STp) goto out;
248
249 kref_get(&STp->kref);
250
251 if (!STp->device)
252 goto out_put;
253
254 if (scsi_device_get(STp->device))
255 goto out_put;
256
257 goto out;
258
259out_put:
260 kref_put(&STp->kref, scsi_tape_release);
261 STp = NULL;
262out:
263 write_unlock(&st_dev_arr_lock);
0b950672 264 mutex_unlock(&st_ref_mutex);
f03a5670
KM		 265 return STp;
266}
267
268static void scsi_tape_put(struct scsi_tape *STp)
269{
270 struct scsi_device *sdev = STp->device;
271
0b950672 272 mutex_lock(&st_ref_mutex);
f03a5670
KM		 273 kref_put(&STp->kref, scsi_tape_release);
274 scsi_device_put(sdev);
0b950672 275 mutex_unlock(&st_ref_mutex);
f03a5670
KM		 276}
277
1da177e4
LT		 278struct st_reject_data {
279 char *vendor;
280 char *model;
281 char *rev;
282 char *driver_hint; /* Name of the correct driver, NULL if unknown */
283};
284
285static struct st_reject_data reject_list[] = {
286 /* {"XXX", "Yy-", "", NULL}, example */
287 SIGS_FROM_OSST,
288 {NULL, }};
289
290/* If the device signature is on the list of incompatible drives, the
291 function returns a pointer to the name of the correct driver (if known) */
292static char * st_incompatible(struct scsi_device* SDp)
293{
294 struct st_reject_data *rp;
295
296 for (rp=&(reject_list[0]); rp->vendor != NULL; rp++)
297 if (!strncmp(rp->vendor, SDp->vendor, strlen(rp->vendor)) &&
298 !strncmp(rp->model, SDp->model, strlen(rp->model)) &&
299 !strncmp(rp->rev, SDp->rev, strlen(rp->rev))) {
300 if (rp->driver_hint)
301 return rp->driver_hint;
302 else
303 return "unknown";
304 }
305 return NULL;
306}
307\f
308
309static inline char *tape_name(struct scsi_tape *tape)
310{
311 return tape->disk->disk_name;
312}
313
314
8b05b773 315static void st_analyze_sense(struct st_request *SRpnt, struct st_cmdstatus *s)
1da177e4
LT		 316{
317 const u8 *ucp;
8b05b773 318 const u8 *sense = SRpnt->sense;
1da177e4 319
8b05b773
MC		 320 s->have_sense = scsi_normalize_sense(SRpnt->sense,
321 SCSI_SENSE_BUFFERSIZE, &s->sense_hdr);
1da177e4
LT		 322 s->flags = 0;
323
324 if (s->have_sense) {
325 s->deferred = 0;
326 s->remainder_valid =
327 scsi_get_sense_info_fld(sense, SCSI_SENSE_BUFFERSIZE, &s->uremainder64);
328 switch (sense[0] & 0x7f) {
329 case 0x71:
330 s->deferred = 1;
331 case 0x70:
332 s->fixed_format = 1;
333 s->flags = sense[2] & 0xe0;
334 break;
335 case 0x73:
336 s->deferred = 1;
337 case 0x72:
338 s->fixed_format = 0;
339 ucp = scsi_sense_desc_find(sense, SCSI_SENSE_BUFFERSIZE, 4);
340 s->flags = ucp ? (ucp[3] & 0xe0) : 0;
341 break;
342 }
343 }
344}
345
346
347/* Convert the result to success code */
8b05b773 348static int st_chk_result(struct scsi_tape *STp, struct st_request * SRpnt)
1da177e4 349{
8b05b773 350 int result = SRpnt->result;
1da177e4
LT		 351 u8 scode;
352 DEB(const char *stp;)
353 char *name = tape_name(STp);
354 struct st_cmdstatus *cmdstatp;
355
356 if (!result)
357 return 0;
358
359 cmdstatp = &STp->buffer->cmdstat;
f03a5670 360 st_analyze_sense(SRpnt, cmdstatp);
1da177e4
LT		 361
362 if (cmdstatp->have_sense)
363 scode = STp->buffer->cmdstat.sense_hdr.sense_key;
364 else
365 scode = 0;
366
367 DEB(
368 if (debugging) {
8b05b773 369 printk(ST_DEB_MSG "%s: Error: %x, cmd: %x %x %x %x %x %x\n",
1da177e4 370 name, result,
8b05b773
MC		 371 SRpnt->cmd[0], SRpnt->cmd[1], SRpnt->cmd[2],
372 SRpnt->cmd[3], SRpnt->cmd[4], SRpnt->cmd[5]);
1da177e4 373 if (cmdstatp->have_sense)
4e73ea7b 374 __scsi_print_sense(name, SRpnt->sense, SCSI_SENSE_BUFFERSIZE);
1da177e4
LT		 375 } ) /* end DEB */
376 if (!debugging) { /* Abnormal conditions for tape */
377 if (!cmdstatp->have_sense)
378 printk(KERN_WARNING
379 "%s: Error %x (sugg. bt 0x%x, driver bt 0x%x, host bt 0x%x).\n",
380 name, result, suggestion(result),
381 driver_byte(result) & DRIVER_MASK, host_byte(result));
382 else if (cmdstatp->have_sense &&
383 scode != NO_SENSE &&
384 scode != RECOVERED_ERROR &&
385 /* scode != UNIT_ATTENTION && */
386 scode != BLANK_CHECK &&
387 scode != VOLUME_OVERFLOW &&
8b05b773
MC		 388 SRpnt->cmd[0] != MODE_SENSE &&
389 SRpnt->cmd[0] != TEST_UNIT_READY) {
4e73ea7b
LT		 390
391 __scsi_print_sense(name, SRpnt->sense, SCSI_SENSE_BUFFERSIZE);
1da177e4
LT		 392 }
393 }
394
395 if (cmdstatp->fixed_format &&
396 STp->cln_mode >= EXTENDED_SENSE_START) { /* Only fixed format sense */
397 if (STp->cln_sense_value)
8b05b773 398 STp->cleaning_req |= ((SRpnt->sense[STp->cln_mode] &
1da177e4
LT		 399 STp->cln_sense_mask) == STp->cln_sense_value);
400 else
8b05b773 401 STp->cleaning_req |= ((SRpnt->sense[STp->cln_mode] &
1da177e4
LT		 402 STp->cln_sense_mask) != 0);
403 }
404 if (cmdstatp->have_sense &&
405 cmdstatp->sense_hdr.asc == 0 && cmdstatp->sense_hdr.ascq == 0x17)
406 STp->cleaning_req = 1; /* ASC and ASCQ => cleaning requested */
407
408 STp->pos_unknown |= STp->device->was_reset;
409
410 if (cmdstatp->have_sense &&
411 scode == RECOVERED_ERROR
412#if ST_RECOVERED_WRITE_FATAL
8b05b773
MC		 413 && SRpnt->cmd[0] != WRITE_6
414 && SRpnt->cmd[0] != WRITE_FILEMARKS
1da177e4
LT		 415#endif
416 ) {
417 STp->recover_count++;
418 STp->recover_reg++;
419
420 DEB(
421 if (debugging) {
8b05b773 422 if (SRpnt->cmd[0] == READ_6)
1da177e4 423 stp = "read";
8b05b773 424 else if (SRpnt->cmd[0] == WRITE_6)
1da177e4
LT		 425 stp = "write";
426 else
427 stp = "ioctl";
428 printk(ST_DEB_MSG "%s: Recovered %s error (%d).\n", name, stp,
429 STp->recover_count);
430 } ) /* end DEB */
431
432 if (cmdstatp->flags == 0)
433 return 0;
434 }
435 return (-EIO);
436}
437
438
439/* Wakeup from interrupt */
8b05b773 440static void st_sleep_done(void *data, char *sense, int result, int resid)
1da177e4 441{
8b05b773
MC		 442 struct st_request *SRpnt = data;
443 struct scsi_tape *STp = SRpnt->stp;
1da177e4 444
8b05b773
MC		 445 memcpy(SRpnt->sense, sense, SCSI_SENSE_BUFFERSIZE);
446 (STp->buffer)->cmdstat.midlevel_result = SRpnt->result = result;
40f6b36c 447 (STp->buffer)->cmdstat.residual = resid;
1da177e4
LT		 448 DEB( STp->write_pending = 0; )
449
8b05b773
MC		 450 if (SRpnt->waiting)
451 complete(SRpnt->waiting);
452}
453
454static struct st_request *st_allocate_request(void)
455{
456 return kzalloc(sizeof(struct st_request), GFP_KERNEL);
457}
458
459static void st_release_request(struct st_request *streq)
460{
461 kfree(streq);
1da177e4
LT		 462}
463
464/* Do the scsi command. Waits until command performed if do_wait is true.
465 Otherwise write_behind_check() is used to check that the command
466 has finished. */
8b05b773
MC		 467static struct st_request *
468st_do_scsi(struct st_request * SRpnt, struct scsi_tape * STp, unsigned char *cmd,
1da177e4
LT		 469 int bytes, int direction, int timeout, int retries, int do_wait)
470{
f03a5670 471 struct completion *waiting;
1da177e4 472
f03a5670
KM		 473 /* if async, make sure there's no command outstanding */
474 if (!do_wait && ((STp->buffer)->last_SRpnt)) {
475 printk(KERN_ERR "%s: Async command already active.\n",
476 tape_name(STp));
477 if (signal_pending(current))
478 (STp->buffer)->syscall_result = (-EINTR);
479 else
480 (STp->buffer)->syscall_result = (-EBUSY);
481 return NULL;
482 }
483
1da177e4 484 if (SRpnt == NULL) {
8b05b773 485 SRpnt = st_allocate_request();
1da177e4
LT		 486 if (SRpnt == NULL) {
487 DEBC( printk(KERN_ERR "%s: Can't get SCSI request.\n",
488 tape_name(STp)); );
489 if (signal_pending(current))
490 (STp->buffer)->syscall_result = (-EINTR);
491 else
492 (STp->buffer)->syscall_result = (-EBUSY);
493 return NULL;
494 }
8b05b773 495 SRpnt->stp = STp;
1da177e4
LT		 496 }
497
f03a5670
KM		 498 /* If async IO, set last_SRpnt. This ptr tells write_behind_check
499 which IO is outstanding. It's nulled out when the IO completes. */
500 if (!do_wait)
501 (STp->buffer)->last_SRpnt = SRpnt;
502
503 waiting = &STp->wait;
504 init_completion(waiting);
8b05b773 505 SRpnt->waiting = waiting;
1da177e4 506
8b05b773
MC		 507 if (!STp->buffer->do_dio)
508 buf_to_sg(STp->buffer, bytes);
1da177e4 509
8b05b773
MC		 510 memcpy(SRpnt->cmd, cmd, sizeof(SRpnt->cmd));
511 STp->buffer->cmdstat.have_sense = 0;
512 STp->buffer->syscall_result = 0;
513
bb1d1073 514 if (scsi_execute_async(STp->device, cmd, COMMAND_SIZE(cmd[0]), direction,
8b05b773 515 &((STp->buffer)->sg[0]), bytes, (STp->buffer)->sg_segs,
787926b1 516 timeout, retries, SRpnt, st_sleep_done, GFP_KERNEL)) {
8b05b773
MC		 517 /* could not allocate the buffer or request was too large */
518 (STp->buffer)->syscall_result = (-EBUSY);
787926b1
KM		 519 (STp->buffer)->last_SRpnt = NULL;
520 }
8b05b773 521 else if (do_wait) {
f03a5670 522 wait_for_completion(waiting);
8b05b773 523 SRpnt->waiting = NULL;
1da177e4
LT		 524 (STp->buffer)->syscall_result = st_chk_result(STp, SRpnt);
525 }
8b05b773 526
1da177e4
LT		 527 return SRpnt;
528}
529
530
531/* Handle the write-behind checking (waits for completion). Returns -ENOSPC if
532 write has been correct but EOM early warning reached, -EIO if write ended in
533 error or zero if write successful. Asynchronous writes are used only in
534 variable block mode. */
535static int write_behind_check(struct scsi_tape * STp)
536{
537 int retval = 0;
538 struct st_buffer *STbuffer;
539 struct st_partstat *STps;
540 struct st_cmdstatus *cmdstatp;
8b05b773 541 struct st_request *SRpnt;
1da177e4
LT		 542
543 STbuffer = STp->buffer;
544 if (!STbuffer->writing)
545 return 0;
546
547 DEB(
548 if (STp->write_pending)
549 STp->nbr_waits++;
550 else
551 STp->nbr_finished++;
552 ) /* end DEB */
553
554 wait_for_completion(&(STp->wait));
f03a5670
KM		 555 SRpnt = STbuffer->last_SRpnt;
556 STbuffer->last_SRpnt = NULL;
8b05b773 557 SRpnt->waiting = NULL;
1da177e4 558
f03a5670 559 (STp->buffer)->syscall_result = st_chk_result(STp, SRpnt);
8b05b773 560 st_release_request(SRpnt);
1da177e4
LT		 561
562 STbuffer->buffer_bytes -= STbuffer->writing;
563 STps = &(STp->ps[STp->partition]);
564 if (STps->drv_block >= 0) {
565 if (STp->block_size == 0)
566 STps->drv_block++;
567 else
568 STps->drv_block += STbuffer->writing / STp->block_size;
569 }
570
571 cmdstatp = &STbuffer->cmdstat;
572 if (STbuffer->syscall_result) {
573 retval = -EIO;
574 if (cmdstatp->have_sense && !cmdstatp->deferred &&
575 (cmdstatp->flags & SENSE_EOM) &&
576 (cmdstatp->sense_hdr.sense_key == NO_SENSE ||
577 cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR)) {
578 /* EOM at write-behind, has all data been written? */
579 if (!cmdstatp->remainder_valid ||
580 cmdstatp->uremainder64 == 0)
581 retval = -ENOSPC;
582 }
583 if (retval == -EIO)
584 STps->drv_block = -1;
585 }
586 STbuffer->writing = 0;
587
588 DEB(if (debugging && retval)
589 printk(ST_DEB_MSG "%s: Async write error %x, return value %d.\n",
590 tape_name(STp), STbuffer->cmdstat.midlevel_result, retval);) /* end DEB */
591
592 return retval;
593}
594
595
596/* Step over EOF if it has been inadvertently crossed (ioctl not used because
597 it messes up the block number). */
598static int cross_eof(struct scsi_tape * STp, int forward)
599{
8b05b773 600 struct st_request *SRpnt;
1da177e4
LT		 601 unsigned char cmd[MAX_COMMAND_SIZE];
602
603 cmd[0] = SPACE;
604 cmd[1] = 0x01; /* Space FileMarks */
605 if (forward) {
606 cmd[2] = cmd[3] = 0;
607 cmd[4] = 1;
608 } else
609 cmd[2] = cmd[3] = cmd[4] = 0xff; /* -1 filemarks */
610 cmd[5] = 0;
611
612 DEBC(printk(ST_DEB_MSG "%s: Stepping over filemark %s.\n",
613 tape_name(STp), forward ? "forward" : "backward"));
614
615 SRpnt = st_do_scsi(NULL, STp, cmd, 0, DMA_NONE,
616 STp->device->timeout, MAX_RETRIES, 1);
617 if (!SRpnt)
618 return (STp->buffer)->syscall_result;
619
8b05b773 620 st_release_request(SRpnt);
1da177e4
LT		 621 SRpnt = NULL;
622
623 if ((STp->buffer)->cmdstat.midlevel_result != 0)
624 printk(KERN_ERR "%s: Stepping over filemark %s failed.\n",
625 tape_name(STp), forward ? "forward" : "backward");
626
627 return (STp->buffer)->syscall_result;
628}
629
630
631/* Flush the write buffer (never need to write if variable blocksize). */
8ef8d594 632static int st_flush_write_buffer(struct scsi_tape * STp)
1da177e4
LT		 633{
634 int offset, transfer, blks;
635 int result;
636 unsigned char cmd[MAX_COMMAND_SIZE];
8b05b773 637 struct st_request *SRpnt;
1da177e4
LT		 638 struct st_partstat *STps;
639
640 result = write_behind_check(STp);
641 if (result)
642 return result;
643
644 result = 0;
645 if (STp->dirty == 1) {
646
647 offset = (STp->buffer)->buffer_bytes;
648 transfer = ((offset + STp->block_size - 1) /
649 STp->block_size) * STp->block_size;
650 DEBC(printk(ST_DEB_MSG "%s: Flushing %d bytes.\n",
651 tape_name(STp), transfer));
652
653 memset((STp->buffer)->b_data + offset, 0, transfer - offset);
654
655 memset(cmd, 0, MAX_COMMAND_SIZE);
656 cmd[0] = WRITE_6;
657 cmd[1] = 1;
658 blks = transfer / STp->block_size;
659 cmd[2] = blks >> 16;
660 cmd[3] = blks >> 8;
661 cmd[4] = blks;
662
663 SRpnt = st_do_scsi(NULL, STp, cmd, transfer, DMA_TO_DEVICE,
664 STp->device->timeout, MAX_WRITE_RETRIES, 1);
665 if (!SRpnt)
666 return (STp->buffer)->syscall_result;
667
668 STps = &(STp->ps[STp->partition]);
669 if ((STp->buffer)->syscall_result != 0) {
670 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
671
672 if (cmdstatp->have_sense && !cmdstatp->deferred &&
673 (cmdstatp->flags & SENSE_EOM) &&
674 (cmdstatp->sense_hdr.sense_key == NO_SENSE ||
675 cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR) &&
676 (!cmdstatp->remainder_valid ||
677 cmdstatp->uremainder64 == 0)) { /* All written at EOM early warning */
678 STp->dirty = 0;
679 (STp->buffer)->buffer_bytes = 0;
680 if (STps->drv_block >= 0)
681 STps->drv_block += blks;
682 result = (-ENOSPC);
683 } else {
684 printk(KERN_ERR "%s: Error on flush.\n",
685 tape_name(STp));
686 STps->drv_block = (-1);
687 result = (-EIO);
688 }
689 } else {
690 if (STps->drv_block >= 0)
691 STps->drv_block += blks;
692 STp->dirty = 0;
693 (STp->buffer)->buffer_bytes = 0;
694 }
8b05b773 695 st_release_request(SRpnt);
1da177e4
LT		 696 SRpnt = NULL;
697 }
698 return result;
699}
700
701
702/* Flush the tape buffer. The tape will be positioned correctly unless
703 seek_next is true. */
704static int flush_buffer(struct scsi_tape *STp, int seek_next)
705{
706 int backspace, result;
707 struct st_buffer *STbuffer;
708 struct st_partstat *STps;
709
710 STbuffer = STp->buffer;
711
712 /*
713 * If there was a bus reset, block further access
714 * to this device.
715 */
716 if (STp->pos_unknown)
717 return (-EIO);
718
719 if (STp->ready != ST_READY)
720 return 0;
721 STps = &(STp->ps[STp->partition]);
722 if (STps->rw == ST_WRITING) /* Writing */
8ef8d594 723 return st_flush_write_buffer(STp);
1da177e4
LT		 724
725 if (STp->block_size == 0)
726 return 0;
727
728 backspace = ((STp->buffer)->buffer_bytes +
729 (STp->buffer)->read_pointer) / STp->block_size -
730 ((STp->buffer)->read_pointer + STp->block_size - 1) /
731 STp->block_size;
732 (STp->buffer)->buffer_bytes = 0;
733 (STp->buffer)->read_pointer = 0;
734 result = 0;
735 if (!seek_next) {
736 if (STps->eof == ST_FM_HIT) {
737 result = cross_eof(STp, 0); /* Back over the EOF hit */
738 if (!result)
739 STps->eof = ST_NOEOF;
740 else {
741 if (STps->drv_file >= 0)
742 STps->drv_file++;
743 STps->drv_block = 0;
744 }
745 }
746 if (!result && backspace > 0)
747 result = st_int_ioctl(STp, MTBSR, backspace);
748 } else if (STps->eof == ST_FM_HIT) {
749 if (STps->drv_file >= 0)
750 STps->drv_file++;
751 STps->drv_block = 0;
752 STps->eof = ST_NOEOF;
753 }
754 return result;
755
756}
757\f
758/* Set the mode parameters */
759static int set_mode_densblk(struct scsi_tape * STp, struct st_modedef * STm)
760{
761 int set_it = 0;
762 unsigned long arg;
763 char *name = tape_name(STp);
764
765 if (!STp->density_changed &&
766 STm->default_density >= 0 &&
767 STm->default_density != STp->density) {
768 arg = STm->default_density;
769 set_it = 1;
770 } else
771 arg = STp->density;
772 arg <<= MT_ST_DENSITY_SHIFT;
773 if (!STp->blksize_changed &&
774 STm->default_blksize >= 0 &&
775 STm->default_blksize != STp->block_size) {
776 arg |= STm->default_blksize;
777 set_it = 1;
778 } else
779 arg |= STp->block_size;
780 if (set_it &&
781 st_int_ioctl(STp, SET_DENS_AND_BLK, arg)) {
782 printk(KERN_WARNING
783 "%s: Can't set default block size to %d bytes and density %x.\n",
784 name, STm->default_blksize, STm->default_density);
785 if (modes_defined)
786 return (-EINVAL);
787 }
788 return 0;
789}
790
791
8b05b773 792/* Lock or unlock the drive door. Don't use when st_request allocated. */
1da177e4
LT		 793static int do_door_lock(struct scsi_tape * STp, int do_lock)
794{
795 int retval, cmd;
796 DEB(char *name = tape_name(STp);)
797
798
799 cmd = do_lock ? SCSI_IOCTL_DOORLOCK : SCSI_IOCTL_DOORUNLOCK;
800 DEBC(printk(ST_DEB_MSG "%s: %socking drive door.\n", name,
801 do_lock ? "L" : "Unl"));
802 retval = scsi_ioctl(STp->device, cmd, NULL);
803 if (!retval) {
804 STp->door_locked = do_lock ? ST_LOCKED_EXPLICIT : ST_UNLOCKED;
805 }
806 else {
807 STp->door_locked = ST_LOCK_FAILS;
808 }
809 return retval;
810}
811
812
813/* Set the internal state after reset */
814static void reset_state(struct scsi_tape *STp)
815{
816 int i;
817 struct st_partstat *STps;
818
819 STp->pos_unknown = 0;
820 for (i = 0; i < ST_NBR_PARTITIONS; i++) {
821 STps = &(STp->ps[i]);
822 STps->rw = ST_IDLE;
823 STps->eof = ST_NOEOF;
824 STps->at_sm = 0;
825 STps->last_block_valid = 0;
826 STps->drv_block = -1;
827 STps->drv_file = -1;
828 }
829 if (STp->can_partitions) {
830 STp->partition = find_partition(STp);
831 if (STp->partition < 0)
832 STp->partition = 0;
833 STp->new_partition = STp->partition;
834 }
835}
836\f
837/* Test if the drive is ready. Returns either one of the codes below or a negative system
838 error code. */
839#define CHKRES_READY 0
840#define CHKRES_NEW_SESSION 1
841#define CHKRES_NOT_READY 2
842#define CHKRES_NO_TAPE 3
843
844#define MAX_ATTENTIONS 10
845
846static int test_ready(struct scsi_tape *STp, int do_wait)
847{
848 int attentions, waits, max_wait, scode;
849 int retval = CHKRES_READY, new_session = 0;
850 unsigned char cmd[MAX_COMMAND_SIZE];
8b05b773 851 struct st_request *SRpnt = NULL;
1da177e4
LT		 852 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
853
854 max_wait = do_wait ? ST_BLOCK_SECONDS : 0;
855
856 for (attentions=waits=0; ; ) {
857 memset((void *) &cmd[0], 0, MAX_COMMAND_SIZE);
858 cmd[0] = TEST_UNIT_READY;
859 SRpnt = st_do_scsi(SRpnt, STp, cmd, 0, DMA_NONE,
860 STp->long_timeout, MAX_READY_RETRIES, 1);
861
862 if (!SRpnt) {
863 retval = (STp->buffer)->syscall_result;
864 break;
865 }
866
867 if (cmdstatp->have_sense) {
868
869 scode = cmdstatp->sense_hdr.sense_key;
870
871 if (scode == UNIT_ATTENTION) { /* New media? */
872 new_session = 1;
873 if (attentions < MAX_ATTENTIONS) {
874 attentions++;
875 continue;
876 }
877 else {
878 retval = (-EIO);
879 break;
880 }
881 }
882
883 if (scode == NOT_READY) {
884 if (waits < max_wait) {
885 if (msleep_interruptible(1000)) {
886 retval = (-EINTR);
887 break;
888 }
889 waits++;
890 continue;
891 }
892 else {
893 if ((STp->device)->scsi_level >= SCSI_2 &&
894 cmdstatp->sense_hdr.asc == 0x3a) /* Check ASC */
895 retval = CHKRES_NO_TAPE;
896 else
897 retval = CHKRES_NOT_READY;
898 break;
899 }
900 }
901 }
902
903 retval = (STp->buffer)->syscall_result;
904 if (!retval)
905 retval = new_session ? CHKRES_NEW_SESSION : CHKRES_READY;
906 break;
907 }
908
909 if (SRpnt != NULL)
8b05b773 910 st_release_request(SRpnt);
1da177e4
LT		 911 return retval;
912}
913
914
915/* See if the drive is ready and gather information about the tape. Return values:
916 < 0 negative error code from errno.h
917 0 drive ready
918 1 drive not ready (possibly no tape)
919*/
920static int check_tape(struct scsi_tape *STp, struct file *filp)
921{
922 int i, retval, new_session = 0, do_wait;
923 unsigned char cmd[MAX_COMMAND_SIZE], saved_cleaning;
924 unsigned short st_flags = filp->f_flags;
8b05b773 925 struct st_request *SRpnt = NULL;
1da177e4
LT		 926 struct st_modedef *STm;
927 struct st_partstat *STps;
928 char *name = tape_name(STp);
7ac6207b 929 struct inode *inode = filp->f_path.dentry->d_inode;
1da177e4
LT		 930 int mode = TAPE_MODE(inode);
931
932 STp->ready = ST_READY;
933
934 if (mode != STp->current_mode) {
935 DEBC(printk(ST_DEB_MSG "%s: Mode change from %d to %d.\n",
936 name, STp->current_mode, mode));
937 new_session = 1;
938 STp->current_mode = mode;
939 }
940 STm = &(STp->modes[STp->current_mode]);
941
942 saved_cleaning = STp->cleaning_req;
943 STp->cleaning_req = 0;
944
945 do_wait = ((filp->f_flags & O_NONBLOCK) == 0);
946 retval = test_ready(STp, do_wait);
947
948 if (retval < 0)
949 goto err_out;
950
951 if (retval == CHKRES_NEW_SESSION) {
952 STp->pos_unknown = 0;
953 STp->partition = STp->new_partition = 0;
954 if (STp->can_partitions)
955 STp->nbr_partitions = 1; /* This guess will be updated later
956 if necessary */
957 for (i = 0; i < ST_NBR_PARTITIONS; i++) {
958 STps = &(STp->ps[i]);
959 STps->rw = ST_IDLE;
960 STps->eof = ST_NOEOF;
961 STps->at_sm = 0;
962 STps->last_block_valid = 0;
963 STps->drv_block = 0;
964 STps->drv_file = 0;
965 }
966 new_session = 1;
967 }
968 else {
969 STp->cleaning_req |= saved_cleaning;
970
971 if (retval == CHKRES_NOT_READY || retval == CHKRES_NO_TAPE) {
972 if (retval == CHKRES_NO_TAPE)
973 STp->ready = ST_NO_TAPE;
974 else
975 STp->ready = ST_NOT_READY;
976
977 STp->density = 0; /* Clear the erroneous "residue" */
978 STp->write_prot = 0;
979 STp->block_size = 0;
980 STp->ps[0].drv_file = STp->ps[0].drv_block = (-1);
981 STp->partition = STp->new_partition = 0;
982 STp->door_locked = ST_UNLOCKED;
983 return CHKRES_NOT_READY;
984 }
985 }
986
987 if (STp->omit_blklims)
988 STp->min_block = STp->max_block = (-1);
989 else {
990 memset((void *) &cmd[0], 0, MAX_COMMAND_SIZE);
991 cmd[0] = READ_BLOCK_LIMITS;
992
993 SRpnt = st_do_scsi(SRpnt, STp, cmd, 6, DMA_FROM_DEVICE,
994 STp->device->timeout, MAX_READY_RETRIES, 1);
995 if (!SRpnt) {
996 retval = (STp->buffer)->syscall_result;
997 goto err_out;
998 }
999
8b05b773 1000 if (!SRpnt->result && !STp->buffer->cmdstat.have_sense) {
1da177e4
LT		 1001 STp->max_block = ((STp->buffer)->b_data[1] << 16) |
1002 ((STp->buffer)->b_data[2] << 8) | (STp->buffer)->b_data[3];
1003 STp->min_block = ((STp->buffer)->b_data[4] << 8) |
1004 (STp->buffer)->b_data[5];
1005 if ( DEB( debugging || ) !STp->inited)
42252854 1006 printk(KERN_INFO
1da177e4
LT		 1007 "%s: Block limits %d - %d bytes.\n", name,
1008 STp->min_block, STp->max_block);
1009 } else {
1010 STp->min_block = STp->max_block = (-1);
1011 DEBC(printk(ST_DEB_MSG "%s: Can't read block limits.\n",
1012 name));
1013 }
1014 }
1015
1016 memset((void *) &cmd[0], 0, MAX_COMMAND_SIZE);
1017 cmd[0] = MODE_SENSE;
1018 cmd[4] = 12;
1019
1020 SRpnt = st_do_scsi(SRpnt, STp, cmd, 12, DMA_FROM_DEVICE,
1021 STp->device->timeout, MAX_READY_RETRIES, 1);
1022 if (!SRpnt) {
1023 retval = (STp->buffer)->syscall_result;
1024 goto err_out;
1025 }
1026
1027 if ((STp->buffer)->syscall_result != 0) {
1028 DEBC(printk(ST_DEB_MSG "%s: No Mode Sense.\n", name));
1029 STp->block_size = ST_DEFAULT_BLOCK; /* Educated guess (?) */
1030 (STp->buffer)->syscall_result = 0; /* Prevent error propagation */
1031 STp->drv_write_prot = 0;
1032 } else {
1033 DEBC(printk(ST_DEB_MSG
1034 "%s: Mode sense. Length %d, medium %x, WBS %x, BLL %d\n",
1035 name,
1036 (STp->buffer)->b_data[0], (STp->buffer)->b_data[1],
1037 (STp->buffer)->b_data[2], (STp->buffer)->b_data[3]));
1038
1039 if ((STp->buffer)->b_data[3] >= 8) {
1040 STp->drv_buffer = ((STp->buffer)->b_data[2] >> 4) & 7;
1041 STp->density = (STp->buffer)->b_data[4];
1042 STp->block_size = (STp->buffer)->b_data[9] * 65536 +
1043 (STp->buffer)->b_data[10] * 256 + (STp->buffer)->b_data[11];
1044 DEBC(printk(ST_DEB_MSG
1045 "%s: Density %x, tape length: %x, drv buffer: %d\n",
1046 name, STp->density, (STp->buffer)->b_data[5] * 65536 +
1047 (STp->buffer)->b_data[6] * 256 + (STp->buffer)->b_data[7],
1048 STp->drv_buffer));
1049 }
1050 STp->drv_write_prot = ((STp->buffer)->b_data[2] & 0x80) != 0;
1051 }
8b05b773 1052 st_release_request(SRpnt);
1da177e4
LT		 1053 SRpnt = NULL;
1054 STp->inited = 1;
1055
1056 if (STp->block_size > 0)
1057 (STp->buffer)->buffer_blocks =
1058 (STp->buffer)->buffer_size / STp->block_size;
1059 else
1060 (STp->buffer)->buffer_blocks = 1;
1061 (STp->buffer)->buffer_bytes = (STp->buffer)->read_pointer = 0;
1062
1063 DEBC(printk(ST_DEB_MSG
1064 "%s: Block size: %d, buffer size: %d (%d blocks).\n", name,
1065 STp->block_size, (STp->buffer)->buffer_size,
1066 (STp->buffer)->buffer_blocks));
1067
1068 if (STp->drv_write_prot) {
1069 STp->write_prot = 1;
1070
1071 DEBC(printk(ST_DEB_MSG "%s: Write protected\n", name));
1072
1073 if (do_wait &&
1074 ((st_flags & O_ACCMODE) == O_WRONLY ||
1075 (st_flags & O_ACCMODE) == O_RDWR)) {
1076 retval = (-EROFS);
1077 goto err_out;
1078 }
1079 }
1080
1081 if (STp->can_partitions && STp->nbr_partitions < 1) {
1082 /* This code is reached when the device is opened for the first time
1083 after the driver has been initialized with tape in the drive and the
1084 partition support has been enabled. */
1085 DEBC(printk(ST_DEB_MSG
1086 "%s: Updating partition number in status.\n", name));
1087 if ((STp->partition = find_partition(STp)) < 0) {
1088 retval = STp->partition;
1089 goto err_out;
1090 }
1091 STp->new_partition = STp->partition;
1092 STp->nbr_partitions = 1; /* This guess will be updated when necessary */
1093 }
1094
1095 if (new_session) { /* Change the drive parameters for the new mode */
1096 STp->density_changed = STp->blksize_changed = 0;
1097 STp->compression_changed = 0;
1098 if (!(STm->defaults_for_writes) &&
1099 (retval = set_mode_densblk(STp, STm)) < 0)
1100 goto err_out;
1101
1102 if (STp->default_drvbuffer != 0xff) {
1103 if (st_int_ioctl(STp, MTSETDRVBUFFER, STp->default_drvbuffer))
1104 printk(KERN_WARNING
1105 "%s: Can't set default drive buffering to %d.\n",
1106 name, STp->default_drvbuffer);
1107 }
1108 }
1109
1110 return CHKRES_READY;
1111
1112 err_out:
1113 return retval;
1114}
1115
1116
b3369c68 1117\f/* Open the device. Needs to take the BKL only because of incrementing the SCSI host
1da177e4
LT		 1118 module count. */
1119static int st_open(struct inode *inode, struct file *filp)
1120{
1121 int i, retval = (-EIO);
1122 struct scsi_tape *STp;
1123 struct st_partstat *STps;
1124 int dev = TAPE_NR(inode);
1125 char *name;
1126
b3369c68 1127 lock_kernel();
1da177e4
LT		 1128 /*
1129 * We really want to do nonseekable_open(inode, filp); here, but some
1130 * versions of tar incorrectly call lseek on tapes and bail out if that
1131 * fails. So we disallow pread() and pwrite(), but permit lseeks.
1132 */
1133 filp->f_mode &= ~(FMODE_PREAD | FMODE_PWRITE);
1134
b3369c68
JC		 1135 if (!(STp = scsi_tape_get(dev))) {
1136 unlock_kernel();
f03a5670 1137 return -ENXIO;
b3369c68 1138 }
f03a5670 1139
1da177e4 1140 write_lock(&st_dev_arr_lock);
1da177e4
LT		 1141 filp->private_data = STp;
1142 name = tape_name(STp);
1143
1144 if (STp->in_use) {
1145 write_unlock(&st_dev_arr_lock);
f03a5670 1146 scsi_tape_put(STp);
b3369c68 1147 unlock_kernel();
1da177e4
LT		 1148 DEB( printk(ST_DEB_MSG "%s: Device already in use.\n", name); )
1149 return (-EBUSY);
1150 }
1151
1da177e4
LT		 1152 STp->in_use = 1;
1153 write_unlock(&st_dev_arr_lock);
1154 STp->rew_at_close = STp->autorew_dev = (iminor(inode) & 0x80) == 0;
1155
1156 if (!scsi_block_when_processing_errors(STp->device)) {
1157 retval = (-ENXIO);
1158 goto err_out;
1159 }
1160
1161 /* See that we have at least a one page buffer available */
1162 if (!enlarge_buffer(STp->buffer, PAGE_SIZE, STp->restr_dma)) {
1163 printk(KERN_WARNING "%s: Can't allocate one page tape buffer.\n",
1164 name);
1165 retval = (-EOVERFLOW);
1166 goto err_out;
1167 }
1168
40f6b36c 1169 (STp->buffer)->cleared = 0;
1da177e4
LT		 1170 (STp->buffer)->writing = 0;
1171 (STp->buffer)->syscall_result = 0;
1172
1173 STp->write_prot = ((filp->f_flags & O_ACCMODE) == O_RDONLY);
1174
1175 STp->dirty = 0;
1176 for (i = 0; i < ST_NBR_PARTITIONS; i++) {
1177 STps = &(STp->ps[i]);
1178 STps->rw = ST_IDLE;
1179 }
9abe16c6 1180 STp->try_dio_now = STp->try_dio;
1da177e4
LT		 1181 STp->recover_count = 0;
1182 DEB( STp->nbr_waits = STp->nbr_finished = 0;
deee13df 1183 STp->nbr_requests = STp->nbr_dio = STp->nbr_pages = 0; )
1da177e4
LT		 1184
1185 retval = check_tape(STp, filp);
1186 if (retval < 0)
1187 goto err_out;
1188 if ((filp->f_flags & O_NONBLOCK) == 0 &&
1189 retval != CHKRES_READY) {
413f7327
KM		 1190 if (STp->ready == NO_TAPE)
1191 retval = (-ENOMEDIUM);
1192 else
1193 retval = (-EIO);
1da177e4
LT		 1194 goto err_out;
1195 }
b3369c68 1196 unlock_kernel();
1da177e4
LT		 1197 return 0;
1198
1199 err_out:
1200 normalize_buffer(STp->buffer);
1201 STp->in_use = 0;
f03a5670 1202 scsi_tape_put(STp);
b3369c68 1203 unlock_kernel();
1da177e4
LT		 1204 return retval;
1205
1206}
1207\f
1208
1209/* Flush the tape buffer before close */
75e1fcc0 1210static int st_flush(struct file *filp, fl_owner_t id)
1da177e4
LT		 1211{
1212 int result = 0, result2;
1213 unsigned char cmd[MAX_COMMAND_SIZE];
8b05b773 1214 struct st_request *SRpnt;
1da177e4
LT		 1215 struct scsi_tape *STp = filp->private_data;
1216 struct st_modedef *STm = &(STp->modes[STp->current_mode]);
1217 struct st_partstat *STps = &(STp->ps[STp->partition]);
1218 char *name = tape_name(STp);
1219
1220 if (file_count(filp) > 1)
1221 return 0;
1222
1223 if (STps->rw == ST_WRITING && !STp->pos_unknown) {
8ef8d594 1224 result = st_flush_write_buffer(STp);
1da177e4
LT		 1225 if (result != 0 && result != (-ENOSPC))
1226 goto out;
1227 }
1228
1229 if (STp->can_partitions &&
1230 (result2 = switch_partition(STp)) < 0) {
1231 DEBC(printk(ST_DEB_MSG
1232 "%s: switch_partition at close failed.\n", name));
1233 if (result == 0)
1234 result = result2;
1235 goto out;
1236 }
1237
1238 DEBC( if (STp->nbr_requests)
deee13df
KM		 1239 printk(KERN_DEBUG "%s: Number of r/w requests %d, dio used in %d, pages %d.\n",
1240 name, STp->nbr_requests, STp->nbr_dio, STp->nbr_pages));
1da177e4
LT		 1241
1242 if (STps->rw == ST_WRITING && !STp->pos_unknown) {
1243 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
1244
1245 DEBC(printk(ST_DEB_MSG "%s: Async write waits %d, finished %d.\n",
1246 name, STp->nbr_waits, STp->nbr_finished);
1247 )
1248
1249 memset(cmd, 0, MAX_COMMAND_SIZE);
1250 cmd[0] = WRITE_FILEMARKS;
1251 cmd[4] = 1 + STp->two_fm;
1252
1253 SRpnt = st_do_scsi(NULL, STp, cmd, 0, DMA_NONE,
1254 STp->device->timeout, MAX_WRITE_RETRIES, 1);
1255 if (!SRpnt) {
1256 result = (STp->buffer)->syscall_result;
1257 goto out;
1258 }
1259
1260 if (STp->buffer->syscall_result == 0 ||
1261 (cmdstatp->have_sense && !cmdstatp->deferred &&
1262 (cmdstatp->flags & SENSE_EOM) &&
1263 (cmdstatp->sense_hdr.sense_key == NO_SENSE ||
1264 cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR) &&
1265 (!cmdstatp->remainder_valid || cmdstatp->uremainder64 == 0))) {
1266 /* Write successful at EOM */
8b05b773 1267 st_release_request(SRpnt);
1da177e4
LT		 1268 SRpnt = NULL;
1269 if (STps->drv_file >= 0)
1270 STps->drv_file++;
1271 STps->drv_block = 0;
1272 if (STp->two_fm)
1273 cross_eof(STp, 0);
1274 STps->eof = ST_FM;
1275 }
1276 else { /* Write error */
8b05b773 1277 st_release_request(SRpnt);
1da177e4
LT		 1278 SRpnt = NULL;
1279 printk(KERN_ERR "%s: Error on write filemark.\n", name);
1280 if (result == 0)
1281 result = (-EIO);
1282 }
1283
1284 DEBC(printk(ST_DEB_MSG "%s: Buffer flushed, %d EOF(s) written\n",
1285 name, cmd[4]));
1286 } else if (!STp->rew_at_close) {
1287 STps = &(STp->ps[STp->partition]);
1288 if (!STm->sysv || STps->rw != ST_READING) {
1289 if (STp->can_bsr)
1290 result = flush_buffer(STp, 0);
1291 else if (STps->eof == ST_FM_HIT) {
1292 result = cross_eof(STp, 0);
1293 if (result) {
1294 if (STps->drv_file >= 0)
1295 STps->drv_file++;
1296 STps->drv_block = 0;
1297 STps->eof = ST_FM;
1298 } else
1299 STps->eof = ST_NOEOF;
1300 }
1301 } else if ((STps->eof == ST_NOEOF &&
1302 !(result = cross_eof(STp, 1))) ||
1303 STps->eof == ST_FM_HIT) {
1304 if (STps->drv_file >= 0)
1305 STps->drv_file++;
1306 STps->drv_block = 0;
1307 STps->eof = ST_FM;
1308 }
1309 }
1310
1311 out:
1312 if (STp->rew_at_close) {
1313 result2 = st_int_ioctl(STp, MTREW, 1);
1314 if (result == 0)
1315 result = result2;
1316 }
1317 return result;
1318}
1319
1320
1321/* Close the device and release it. BKL is not needed: this is the only thread
1322 accessing this tape. */
1323static int st_release(struct inode *inode, struct file *filp)
1324{
1325 int result = 0;
1326 struct scsi_tape *STp = filp->private_data;
1327
1328 if (STp->door_locked == ST_LOCKED_AUTO)
1329 do_door_lock(STp, 0);
1330
1331 normalize_buffer(STp->buffer);
1332 write_lock(&st_dev_arr_lock);
1333 STp->in_use = 0;
1334 write_unlock(&st_dev_arr_lock);
f03a5670 1335 scsi_tape_put(STp);
1da177e4
LT		 1336
1337 return result;
1338}
1339\f
1340/* The checks common to both reading and writing */
1341static ssize_t rw_checks(struct scsi_tape *STp, struct file *filp, size_t count)
1342{
1343 ssize_t retval = 0;
1344
1345 /*
1346 * If we are in the middle of error recovery, don't let anyone
1347 * else try and use this device. Also, if error recovery fails, it
1348 * may try and take the device offline, in which case all further
1349 * access to the device is prohibited.
1350 */
1351 if (!scsi_block_when_processing_errors(STp->device)) {
1352 retval = (-ENXIO);
1353 goto out;
1354 }
1355
1356 if (STp->ready != ST_READY) {
1357 if (STp->ready == ST_NO_TAPE)
1358 retval = (-ENOMEDIUM);
1359 else
1360 retval = (-EIO);
1361 goto out;
1362 }
1363
1364 if (! STp->modes[STp->current_mode].defined) {
1365 retval = (-ENXIO);
1366 goto out;
1367 }
1368
1369
1370 /*
1371 * If there was a bus reset, block further access
1372 * to this device.
1373 */
1374 if (STp->pos_unknown) {
1375 retval = (-EIO);
1376 goto out;
1377 }
1378
1379 if (count == 0)
1380 goto out;
1381
1382 DEB(
1383 if (!STp->in_use) {
1384 printk(ST_DEB_MSG "%s: Incorrect device.\n", tape_name(STp));
1385 retval = (-EIO);
1386 goto out;
1387 } ) /* end DEB */
1388
1389 if (STp->can_partitions &&
1390 (retval = switch_partition(STp)) < 0)
1391 goto out;
1392
1393 if (STp->block_size == 0 && STp->max_block > 0 &&
1394 (count < STp->min_block || count > STp->max_block)) {
1395 retval = (-EINVAL);
1396 goto out;
1397 }
1398
1399 if (STp->do_auto_lock && STp->door_locked == ST_UNLOCKED &&
1400 !do_door_lock(STp, 1))
1401 STp->door_locked = ST_LOCKED_AUTO;
1402
1403 out:
1404 return retval;
1405}
1406
1407
1408static int setup_buffering(struct scsi_tape *STp, const char __user *buf,
1409 size_t count, int is_read)
1410{
1411 int i, bufsize, retval = 0;
1412 struct st_buffer *STbp = STp->buffer;
1413
1414 if (is_read)
9abe16c6 1415 i = STp->try_dio_now && try_rdio;
1da177e4 1416 else
9abe16c6 1417 i = STp->try_dio_now && try_wdio;
8b05b773 1418
1da177e4
LT		 1419 if (i && ((unsigned long)buf & queue_dma_alignment(
1420 STp->device->request_queue)) == 0) {
8b05b773
MC		 1421 i = sgl_map_user_pages(&(STbp->sg[0]), STbp->use_sg,
1422 (unsigned long)buf, count, (is_read ? READ : WRITE));
1da177e4
LT		 1423 if (i > 0) {
1424 STbp->do_dio = i;
1425 STbp->buffer_bytes = 0; /* can be used as transfer counter */
1426 }
1427 else
1428 STbp->do_dio = 0; /* fall back to buffering with any error */
1429 STbp->sg_segs = STbp->do_dio;
1430 STbp->frp_sg_current = 0;
1431 DEB(
1432 if (STbp->do_dio) {
1433 STp->nbr_dio++;
1434 STp->nbr_pages += STbp->do_dio;
1da177e4
LT		 1435 }
1436 )
1437 } else
1438 STbp->do_dio = 0;
1439 DEB( STp->nbr_requests++; )
1440
1441 if (!STbp->do_dio) {
1442 if (STp->block_size)
1443 bufsize = STp->block_size > st_fixed_buffer_size ?
1444 STp->block_size : st_fixed_buffer_size;
40f6b36c 1445 else {
1da177e4 1446 bufsize = count;
40f6b36c
KM		 1447 /* Make sure that data from previous user is not leaked even if
1448 HBA does not return correct residual */
1449 if (is_read && STp->sili && !STbp->cleared)
1450 clear_buffer(STbp);
1451 }
1452
1da177e4
LT		 1453 if (bufsize > STbp->buffer_size &&
1454 !enlarge_buffer(STbp, bufsize, STp->restr_dma)) {
1455 printk(KERN_WARNING "%s: Can't allocate %d byte tape buffer.\n",
1456 tape_name(STp), bufsize);
1457 retval = (-EOVERFLOW);
1458 goto out;
1459 }
1460 if (STp->block_size)
1461 STbp->buffer_blocks = bufsize / STp->block_size;
1462 }
1463
1464 out:
1465 return retval;
1466}
1467
1468
1469/* Can be called more than once after each setup_buffer() */
787926b1 1470static void release_buffering(struct scsi_tape *STp, int is_read)
1da177e4
LT		 1471{
1472 struct st_buffer *STbp;
1473
1474 STbp = STp->buffer;
1475 if (STbp->do_dio) {
787926b1 1476 sgl_unmap_user_pages(&(STbp->sg[0]), STbp->do_dio, is_read);
1da177e4 1477 STbp->do_dio = 0;
787926b1 1478 STbp->sg_segs = 0;
1da177e4
LT		 1479 }
1480}
1481
1482
1483/* Write command */
1484static ssize_t
1485st_write(struct file *filp, const char __user *buf, size_t count, loff_t * ppos)
1486{
1487 ssize_t total;
1488 ssize_t i, do_count, blks, transfer;
1489 ssize_t retval;
1490 int undone, retry_eot = 0, scode;
1491 int async_write;
1492 unsigned char cmd[MAX_COMMAND_SIZE];
1493 const char __user *b_point;
8b05b773 1494 struct st_request *SRpnt = NULL;
1da177e4
LT		 1495 struct scsi_tape *STp = filp->private_data;
1496 struct st_modedef *STm;
1497 struct st_partstat *STps;
1498 struct st_buffer *STbp;
1499 char *name = tape_name(STp);
1500
28f85009 1501 if (mutex_lock_interruptible(&STp->lock))
1da177e4
LT		 1502 return -ERESTARTSYS;
1503
1504 retval = rw_checks(STp, filp, count);
1505 if (retval || count == 0)
1506 goto out;
1507
1508 /* Write must be integral number of blocks */
1509 if (STp->block_size != 0 && (count % STp->block_size) != 0) {
1510 printk(KERN_WARNING "%s: Write not multiple of tape block size.\n",
1511 name);
1512 retval = (-EINVAL);
1513 goto out;
1514 }
1515
1516 STm = &(STp->modes[STp->current_mode]);
1517 STps = &(STp->ps[STp->partition]);
1518
1519 if (STp->write_prot) {
1520 retval = (-EACCES);
1521 goto out;
1522 }
1523
1524
1525 if (STps->rw == ST_READING) {
1526 retval = flush_buffer(STp, 0);
1527 if (retval)
1528 goto out;
1529 STps->rw = ST_WRITING;
1530 } else if (STps->rw != ST_WRITING &&
1531 STps->drv_file == 0 && STps->drv_block == 0) {
1532 if ((retval = set_mode_densblk(STp, STm)) < 0)
1533 goto out;
1534 if (STm->default_compression != ST_DONT_TOUCH &&
1535 !(STp->compression_changed)) {
1536 if (st_compression(STp, (STm->default_compression == ST_YES))) {
1537 printk(KERN_WARNING "%s: Can't set default compression.\n",
1538 name);
1539 if (modes_defined) {
1540 retval = (-EINVAL);
1541 goto out;
1542 }
1543 }
1544 }
1545 }
1546
1547 STbp = STp->buffer;
1548 i = write_behind_check(STp);
1549 if (i) {
1550 if (i == -ENOSPC)
1551 STps->eof = ST_EOM_OK;
1552 else
1553 STps->eof = ST_EOM_ERROR;
1554 }
1555
1556 if (STps->eof == ST_EOM_OK) {
1557 STps->eof = ST_EOD_1; /* allow next write */
1558 retval = (-ENOSPC);
1559 goto out;
1560 }
1561 else if (STps->eof == ST_EOM_ERROR) {
1562 retval = (-EIO);
1563 goto out;
1564 }
1565
1566 /* Check the buffer readability in cases where copy_user might catch
1567 the problems after some tape movement. */
1568 if (STp->block_size != 0 &&
1569 !STbp->do_dio &&
1570 (copy_from_user(&i, buf, 1) != 0 ||
1571 copy_from_user(&i, buf + count - 1, 1) != 0)) {
1572 retval = (-EFAULT);
1573 goto out;
1574 }
1575
1576 retval = setup_buffering(STp, buf, count, 0);
1577 if (retval)
1578 goto out;
1579
1580 total = count;
1581
1582 memset(cmd, 0, MAX_COMMAND_SIZE);
1583 cmd[0] = WRITE_6;
1584 cmd[1] = (STp->block_size != 0);
1585
1586 STps->rw = ST_WRITING;
1587
1588 b_point = buf;
1589 while (count > 0 && !retry_eot) {
1590
1591 if (STbp->do_dio) {
1592 do_count = count;
1593 }
1594 else {
1595 if (STp->block_size == 0)
1596 do_count = count;
1597 else {
1598 do_count = STbp->buffer_blocks * STp->block_size -
1599 STbp->buffer_bytes;
1600 if (do_count > count)
1601 do_count = count;
1602 }
1603
1604 i = append_to_buffer(b_point, STbp, do_count);
1605 if (i) {
1606 retval = i;
1607 goto out;
1608 }
1609 }
1610 count -= do_count;
1611 b_point += do_count;
1612
1613 async_write = STp->block_size == 0 && !STbp->do_dio &&
1614 STm->do_async_writes && STps->eof < ST_EOM_OK;
1615
1616 if (STp->block_size != 0 && STm->do_buffer_writes &&
9abe16c6 1617 !(STp->try_dio_now && try_wdio) && STps->eof < ST_EOM_OK &&
1da177e4
LT		 1618 STbp->buffer_bytes < STbp->buffer_size) {
1619 STp->dirty = 1;
1620 /* Don't write a buffer that is not full enough. */
1621 if (!async_write && count == 0)
1622 break;
1623 }
1624
1625 retry_write:
1626 if (STp->block_size == 0)
1627 blks = transfer = do_count;
1628 else {
1629 if (!STbp->do_dio)
1630 blks = STbp->buffer_bytes;
1631 else
1632 blks = do_count;
1633 blks /= STp->block_size;
1634 transfer = blks * STp->block_size;
1635 }
1636 cmd[2] = blks >> 16;
1637 cmd[3] = blks >> 8;
1638 cmd[4] = blks;
1639
1640 SRpnt = st_do_scsi(SRpnt, STp, cmd, transfer, DMA_TO_DEVICE,
1641 STp->device->timeout, MAX_WRITE_RETRIES, !async_write);
1642 if (!SRpnt) {
1643 retval = STbp->syscall_result;
1644 goto out;
1645 }
8b05b773 1646 if (async_write && !STbp->syscall_result) {
1da177e4
LT		 1647 STbp->writing = transfer;
1648 STp->dirty = !(STbp->writing ==
1649 STbp->buffer_bytes);
1650 SRpnt = NULL; /* Prevent releasing this request! */
1651 DEB( STp->write_pending = 1; )
1652 break;
1653 }
1654
1655 if (STbp->syscall_result != 0) {
1656 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
1657
1658 DEBC(printk(ST_DEB_MSG "%s: Error on write:\n", name));
1659 if (cmdstatp->have_sense && (cmdstatp->flags & SENSE_EOM)) {
1660 scode = cmdstatp->sense_hdr.sense_key;
1661 if (cmdstatp->remainder_valid)
1662 undone = (int)cmdstatp->uremainder64;
1663 else if (STp->block_size == 0 &&
1664 scode == VOLUME_OVERFLOW)
1665 undone = transfer;
1666 else
1667 undone = 0;
1668 if (STp->block_size != 0)
1669 undone *= STp->block_size;
1670 if (undone <= do_count) {
1671 /* Only data from this write is not written */
1672 count += undone;
626dcb1e 1673 b_point -= undone;
1da177e4
LT		 1674 do_count -= undone;
1675 if (STp->block_size)
1676 blks = (transfer - undone) / STp->block_size;
1677 STps->eof = ST_EOM_OK;
1678 /* Continue in fixed block mode if all written
1679 in this request but still something left to write
1680 (retval left to zero)
1681 */
1682 if (STp->block_size == 0 ||
1683 undone > 0 || count == 0)
1684 retval = (-ENOSPC); /* EOM within current request */
1685 DEBC(printk(ST_DEB_MSG
1686 "%s: EOM with %d bytes unwritten.\n",
1687 name, (int)count));
1688 } else {
1689 /* EOT within data buffered earlier (possible only
1690 in fixed block mode without direct i/o) */
1691 if (!retry_eot && !cmdstatp->deferred &&
1692 (scode == NO_SENSE || scode == RECOVERED_ERROR)) {
1693 move_buffer_data(STp->buffer, transfer - undone);
1694 retry_eot = 1;
1695 if (STps->drv_block >= 0) {
1696 STps->drv_block += (transfer - undone) /
1697 STp->block_size;
1698 }
1699 STps->eof = ST_EOM_OK;
1700 DEBC(printk(ST_DEB_MSG
1701 "%s: Retry write of %d bytes at EOM.\n",
1702 name, STp->buffer->buffer_bytes));
1703 goto retry_write;
1704 }
1705 else {
1706 /* Either error within data buffered by driver or
1707 failed retry */
1708 count -= do_count;
1709 blks = do_count = 0;
1710 STps->eof = ST_EOM_ERROR;
1711 STps->drv_block = (-1); /* Too cautious? */
1712 retval = (-EIO); /* EOM for old data */
1713 DEBC(printk(ST_DEB_MSG
1714 "%s: EOM with lost data.\n",
1715 name));
1716 }
1717 }
1718 } else {
1719 count += do_count;
1720 STps->drv_block = (-1); /* Too cautious? */
8b05b773 1721 retval = STbp->syscall_result;
1da177e4
LT		 1722 }
1723
1724 }
1725
1726 if (STps->drv_block >= 0) {
1727 if (STp->block_size == 0)
1728 STps->drv_block += (do_count > 0);
1729 else
1730 STps->drv_block += blks;
1731 }
1732
1733 STbp->buffer_bytes = 0;
1734 STp->dirty = 0;
1735
1736 if (retval || retry_eot) {
1737 if (count < total)
1738 retval = total - count;
1739 goto out;
1740 }
1741 }
1742
1743 if (STps->eof == ST_EOD_1)
1744 STps->eof = ST_EOM_OK;
1745 else if (STps->eof != ST_EOM_OK)
1746 STps->eof = ST_NOEOF;
1747 retval = total - count;
1748
1749 out:
1750 if (SRpnt != NULL)
8b05b773 1751 st_release_request(SRpnt);
787926b1 1752 release_buffering(STp, 0);
28f85009 1753 mutex_unlock(&STp->lock);
1da177e4
LT		 1754
1755 return retval;
1756}
1757\f
1758/* Read data from the tape. Returns zero in the normal case, one if the
1759 eof status has changed, and the negative error code in case of a
1760 fatal error. Otherwise updates the buffer and the eof state.
1761
1762 Does release user buffer mapping if it is set.
1763*/
1764static long read_tape(struct scsi_tape *STp, long count,
8b05b773 1765 struct st_request ** aSRpnt)
1da177e4
LT		 1766{
1767 int transfer, blks, bytes;
1768 unsigned char cmd[MAX_COMMAND_SIZE];
8b05b773 1769 struct st_request *SRpnt;
1da177e4
LT		 1770 struct st_modedef *STm;
1771 struct st_partstat *STps;
1772 struct st_buffer *STbp;
1773 int retval = 0;
1774 char *name = tape_name(STp);
1775
1776 if (count == 0)
1777 return 0;
1778
1779 STm = &(STp->modes[STp->current_mode]);
1780 STps = &(STp->ps[STp->partition]);
1781 if (STps->eof == ST_FM_HIT)
1782 return 1;
1783 STbp = STp->buffer;
1784
1785 if (STp->block_size == 0)
1786 blks = bytes = count;
1787 else {
9abe16c6 1788 if (!(STp->try_dio_now && try_rdio) && STm->do_read_ahead) {
1da177e4
LT		 1789 blks = (STp->buffer)->buffer_blocks;
1790 bytes = blks * STp->block_size;
1791 } else {
1792 bytes = count;
1793 if (!STbp->do_dio && bytes > (STp->buffer)->buffer_size)
1794 bytes = (STp->buffer)->buffer_size;
1795 blks = bytes / STp->block_size;
1796 bytes = blks * STp->block_size;
1797 }
1798 }
1799
1800 memset(cmd, 0, MAX_COMMAND_SIZE);
1801 cmd[0] = READ_6;
1802 cmd[1] = (STp->block_size != 0);
40f6b36c
KM		 1803 if (!cmd[1] && STp->sili)
1804 cmd[1] |= 2;
1da177e4
LT		 1805 cmd[2] = blks >> 16;
1806 cmd[3] = blks >> 8;
1807 cmd[4] = blks;
1808
1809 SRpnt = *aSRpnt;
1810 SRpnt = st_do_scsi(SRpnt, STp, cmd, bytes, DMA_FROM_DEVICE,
1811 STp->device->timeout, MAX_RETRIES, 1);
787926b1 1812 release_buffering(STp, 1);
1da177e4
LT		 1813 *aSRpnt = SRpnt;
1814 if (!SRpnt)
1815 return STbp->syscall_result;
1816
1817 STbp->read_pointer = 0;
1818 STps->at_sm = 0;
1819
1820 /* Something to check */
1821 if (STbp->syscall_result) {
1822 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
1823
1824 retval = 1;
1825 DEBC(printk(ST_DEB_MSG "%s: Sense: %2x %2x %2x %2x %2x %2x %2x %2x\n",
1826 name,
8b05b773
MC		 1827 SRpnt->sense[0], SRpnt->sense[1],
1828 SRpnt->sense[2], SRpnt->sense[3],
1829 SRpnt->sense[4], SRpnt->sense[5],
1830 SRpnt->sense[6], SRpnt->sense[7]));
1da177e4
LT		 1831 if (cmdstatp->have_sense) {
1832
1833 if (cmdstatp->sense_hdr.sense_key == BLANK_CHECK)
1834 cmdstatp->flags &= 0xcf; /* No need for EOM in this case */
1835
1836 if (cmdstatp->flags != 0) { /* EOF, EOM, or ILI */
1837 /* Compute the residual count */
1838 if (cmdstatp->remainder_valid)
1839 transfer = (int)cmdstatp->uremainder64;
1840 else
1841 transfer = 0;
1842 if (STp->block_size == 0 &&
1843 cmdstatp->sense_hdr.sense_key == MEDIUM_ERROR)
1844 transfer = bytes;
1845
1846 if (cmdstatp->flags & SENSE_ILI) { /* ILI */
1847 if (STp->block_size == 0) {
1848 if (transfer <= 0) {
1849 if (transfer < 0)
1850 printk(KERN_NOTICE
1851 "%s: Failed to read %d byte block with %d byte transfer.\n",
1852 name, bytes - transfer, bytes);
1853 if (STps->drv_block >= 0)
1854 STps->drv_block += 1;
1855 STbp->buffer_bytes = 0;
1856 return (-ENOMEM);
1857 }
1858 STbp->buffer_bytes = bytes - transfer;
1859 } else {
8b05b773 1860 st_release_request(SRpnt);
1da177e4
LT		 1861 SRpnt = *aSRpnt = NULL;
1862 if (transfer == blks) { /* We did not get anything, error */
1863 printk(KERN_NOTICE "%s: Incorrect block size.\n", name);
1864 if (STps->drv_block >= 0)
1865 STps->drv_block += blks - transfer + 1;
1866 st_int_ioctl(STp, MTBSR, 1);
1867 return (-EIO);
1868 }
1869 /* We have some data, deliver it */
1870 STbp->buffer_bytes = (blks - transfer) *
1871 STp->block_size;
1872 DEBC(printk(ST_DEB_MSG
1873 "%s: ILI but enough data received %ld %d.\n",
1874 name, count, STbp->buffer_bytes));
1875 if (STps->drv_block >= 0)
1876 STps->drv_block += 1;
1877 if (st_int_ioctl(STp, MTBSR, 1))
1878 return (-EIO);
1879 }
1880 } else if (cmdstatp->flags & SENSE_FMK) { /* FM overrides EOM */
1881 if (STps->eof != ST_FM_HIT)
1882 STps->eof = ST_FM_HIT;
1883 else
1884 STps->eof = ST_EOD_2;
1885 if (STp->block_size == 0)
1886 STbp->buffer_bytes = 0;
1887 else
1888 STbp->buffer_bytes =
1889 bytes - transfer * STp->block_size;
1890 DEBC(printk(ST_DEB_MSG
1891 "%s: EOF detected (%d bytes read).\n",
1892 name, STbp->buffer_bytes));
1893 } else if (cmdstatp->flags & SENSE_EOM) {
1894 if (STps->eof == ST_FM)
1895 STps->eof = ST_EOD_1;
1896 else
1897 STps->eof = ST_EOM_OK;
1898 if (STp->block_size == 0)
1899 STbp->buffer_bytes = bytes - transfer;
1900 else
1901 STbp->buffer_bytes =
1902 bytes - transfer * STp->block_size;
1903
1904 DEBC(printk(ST_DEB_MSG "%s: EOM detected (%d bytes read).\n",
1905 name, STbp->buffer_bytes));
1906 }
1907 }
1908 /* end of EOF, EOM, ILI test */
1909 else { /* nonzero sense key */
1910 DEBC(printk(ST_DEB_MSG
1911 "%s: Tape error while reading.\n", name));
1912 STps->drv_block = (-1);
1913 if (STps->eof == ST_FM &&
1914 cmdstatp->sense_hdr.sense_key == BLANK_CHECK) {
1915 DEBC(printk(ST_DEB_MSG
1916 "%s: Zero returned for first BLANK CHECK after EOF.\n",
1917 name));
1918 STps->eof = ST_EOD_2; /* First BLANK_CHECK after FM */
1919 } else /* Some other extended sense code */
1920 retval = (-EIO);
1921 }
1922
1923 if (STbp->buffer_bytes < 0) /* Caused by bogus sense data */
1924 STbp->buffer_bytes = 0;
1925 }
1926 /* End of extended sense test */
1927 else { /* Non-extended sense */
1928 retval = STbp->syscall_result;
1929 }
1930
1931 }
1932 /* End of error handling */
40f6b36c 1933 else { /* Read successful */
1da177e4 1934 STbp->buffer_bytes = bytes;
40f6b36c
KM		 1935 if (STp->sili) /* In fixed block mode residual is always zero here */
1936 STbp->buffer_bytes -= STp->buffer->cmdstat.residual;
1937 }
1da177e4
LT		 1938
1939 if (STps->drv_block >= 0) {
1940 if (STp->block_size == 0)
1941 STps->drv_block++;
1942 else
1943 STps->drv_block += STbp->buffer_bytes / STp->block_size;
1944 }
1945 return retval;
1946}
1947\f
1948
1949/* Read command */
1950static ssize_t
1951st_read(struct file *filp, char __user *buf, size_t count, loff_t * ppos)
1952{
1953 ssize_t total;
1954 ssize_t retval = 0;
1955 ssize_t i, transfer;
1956 int special, do_dio = 0;
8b05b773 1957 struct st_request *SRpnt = NULL;
1da177e4
LT		 1958 struct scsi_tape *STp = filp->private_data;
1959 struct st_modedef *STm;
1960 struct st_partstat *STps;
1961 struct st_buffer *STbp = STp->buffer;
1962 DEB( char *name = tape_name(STp); )
1963
28f85009 1964 if (mutex_lock_interruptible(&STp->lock))
1da177e4
LT		 1965 return -ERESTARTSYS;
1966
1967 retval = rw_checks(STp, filp, count);
1968 if (retval || count == 0)
1969 goto out;
1970
1971 STm = &(STp->modes[STp->current_mode]);
9abe16c6
KM		 1972 if (STp->block_size != 0 && (count % STp->block_size) != 0) {
1973 if (!STm->do_read_ahead) {
1974 retval = (-EINVAL); /* Read must be integral number of blocks */
1975 goto out;
1976 }
1977 STp->try_dio_now = 0; /* Direct i/o can't handle split blocks */
1da177e4
LT		 1978 }
1979
1980 STps = &(STp->ps[STp->partition]);
1981 if (STps->rw == ST_WRITING) {
1982 retval = flush_buffer(STp, 0);
1983 if (retval)
1984 goto out;
1985 STps->rw = ST_READING;
1986 }
1987 DEB(
1988 if (debugging && STps->eof != ST_NOEOF)
1989 printk(ST_DEB_MSG "%s: EOF/EOM flag up (%d). Bytes %d\n", name,
1990 STps->eof, STbp->buffer_bytes);
1991 ) /* end DEB */
1992
1993 retval = setup_buffering(STp, buf, count, 1);
1994 if (retval)
1995 goto out;
1996 do_dio = STbp->do_dio;
1997
1998 if (STbp->buffer_bytes == 0 &&
1999 STps->eof >= ST_EOD_1) {
2000 if (STps->eof < ST_EOD) {
2001 STps->eof += 1;
2002 retval = 0;
2003 goto out;
2004 }
2005 retval = (-EIO); /* EOM or Blank Check */
2006 goto out;
2007 }
2008
2009 if (do_dio) {
2010 /* Check the buffer writability before any tape movement. Don't alter
2011 buffer data. */
2012 if (copy_from_user(&i, buf, 1) != 0 ||
2013 copy_to_user(buf, &i, 1) != 0 ||
2014 copy_from_user(&i, buf + count - 1, 1) != 0 ||
2015 copy_to_user(buf + count - 1, &i, 1) != 0) {
2016 retval = (-EFAULT);
2017 goto out;
2018 }
2019 }
2020
2021 STps->rw = ST_READING;
2022
2023
2024 /* Loop until enough data in buffer or a special condition found */
2025 for (total = 0, special = 0; total < count && !special;) {
2026
2027 /* Get new data if the buffer is empty */
2028 if (STbp->buffer_bytes == 0) {
2029 special = read_tape(STp, count - total, &SRpnt);
2030 if (special < 0) { /* No need to continue read */
2031 retval = special;
2032 goto out;
2033 }
2034 }
2035
2036 /* Move the data from driver buffer to user buffer */
2037 if (STbp->buffer_bytes > 0) {
2038 DEB(
2039 if (debugging && STps->eof != ST_NOEOF)
2040 printk(ST_DEB_MSG
2041 "%s: EOF up (%d). Left %d, needed %d.\n", name,
2042 STps->eof, STbp->buffer_bytes,
2043 (int)(count - total));
2044 ) /* end DEB */
2045 transfer = STbp->buffer_bytes < count - total ?
2046 STbp->buffer_bytes : count - total;
2047 if (!do_dio) {
2048 i = from_buffer(STbp, buf, transfer);
2049 if (i) {
2050 retval = i;
2051 goto out;
2052 }
2053 }
2054 buf += transfer;
2055 total += transfer;
2056 }
2057
2058 if (STp->block_size == 0)
2059 break; /* Read only one variable length block */
2060
2061 } /* for (total = 0, special = 0;
2062 total < count && !special; ) */
2063
2064 /* Change the eof state if no data from tape or buffer */
2065 if (total == 0) {
2066 if (STps->eof == ST_FM_HIT) {
2067 STps->eof = ST_FM;
2068 STps->drv_block = 0;
2069 if (STps->drv_file >= 0)
2070 STps->drv_file++;
2071 } else if (STps->eof == ST_EOD_1) {
2072 STps->eof = ST_EOD_2;
2073 STps->drv_block = 0;
2074 if (STps->drv_file >= 0)
2075 STps->drv_file++;
2076 } else if (STps->eof == ST_EOD_2)
2077 STps->eof = ST_EOD;
2078 } else if (STps->eof == ST_FM)
2079 STps->eof = ST_NOEOF;
2080 retval = total;
2081
2082 out:
2083 if (SRpnt != NULL) {
8b05b773 2084 st_release_request(SRpnt);
1da177e4
LT		 2085 SRpnt = NULL;
2086 }
2087 if (do_dio) {
787926b1 2088 release_buffering(STp, 1);
1da177e4
LT		 2089 STbp->buffer_bytes = 0;
2090 }
28f85009 2091 mutex_unlock(&STp->lock);
1da177e4
LT		 2092
2093 return retval;
2094}
2095\f
2096
2097
2098DEB(
2099/* Set the driver options */
2100static void st_log_options(struct scsi_tape * STp, struct st_modedef * STm, char *name)
2101{
2102 if (debugging) {
2103 printk(KERN_INFO
2104 "%s: Mode %d options: buffer writes: %d, async writes: %d, read ahead: %d\n",
2105 name, STp->current_mode, STm->do_buffer_writes, STm->do_async_writes,
2106 STm->do_read_ahead);
2107 printk(KERN_INFO
2108 "%s: can bsr: %d, two FMs: %d, fast mteom: %d, auto lock: %d,\n",
2109 name, STp->can_bsr, STp->two_fm, STp->fast_mteom, STp->do_auto_lock);
2110 printk(KERN_INFO
2111 "%s: defs for wr: %d, no block limits: %d, partitions: %d, s2 log: %d\n",
2112 name, STm->defaults_for_writes, STp->omit_blklims, STp->can_partitions,
2113 STp->scsi2_logical);
2114 printk(KERN_INFO
40f6b36c
KM		 2115 "%s: sysv: %d nowait: %d sili: %d\n", name, STm->sysv, STp->immediate,
2116 STp->sili);
1da177e4
LT		 2117 printk(KERN_INFO "%s: debugging: %d\n",
2118 name, debugging);
2119 }
2120}
2121 )
2122
2123
2124static int st_set_options(struct scsi_tape *STp, long options)
2125{
2126 int value;
2127 long code;
2128 struct st_modedef *STm;
2129 char *name = tape_name(STp);
2130 struct cdev *cd0, *cd1;
2131
2132 STm = &(STp->modes[STp->current_mode]);
2133 if (!STm->defined) {
2134 cd0 = STm->cdevs[0]; cd1 = STm->cdevs[1];
2135 memcpy(STm, &(STp->modes[0]), sizeof(struct st_modedef));
2136 STm->cdevs[0] = cd0; STm->cdevs[1] = cd1;
2137 modes_defined = 1;
2138 DEBC(printk(ST_DEB_MSG
2139 "%s: Initialized mode %d definition from mode 0\n",
2140 name, STp->current_mode));
2141 }
2142
2143 code = options & MT_ST_OPTIONS;
2144 if (code == MT_ST_BOOLEANS) {
2145 STm->do_buffer_writes = (options & MT_ST_BUFFER_WRITES) != 0;
2146 STm->do_async_writes = (options & MT_ST_ASYNC_WRITES) != 0;
2147 STm->defaults_for_writes = (options & MT_ST_DEF_WRITES) != 0;
2148 STm->do_read_ahead = (options & MT_ST_READ_AHEAD) != 0;
2149 STp->two_fm = (options & MT_ST_TWO_FM) != 0;
2150 STp->fast_mteom = (options & MT_ST_FAST_MTEOM) != 0;
2151 STp->do_auto_lock = (options & MT_ST_AUTO_LOCK) != 0;
2152 STp->can_bsr = (options & MT_ST_CAN_BSR) != 0;
2153 STp->omit_blklims = (options & MT_ST_NO_BLKLIMS) != 0;
2154 if ((STp->device)->scsi_level >= SCSI_2)
2155 STp->can_partitions = (options & MT_ST_CAN_PARTITIONS) != 0;
2156 STp->scsi2_logical = (options & MT_ST_SCSI2LOGICAL) != 0;
2157 STp->immediate = (options & MT_ST_NOWAIT) != 0;
2158 STm->sysv = (options & MT_ST_SYSV) != 0;
40f6b36c 2159 STp->sili = (options & MT_ST_SILI) != 0;
1da177e4
LT		 2160 DEB( debugging = (options & MT_ST_DEBUGGING) != 0;
2161 st_log_options(STp, STm, name); )
2162 } else if (code == MT_ST_SETBOOLEANS || code == MT_ST_CLEARBOOLEANS) {
2163 value = (code == MT_ST_SETBOOLEANS);
2164 if ((options & MT_ST_BUFFER_WRITES) != 0)
2165 STm->do_buffer_writes = value;
2166 if ((options & MT_ST_ASYNC_WRITES) != 0)
2167 STm->do_async_writes = value;
2168 if ((options & MT_ST_DEF_WRITES) != 0)
2169 STm->defaults_for_writes = value;
2170 if ((options & MT_ST_READ_AHEAD) != 0)
2171 STm->do_read_ahead = value;
2172 if ((options & MT_ST_TWO_FM) != 0)
2173 STp->two_fm = value;
2174 if ((options & MT_ST_FAST_MTEOM) != 0)
2175 STp->fast_mteom = value;
2176 if ((options & MT_ST_AUTO_LOCK) != 0)
2177 STp->do_auto_lock = value;
2178 if ((options & MT_ST_CAN_BSR) != 0)
2179 STp->can_bsr = value;
2180 if ((options & MT_ST_NO_BLKLIMS) != 0)
2181 STp->omit_blklims = value;
2182 if ((STp->device)->scsi_level >= SCSI_2 &&
2183 (options & MT_ST_CAN_PARTITIONS) != 0)
2184 STp->can_partitions = value;
2185 if ((options & MT_ST_SCSI2LOGICAL) != 0)
2186 STp->scsi2_logical = value;
2187 if ((options & MT_ST_NOWAIT) != 0)
2188 STp->immediate = value;
2189 if ((options & MT_ST_SYSV) != 0)
2190 STm->sysv = value;
40f6b36c
KM		 2191 if ((options & MT_ST_SILI) != 0)
2192 STp->sili = value;
1da177e4
LT		 2193 DEB(
2194 if ((options & MT_ST_DEBUGGING) != 0)
2195 debugging = value;
2196 st_log_options(STp, STm, name); )
2197 } else if (code == MT_ST_WRITE_THRESHOLD) {
2198 /* Retained for compatibility */
2199 } else if (code == MT_ST_DEF_BLKSIZE) {
2200 value = (options & ~MT_ST_OPTIONS);
2201 if (value == ~MT_ST_OPTIONS) {
2202 STm->default_blksize = (-1);
2203 DEBC( printk(KERN_INFO "%s: Default block size disabled.\n", name));
2204 } else {
2205 STm->default_blksize = value;
2206 DEBC( printk(KERN_INFO "%s: Default block size set to %d bytes.\n",
2207 name, STm->default_blksize));
2208 if (STp->ready == ST_READY) {
2209 STp->blksize_changed = 0;
2210 set_mode_densblk(STp, STm);
2211 }
2212 }
2213 } else if (code == MT_ST_TIMEOUTS) {
2214 value = (options & ~MT_ST_OPTIONS);
2215 if ((value & MT_ST_SET_LONG_TIMEOUT) != 0) {
2216 STp->long_timeout = (value & ~MT_ST_SET_LONG_TIMEOUT) * HZ;
2217 DEBC( printk(KERN_INFO "%s: Long timeout set to %d seconds.\n", name,
2218 (value & ~MT_ST_SET_LONG_TIMEOUT)));
2219 } else {
2220 STp->device->timeout = value * HZ;
2221 DEBC( printk(KERN_INFO "%s: Normal timeout set to %d seconds.\n",
2222 name, value) );
2223 }
2224 } else if (code == MT_ST_SET_CLN) {
2225 value = (options & ~MT_ST_OPTIONS) & 0xff;
2226 if (value != 0 &&
2227 value < EXTENDED_SENSE_START && value >= SCSI_SENSE_BUFFERSIZE)
2228 return (-EINVAL);
2229 STp->cln_mode = value;
2230 STp->cln_sense_mask = (options >> 8) & 0xff;
2231 STp->cln_sense_value = (options >> 16) & 0xff;
2232 printk(KERN_INFO
2233 "%s: Cleaning request mode %d, mask %02x, value %02x\n",
2234 name, value, STp->cln_sense_mask, STp->cln_sense_value);
2235 } else if (code == MT_ST_DEF_OPTIONS) {
2236 code = (options & ~MT_ST_CLEAR_DEFAULT);
2237 value = (options & MT_ST_CLEAR_DEFAULT);
2238 if (code == MT_ST_DEF_DENSITY) {
2239 if (value == MT_ST_CLEAR_DEFAULT) {
2240 STm->default_density = (-1);
2241 DEBC( printk(KERN_INFO "%s: Density default disabled.\n",
2242 name));
2243 } else {
2244 STm->default_density = value & 0xff;
2245 DEBC( printk(KERN_INFO "%s: Density default set to %x\n",
2246 name, STm->default_density));
2247 if (STp->ready == ST_READY) {
2248 STp->density_changed = 0;
2249 set_mode_densblk(STp, STm);
2250 }
2251 }
2252 } else if (code == MT_ST_DEF_DRVBUFFER) {
2253 if (value == MT_ST_CLEAR_DEFAULT) {
2254 STp->default_drvbuffer = 0xff;
2255 DEBC( printk(KERN_INFO
2256 "%s: Drive buffer default disabled.\n", name));
2257 } else {
2258 STp->default_drvbuffer = value & 7;
2259 DEBC( printk(KERN_INFO
2260 "%s: Drive buffer default set to %x\n",
2261 name, STp->default_drvbuffer));
2262 if (STp->ready == ST_READY)
2263 st_int_ioctl(STp, MTSETDRVBUFFER, STp->default_drvbuffer);
2264 }
2265 } else if (code == MT_ST_DEF_COMPRESSION) {
2266 if (value == MT_ST_CLEAR_DEFAULT) {
2267 STm->default_compression = ST_DONT_TOUCH;
2268 DEBC( printk(KERN_INFO
2269 "%s: Compression default disabled.\n", name));
2270 } else {
2271 if ((value & 0xff00) != 0) {
2272 STp->c_algo = (value & 0xff00) >> 8;
2273 DEBC( printk(KERN_INFO "%s: Compression algorithm set to 0x%x.\n",
2274 name, STp->c_algo));
2275 }
2276 if ((value & 0xff) != 0xff) {
2277 STm->default_compression = (value & 1 ? ST_YES : ST_NO);
2278 DEBC( printk(KERN_INFO "%s: Compression default set to %x\n",
2279 name, (value & 1)));
2280 if (STp->ready == ST_READY) {
2281 STp->compression_changed = 0;
2282 st_compression(STp, (STm->default_compression == ST_YES));
2283 }
2284 }
2285 }
2286 }
2287 } else
2288 return (-EIO);
2289
2290 return 0;
2291}
2292\f
2293#define MODE_HEADER_LENGTH 4
2294
2295/* Mode header and page byte offsets */
2296#define MH_OFF_DATA_LENGTH 0
2297#define MH_OFF_MEDIUM_TYPE 1
2298#define MH_OFF_DEV_SPECIFIC 2
2299#define MH_OFF_BDESCS_LENGTH 3
2300#define MP_OFF_PAGE_NBR 0
2301#define MP_OFF_PAGE_LENGTH 1
2302
2303/* Mode header and page bit masks */
2304#define MH_BIT_WP 0x80
2305#define MP_MSK_PAGE_NBR 0x3f
2306
2307/* Don't return block descriptors */
2308#define MODE_SENSE_OMIT_BDESCS 0x08
2309
2310#define MODE_SELECT_PAGE_FORMAT 0x10
2311
2312/* Read a mode page into the tape buffer. The block descriptors are included
2313 if incl_block_descs is true. The page control is ored to the page number
2314 parameter, if necessary. */
2315static int read_mode_page(struct scsi_tape *STp, int page, int omit_block_descs)
2316{
2317 unsigned char cmd[MAX_COMMAND_SIZE];
8b05b773 2318 struct st_request *SRpnt = NULL;
1da177e4
LT		 2319
2320 memset(cmd, 0, MAX_COMMAND_SIZE);
2321 cmd[0] = MODE_SENSE;
2322 if (omit_block_descs)
2323 cmd[1] = MODE_SENSE_OMIT_BDESCS;
2324 cmd[2] = page;
2325 cmd[4] = 255;
2326
2327 SRpnt = st_do_scsi(SRpnt, STp, cmd, cmd[4], DMA_FROM_DEVICE,
2328 STp->device->timeout, 0, 1);
2329 if (SRpnt == NULL)
2330 return (STp->buffer)->syscall_result;
2331
8b05b773 2332 st_release_request(SRpnt);
1da177e4
LT		 2333
2334 return (STp->buffer)->syscall_result;
2335}
2336
2337
2338/* Send the mode page in the tape buffer to the drive. Assumes that the mode data
2339 in the buffer is correctly formatted. The long timeout is used if slow is non-zero. */
2340static int write_mode_page(struct scsi_tape *STp, int page, int slow)
2341{
2342 int pgo;
2343 unsigned char cmd[MAX_COMMAND_SIZE];
8b05b773 2344 struct st_request *SRpnt = NULL;
1da177e4
LT		 2345
2346 memset(cmd, 0, MAX_COMMAND_SIZE);
2347 cmd[0] = MODE_SELECT;
2348 cmd[1] = MODE_SELECT_PAGE_FORMAT;
2349 pgo = MODE_HEADER_LENGTH + (STp->buffer)->b_data[MH_OFF_BDESCS_LENGTH];
2350 cmd[4] = pgo + (STp->buffer)->b_data[pgo + MP_OFF_PAGE_LENGTH] + 2;
2351
2352 /* Clear reserved fields */
2353 (STp->buffer)->b_data[MH_OFF_DATA_LENGTH] = 0;
2354 (STp->buffer)->b_data[MH_OFF_MEDIUM_TYPE] = 0;
2355 (STp->buffer)->b_data[MH_OFF_DEV_SPECIFIC] &= ~MH_BIT_WP;
2356 (STp->buffer)->b_data[pgo + MP_OFF_PAGE_NBR] &= MP_MSK_PAGE_NBR;
2357
2358 SRpnt = st_do_scsi(SRpnt, STp, cmd, cmd[4], DMA_TO_DEVICE,
2359 (slow ? STp->long_timeout : STp->device->timeout), 0, 1);
2360 if (SRpnt == NULL)
2361 return (STp->buffer)->syscall_result;
2362
8b05b773 2363 st_release_request(SRpnt);
1da177e4
LT		 2364
2365 return (STp->buffer)->syscall_result;
2366}
2367
2368
2369#define COMPRESSION_PAGE 0x0f
2370#define COMPRESSION_PAGE_LENGTH 16
2371
2372#define CP_OFF_DCE_DCC 2
2373#define CP_OFF_C_ALGO 7
2374
2375#define DCE_MASK 0x80
2376#define DCC_MASK 0x40
2377#define RED_MASK 0x60
2378
2379
2380/* Control the compression with mode page 15. Algorithm not changed if zero.
2381
2382 The block descriptors are read and written because Sony SDT-7000 does not
2383 work without this (suggestion from Michael Schaefer <Michael.Schaefer@dlr.de>).
2384 Including block descriptors should not cause any harm to other drives. */
2385
2386static int st_compression(struct scsi_tape * STp, int state)
2387{
2388 int retval;
2389 int mpoffs; /* Offset to mode page start */
2390 unsigned char *b_data = (STp->buffer)->b_data;
2391 DEB( char *name = tape_name(STp); )
2392
2393 if (STp->ready != ST_READY)
2394 return (-EIO);
2395
2396 /* Read the current page contents */
2397 retval = read_mode_page(STp, COMPRESSION_PAGE, 0);
2398 if (retval) {
2399 DEBC(printk(ST_DEB_MSG "%s: Compression mode page not supported.\n",
2400 name));
2401 return (-EIO);
2402 }
2403
2404 mpoffs = MODE_HEADER_LENGTH + b_data[MH_OFF_BDESCS_LENGTH];
2405 DEBC(printk(ST_DEB_MSG "%s: Compression state is %d.\n", name,
2406 (b_data[mpoffs + CP_OFF_DCE_DCC] & DCE_MASK ? 1 : 0)));
2407
2408 /* Check if compression can be changed */
2409 if ((b_data[mpoffs + CP_OFF_DCE_DCC] & DCC_MASK) == 0) {
2410 DEBC(printk(ST_DEB_MSG "%s: Compression not supported.\n", name));
2411 return (-EIO);
2412 }
2413
2414 /* Do the change */
2415 if (state) {
2416 b_data[mpoffs + CP_OFF_DCE_DCC] |= DCE_MASK;
2417 if (STp->c_algo != 0)
2418 b_data[mpoffs + CP_OFF_C_ALGO] = STp->c_algo;
2419 }
2420 else {
2421 b_data[mpoffs + CP_OFF_DCE_DCC] &= ~DCE_MASK;
2422 if (STp->c_algo != 0)
2423 b_data[mpoffs + CP_OFF_C_ALGO] = 0; /* no compression */
2424 }
2425
2426 retval = write_mode_page(STp, COMPRESSION_PAGE, 0);
2427 if (retval) {
2428 DEBC(printk(ST_DEB_MSG "%s: Compression change failed.\n", name));
2429 return (-EIO);
2430 }
2431 DEBC(printk(ST_DEB_MSG "%s: Compression state changed to %d.\n",
2432 name, state));
2433
2434 STp->compression_changed = 1;
2435 return 0;
2436}
2437
2438
2439/* Process the load and unload commands (does unload if the load code is zero) */
2440static int do_load_unload(struct scsi_tape *STp, struct file *filp, int load_code)
2441{
2442 int retval = (-EIO), timeout;
2443 DEB( char *name = tape_name(STp); )
2444 unsigned char cmd[MAX_COMMAND_SIZE];
2445 struct st_partstat *STps;
8b05b773 2446 struct st_request *SRpnt;
1da177e4
LT		 2447
2448 if (STp->ready != ST_READY && !load_code) {
2449 if (STp->ready == ST_NO_TAPE)
2450 return (-ENOMEDIUM);
2451 else
2452 return (-EIO);
2453 }
2454
2455 memset(cmd, 0, MAX_COMMAND_SIZE);
2456 cmd[0] = START_STOP;
2457 if (load_code)
2458 cmd[4] |= 1;
2459 /*
2460 * If arg >= 1 && arg <= 6 Enhanced load/unload in HP C1553A
2461 */
2462 if (load_code >= 1 + MT_ST_HPLOADER_OFFSET
2463 && load_code <= 6 + MT_ST_HPLOADER_OFFSET) {
2464 DEBC(printk(ST_DEB_MSG "%s: Enhanced %sload slot %2d.\n",
2465 name, (cmd[4]) ? "" : "un",
2466 load_code - MT_ST_HPLOADER_OFFSET));
2467 cmd[3] = load_code - MT_ST_HPLOADER_OFFSET; /* MediaID field of C1553A */
2468 }
2469 if (STp->immediate) {
2470 cmd[1] = 1; /* Don't wait for completion */
2471 timeout = STp->device->timeout;
2472 }
2473 else
2474 timeout = STp->long_timeout;
2475
2476 DEBC(
2477 if (!load_code)
2478 printk(ST_DEB_MSG "%s: Unloading tape.\n", name);
2479 else
2480 printk(ST_DEB_MSG "%s: Loading tape.\n", name);
2481 );
2482
2483 SRpnt = st_do_scsi(NULL, STp, cmd, 0, DMA_NONE,
2484 timeout, MAX_RETRIES, 1);
2485 if (!SRpnt)
2486 return (STp->buffer)->syscall_result;
2487
2488 retval = (STp->buffer)->syscall_result;
8b05b773 2489 st_release_request(SRpnt);
1da177e4
LT		 2490
2491 if (!retval) { /* SCSI command successful */
2492
2493 if (!load_code) {
2494 STp->rew_at_close = 0;
2495 STp->ready = ST_NO_TAPE;
2496 }
2497 else {
2498 STp->rew_at_close = STp->autorew_dev;
2499 retval = check_tape(STp, filp);
2500 if (retval > 0)
2501 retval = 0;
2502 }
2503 }
2504 else {
2505 STps = &(STp->ps[STp->partition]);
2506 STps->drv_file = STps->drv_block = (-1);
2507 }
2508
2509 return retval;
2510}
2511\f
2512#if DEBUG
2513#define ST_DEB_FORWARD 0
2514#define ST_DEB_BACKWARD 1
2515static void deb_space_print(char *name, int direction, char *units, unsigned char *cmd)
2516{
2517 s32 sc;
2518
2519 sc = cmd[2] & 0x80 ? 0xff000000 : 0;
2520 sc |= (cmd[2] << 16) | (cmd[3] << 8) | cmd[4];
2521 if (direction)
2522 sc = -sc;
2523 printk(ST_DEB_MSG "%s: Spacing tape %s over %d %s.\n", name,
2524 direction ? "backward" : "forward", sc, units);
2525}
2526#endif
2527
2528
2529/* Internal ioctl function */
2530static int st_int_ioctl(struct scsi_tape *STp, unsigned int cmd_in, unsigned long arg)
2531{
2532 int timeout;
2533 long ltmp;
2534 int ioctl_result;
2535 int chg_eof = 1;
2536 unsigned char cmd[MAX_COMMAND_SIZE];
8b05b773 2537 struct st_request *SRpnt;
1da177e4
LT		 2538 struct st_partstat *STps;
2539 int fileno, blkno, at_sm, undone;
2540 int datalen = 0, direction = DMA_NONE;
2541 char *name = tape_name(STp);
2542
2543 WARN_ON(STp->buffer->do_dio != 0);
2544 if (STp->ready != ST_READY) {
2545 if (STp->ready == ST_NO_TAPE)
2546 return (-ENOMEDIUM);
2547 else
2548 return (-EIO);
2549 }
2550 timeout = STp->long_timeout;
2551 STps = &(STp->ps[STp->partition]);
2552 fileno = STps->drv_file;
2553 blkno = STps->drv_block;
2554 at_sm = STps->at_sm;
2555
2556 memset(cmd, 0, MAX_COMMAND_SIZE);
2557 switch (cmd_in) {
2558 case MTFSFM:
2559 chg_eof = 0; /* Changed from the FSF after this */
2560 case MTFSF:
2561 cmd[0] = SPACE;
2562 cmd[1] = 0x01; /* Space FileMarks */
2563 cmd[2] = (arg >> 16);
2564 cmd[3] = (arg >> 8);
2565 cmd[4] = arg;
2566 DEBC(deb_space_print(name, ST_DEB_FORWARD, "filemarks", cmd);)
2567 if (fileno >= 0)
2568 fileno += arg;
2569 blkno = 0;
2570 at_sm &= (arg == 0);
2571 break;
2572 case MTBSFM:
2573 chg_eof = 0; /* Changed from the FSF after this */
2574 case MTBSF:
2575 cmd[0] = SPACE;
2576 cmd[1] = 0x01; /* Space FileMarks */
2577 ltmp = (-arg);
2578 cmd[2] = (ltmp >> 16);
2579 cmd[3] = (ltmp >> 8);
2580 cmd[4] = ltmp;
2581 DEBC(deb_space_print(name, ST_DEB_BACKWARD, "filemarks", cmd);)
2582 if (fileno >= 0)
2583 fileno -= arg;
2584 blkno = (-1); /* We can't know the block number */
2585 at_sm &= (arg == 0);
2586 break;
2587 case MTFSR:
2588 cmd[0] = SPACE;
2589 cmd[1] = 0x00; /* Space Blocks */
2590 cmd[2] = (arg >> 16);
2591 cmd[3] = (arg >> 8);
2592 cmd[4] = arg;
2593 DEBC(deb_space_print(name, ST_DEB_FORWARD, "blocks", cmd);)
2594 if (blkno >= 0)
2595 blkno += arg;
2596 at_sm &= (arg == 0);
2597 break;
2598 case MTBSR:
2599 cmd[0] = SPACE;
2600 cmd[1] = 0x00; /* Space Blocks */
2601 ltmp = (-arg);
2602 cmd[2] = (ltmp >> 16);
2603 cmd[3] = (ltmp >> 8);
2604 cmd[4] = ltmp;
2605 DEBC(deb_space_print(name, ST_DEB_BACKWARD, "blocks", cmd);)
2606 if (blkno >= 0)
2607 blkno -= arg;
2608 at_sm &= (arg == 0);
2609 break;
2610 case MTFSS:
2611 cmd[0] = SPACE;
2612 cmd[1] = 0x04; /* Space Setmarks */
2613 cmd[2] = (arg >> 16);
2614 cmd[3] = (arg >> 8);
2615 cmd[4] = arg;
2616 DEBC(deb_space_print(name, ST_DEB_FORWARD, "setmarks", cmd);)
2617 if (arg != 0) {
2618 blkno = fileno = (-1);
2619 at_sm = 1;
2620 }
2621 break;
2622 case MTBSS:
2623 cmd[0] = SPACE;
2624 cmd[1] = 0x04; /* Space Setmarks */
2625 ltmp = (-arg);
2626 cmd[2] = (ltmp >> 16);
2627 cmd[3] = (ltmp >> 8);
2628 cmd[4] = ltmp;
2629 DEBC(deb_space_print(name, ST_DEB_BACKWARD, "setmarks", cmd);)
2630 if (arg != 0) {
2631 blkno = fileno = (-1);
2632 at_sm = 1;
2633 }
2634 break;
2635 case MTWEOF:
2636 case MTWSM:
2637 if (STp->write_prot)
2638 return (-EACCES);
2639 cmd[0] = WRITE_FILEMARKS;
2640 if (cmd_in == MTWSM)
2641 cmd[1] = 2;
2642 cmd[2] = (arg >> 16);
2643 cmd[3] = (arg >> 8);
2644 cmd[4] = arg;
2645 timeout = STp->device->timeout;
2646 DEBC(
2647 if (cmd_in == MTWEOF)
2648 printk(ST_DEB_MSG "%s: Writing %d filemarks.\n", name,
2649 cmd[2] * 65536 + cmd[3] * 256 + cmd[4]);
2650 else
2651 printk(ST_DEB_MSG "%s: Writing %d setmarks.\n", name,
2652 cmd[2] * 65536 + cmd[3] * 256 + cmd[4]);
2653 )
2654 if (fileno >= 0)
2655 fileno += arg;
2656 blkno = 0;
2657 at_sm = (cmd_in == MTWSM);
2658 break;
2659 case MTREW:
2660 cmd[0] = REZERO_UNIT;
2661 if (STp->immediate) {
2662 cmd[1] = 1; /* Don't wait for completion */
2663 timeout = STp->device->timeout;
2664 }
2665 DEBC(printk(ST_DEB_MSG "%s: Rewinding tape.\n", name));
2666 fileno = blkno = at_sm = 0;
2667 break;
2668 case MTNOP:
2669 DEBC(printk(ST_DEB_MSG "%s: No op on tape.\n", name));
2670 return 0; /* Should do something ? */
2671 break;
2672 case MTRETEN:
2673 cmd[0] = START_STOP;
2674 if (STp->immediate) {
2675 cmd[1] = 1; /* Don't wait for completion */
2676 timeout = STp->device->timeout;
2677 }
2678 cmd[4] = 3;
2679 DEBC(printk(ST_DEB_MSG "%s: Retensioning tape.\n", name));
2680 fileno = blkno = at_sm = 0;
2681 break;
2682 case MTEOM:
2683 if (!STp->fast_mteom) {
2684 /* space to the end of tape */
2685 ioctl_result = st_int_ioctl(STp, MTFSF, 0x7fffff);
2686 fileno = STps->drv_file;
2687 if (STps->eof >= ST_EOD_1)
2688 return 0;
2689 /* The next lines would hide the number of spaced FileMarks
2690 That's why I inserted the previous lines. I had no luck
2691 with detecting EOM with FSF, so we go now to EOM.
2692 Joerg Weule */
2693 } else
2694 fileno = (-1);
2695 cmd[0] = SPACE;
2696 cmd[1] = 3;
2697 DEBC(printk(ST_DEB_MSG "%s: Spacing to end of recorded medium.\n",
2698 name));
2699 blkno = -1;
2700 at_sm = 0;
2701 break;
2702 case MTERASE:
2703 if (STp->write_prot)
2704 return (-EACCES);
2705 cmd[0] = ERASE;
2706 cmd[1] = (arg ? 1 : 0); /* Long erase with non-zero argument */
2707 if (STp->immediate) {
2708 cmd[1] |= 2; /* Don't wait for completion */
2709 timeout = STp->device->timeout;
2710 }
2711 else
2712 timeout = STp->long_timeout * 8;
2713
2714 DEBC(printk(ST_DEB_MSG "%s: Erasing tape.\n", name));
2715 fileno = blkno = at_sm = 0;
2716 break;
2717 case MTSETBLK: /* Set block length */
2718 case MTSETDENSITY: /* Set tape density */
2719 case MTSETDRVBUFFER: /* Set drive buffering */
2720 case SET_DENS_AND_BLK: /* Set density and block size */
2721 chg_eof = 0;
2722 if (STp->dirty || (STp->buffer)->buffer_bytes != 0)
2723 return (-EIO); /* Not allowed if data in buffer */
2724 if ((cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) &&
2725 (arg & MT_ST_BLKSIZE_MASK) != 0 &&
2726 STp->max_block > 0 &&
2727 ((arg & MT_ST_BLKSIZE_MASK) < STp->min_block ||
2728 (arg & MT_ST_BLKSIZE_MASK) > STp->max_block)) {
2729 printk(KERN_WARNING "%s: Illegal block size.\n", name);
2730 return (-EINVAL);
2731 }
2732 cmd[0] = MODE_SELECT;
2733 if ((STp->use_pf & USE_PF))
2734 cmd[1] = MODE_SELECT_PAGE_FORMAT;
2735 cmd[4] = datalen = 12;
2736 direction = DMA_TO_DEVICE;
2737
2738 memset((STp->buffer)->b_data, 0, 12);
2739 if (cmd_in == MTSETDRVBUFFER)
2740 (STp->buffer)->b_data[2] = (arg & 7) << 4;
2741 else
2742 (STp->buffer)->b_data[2] =
2743 STp->drv_buffer << 4;
2744 (STp->buffer)->b_data[3] = 8; /* block descriptor length */
2745 if (cmd_in == MTSETDENSITY) {
2746 (STp->buffer)->b_data[4] = arg;
2747 STp->density_changed = 1; /* At least we tried ;-) */
2748 } else if (cmd_in == SET_DENS_AND_BLK)
2749 (STp->buffer)->b_data[4] = arg >> 24;
2750 else
2751 (STp->buffer)->b_data[4] = STp->density;
2752 if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) {
2753 ltmp = arg & MT_ST_BLKSIZE_MASK;
2754 if (cmd_in == MTSETBLK)
2755 STp->blksize_changed = 1; /* At least we tried ;-) */
2756 } else
2757 ltmp = STp->block_size;
2758 (STp->buffer)->b_data[9] = (ltmp >> 16);
2759 (STp->buffer)->b_data[10] = (ltmp >> 8);
2760 (STp->buffer)->b_data[11] = ltmp;
2761 timeout = STp->device->timeout;
2762 DEBC(
2763 if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK)
2764 printk(ST_DEB_MSG
2765 "%s: Setting block size to %d bytes.\n", name,
2766 (STp->buffer)->b_data[9] * 65536 +
2767 (STp->buffer)->b_data[10] * 256 +
2768 (STp->buffer)->b_data[11]);
2769 if (cmd_in == MTSETDENSITY || cmd_in == SET_DENS_AND_BLK)
2770 printk(ST_DEB_MSG
2771 "%s: Setting density code to %x.\n", name,
2772 (STp->buffer)->b_data[4]);
2773 if (cmd_in == MTSETDRVBUFFER)
2774 printk(ST_DEB_MSG
2775 "%s: Setting drive buffer code to %d.\n", name,
2776 ((STp->buffer)->b_data[2] >> 4) & 7);
2777 )
2778 break;
2779 default:
2780 return (-ENOSYS);
2781 }
2782
2783 SRpnt = st_do_scsi(NULL, STp, cmd, datalen, direction,
2784 timeout, MAX_RETRIES, 1);
2785 if (!SRpnt)
2786 return (STp->buffer)->syscall_result;
2787
2788 ioctl_result = (STp->buffer)->syscall_result;
2789
2790 if (!ioctl_result) { /* SCSI command successful */
8b05b773 2791 st_release_request(SRpnt);
1da177e4
LT		 2792 SRpnt = NULL;
2793 STps->drv_block = blkno;
2794 STps->drv_file = fileno;
2795 STps->at_sm = at_sm;
2796
2797 if (cmd_in == MTBSFM)
2798 ioctl_result = st_int_ioctl(STp, MTFSF, 1);
2799 else if (cmd_in == MTFSFM)
2800 ioctl_result = st_int_ioctl(STp, MTBSF, 1);
2801
2802 if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) {
2803 int old_block_size = STp->block_size;
2804 STp->block_size = arg & MT_ST_BLKSIZE_MASK;
2805 if (STp->block_size != 0) {
2806 if (old_block_size == 0)
2807 normalize_buffer(STp->buffer);
2808 (STp->buffer)->buffer_blocks =
2809 (STp->buffer)->buffer_size / STp->block_size;
2810 }
2811 (STp->buffer)->buffer_bytes = (STp->buffer)->read_pointer = 0;
2812 if (cmd_in == SET_DENS_AND_BLK)
2813 STp->density = arg >> MT_ST_DENSITY_SHIFT;
2814 } else if (cmd_in == MTSETDRVBUFFER)
2815 STp->drv_buffer = (arg & 7);
2816 else if (cmd_in == MTSETDENSITY)
2817 STp->density = arg;
2818
2819 if (cmd_in == MTEOM)
2820 STps->eof = ST_EOD;
2821 else if (cmd_in == MTFSF)
2822 STps->eof = ST_FM;
2823 else if (chg_eof)
2824 STps->eof = ST_NOEOF;
2825
2826 if (cmd_in == MTWEOF)
2827 STps->rw = ST_IDLE;
2828 } else { /* SCSI command was not completely successful. Don't return
2829 from this block without releasing the SCSI command block! */
2830 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
2831
2832 if (cmdstatp->flags & SENSE_EOM) {
2833 if (cmd_in != MTBSF && cmd_in != MTBSFM &&
2834 cmd_in != MTBSR && cmd_in != MTBSS)
2835 STps->eof = ST_EOM_OK;
2836 STps->drv_block = 0;
2837 }
2838
2839 if (cmdstatp->remainder_valid)
2840 undone = (int)cmdstatp->uremainder64;
2841 else
2842 undone = 0;
2843
2844 if (cmd_in == MTWEOF &&
2845 cmdstatp->have_sense &&
91614c05
KM		 2846 (cmdstatp->flags & SENSE_EOM)) {
2847 if (cmdstatp->sense_hdr.sense_key == NO_SENSE ||
2848 cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR) {
2849 ioctl_result = 0; /* EOF(s) written successfully at EOM */
2850 STps->eof = ST_NOEOF;
2851 } else { /* Writing EOF(s) failed */
2852 if (fileno >= 0)
2853 fileno -= undone;
2854 if (undone < arg)
2855 STps->eof = ST_NOEOF;
2856 }
1da177e4 2857 STps->drv_file = fileno;
1da177e4
LT		 2858 } else if ((cmd_in == MTFSF) || (cmd_in == MTFSFM)) {
2859 if (fileno >= 0)
2860 STps->drv_file = fileno - undone;
2861 else
2862 STps->drv_file = fileno;
2863 STps->drv_block = -1;
2864 STps->eof = ST_NOEOF;
2865 } else if ((cmd_in == MTBSF) || (cmd_in == MTBSFM)) {
2866 if (arg > 0 && undone < 0) /* Some drives get this wrong */
2867 undone = (-undone);
2868 if (STps->drv_file >= 0)
2869 STps->drv_file = fileno + undone;
2870 STps->drv_block = 0;
2871 STps->eof = ST_NOEOF;
2872 } else if (cmd_in == MTFSR) {
2873 if (cmdstatp->flags & SENSE_FMK) { /* Hit filemark */
2874 if (STps->drv_file >= 0)
2875 STps->drv_file++;
2876 STps->drv_block = 0;
2877 STps->eof = ST_FM;
2878 } else {
2879 if (blkno >= undone)
2880 STps->drv_block = blkno - undone;
2881 else
2882 STps->drv_block = (-1);
2883 STps->eof = ST_NOEOF;
2884 }
2885 } else if (cmd_in == MTBSR) {
2886 if (cmdstatp->flags & SENSE_FMK) { /* Hit filemark */
2887 STps->drv_file--;
2888 STps->drv_block = (-1);
2889 } else {
2890 if (arg > 0 && undone < 0) /* Some drives get this wrong */
2891 undone = (-undone);
2892 if (STps->drv_block >= 0)
2893 STps->drv_block = blkno + undone;
2894 }
2895 STps->eof = ST_NOEOF;
2896 } else if (cmd_in == MTEOM) {
2897 STps->drv_file = (-1);
2898 STps->drv_block = (-1);
2899 STps->eof = ST_EOD;
2900 } else if (cmd_in == MTSETBLK ||
2901 cmd_in == MTSETDENSITY ||
2902 cmd_in == MTSETDRVBUFFER ||
2903 cmd_in == SET_DENS_AND_BLK) {
2904 if (cmdstatp->sense_hdr.sense_key == ILLEGAL_REQUEST &&
2905 !(STp->use_pf & PF_TESTED)) {
2906 /* Try the other possible state of Page Format if not
2907 already tried */
2908 STp->use_pf = !STp->use_pf | PF_TESTED;
8b05b773 2909 st_release_request(SRpnt);
1da177e4
LT		 2910 SRpnt = NULL;
2911 return st_int_ioctl(STp, cmd_in, arg);
2912 }
2913 } else if (chg_eof)
2914 STps->eof = ST_NOEOF;
2915
2916 if (cmdstatp->sense_hdr.sense_key == BLANK_CHECK)
2917 STps->eof = ST_EOD;
2918
8b05b773 2919 st_release_request(SRpnt);
1da177e4
LT		 2920 SRpnt = NULL;
2921 }
2922
2923 return ioctl_result;
2924}
2925\f
2926
2927/* Get the tape position. If bt == 2, arg points into a kernel space mt_loc
2928 structure. */
2929
2930static int get_location(struct scsi_tape *STp, unsigned int *block, int *partition,
2931 int logical)
2932{
2933 int result;
2934 unsigned char scmd[MAX_COMMAND_SIZE];
8b05b773 2935 struct st_request *SRpnt;
1da177e4
LT		 2936 DEB( char *name = tape_name(STp); )
2937
2938 if (STp->ready != ST_READY)
2939 return (-EIO);
2940
2941 memset(scmd, 0, MAX_COMMAND_SIZE);
2942 if ((STp->device)->scsi_level < SCSI_2) {
2943 scmd[0] = QFA_REQUEST_BLOCK;
2944 scmd[4] = 3;
2945 } else {
2946 scmd[0] = READ_POSITION;
2947 if (!logical && !STp->scsi2_logical)
2948 scmd[1] = 1;
2949 }
2950 SRpnt = st_do_scsi(NULL, STp, scmd, 20, DMA_FROM_DEVICE,
2951 STp->device->timeout, MAX_READY_RETRIES, 1);
2952 if (!SRpnt)
2953 return (STp->buffer)->syscall_result;
2954
2955 if ((STp->buffer)->syscall_result != 0 ||
2956 (STp->device->scsi_level >= SCSI_2 &&
2957 ((STp->buffer)->b_data[0] & 4) != 0)) {
2958 *block = *partition = 0;
2959 DEBC(printk(ST_DEB_MSG "%s: Can't read tape position.\n", name));
2960 result = (-EIO);
2961 } else {
2962 result = 0;
2963 if ((STp->device)->scsi_level < SCSI_2) {
2964 *block = ((STp->buffer)->b_data[0] << 16)
2965 + ((STp->buffer)->b_data[1] << 8)
2966 + (STp->buffer)->b_data[2];
2967 *partition = 0;
2968 } else {
2969 *block = ((STp->buffer)->b_data[4] << 24)
2970 + ((STp->buffer)->b_data[5] << 16)
2971 + ((STp->buffer)->b_data[6] << 8)
2972 + (STp->buffer)->b_data[7];
2973 *partition = (STp->buffer)->b_data[1];
2974 if (((STp->buffer)->b_data[0] & 0x80) &&
2975 (STp->buffer)->b_data[1] == 0) /* BOP of partition 0 */
2976 STp->ps[0].drv_block = STp->ps[0].drv_file = 0;
2977 }
2978 DEBC(printk(ST_DEB_MSG "%s: Got tape pos. blk %d part %d.\n", name,
2979 *block, *partition));
2980 }
8b05b773 2981 st_release_request(SRpnt);
1da177e4
LT		 2982 SRpnt = NULL;
2983
2984 return result;
2985}
2986
2987
2988/* Set the tape block and partition. Negative partition means that only the
2989 block should be set in vendor specific way. */
2990static int set_location(struct scsi_tape *STp, unsigned int block, int partition,
2991 int logical)
2992{
2993 struct st_partstat *STps;
2994 int result, p;
2995 unsigned int blk;
2996 int timeout;
2997 unsigned char scmd[MAX_COMMAND_SIZE];
8b05b773 2998 struct st_request *SRpnt;
1da177e4
LT		 2999 DEB( char *name = tape_name(STp); )
3000
3001 if (STp->ready != ST_READY)
3002 return (-EIO);
3003 timeout = STp->long_timeout;
3004 STps = &(STp->ps[STp->partition]);
3005
3006 DEBC(printk(ST_DEB_MSG "%s: Setting block to %d and partition to %d.\n",
3007 name, block, partition));
3008 DEB(if (partition < 0)
3009 return (-EIO); )
3010
3011 /* Update the location at the partition we are leaving */
3012 if ((!STp->can_partitions && partition != 0) ||
3013 partition >= ST_NBR_PARTITIONS)
3014 return (-EINVAL);
3015 if (partition != STp->partition) {
3016 if (get_location(STp, &blk, &p, 1))
3017 STps->last_block_valid = 0;
3018 else {
3019 STps->last_block_valid = 1;
3020 STps->last_block_visited = blk;
3021 DEBC(printk(ST_DEB_MSG
3022 "%s: Visited block %d for partition %d saved.\n",
3023 name, blk, STp->partition));
3024 }
3025 }
3026
3027 memset(scmd, 0, MAX_COMMAND_SIZE);
3028 if ((STp->device)->scsi_level < SCSI_2) {
3029 scmd[0] = QFA_SEEK_BLOCK;
3030 scmd[2] = (block >> 16);
3031 scmd[3] = (block >> 8);
3032 scmd[4] = block;
3033 scmd[5] = 0;
3034 } else {
3035 scmd[0] = SEEK_10;
3036 scmd[3] = (block >> 24);
3037 scmd[4] = (block >> 16);
3038 scmd[5] = (block >> 8);
3039 scmd[6] = block;
3040 if (!logical && !STp->scsi2_logical)
3041 scmd[1] = 4;
3042 if (STp->partition != partition) {
3043 scmd[1] |= 2;
3044 scmd[8] = partition;
3045 DEBC(printk(ST_DEB_MSG
3046 "%s: Trying to change partition from %d to %d\n",
3047 name, STp->partition, partition));
3048 }
3049 }
3050 if (STp->immediate) {
3051 scmd[1] |= 1; /* Don't wait for completion */
3052 timeout = STp->device->timeout;
3053 }
3054
3055 SRpnt = st_do_scsi(NULL, STp, scmd, 0, DMA_NONE,
3056 timeout, MAX_READY_RETRIES, 1);
3057 if (!SRpnt)
3058 return (STp->buffer)->syscall_result;
3059
3060 STps->drv_block = STps->drv_file = (-1);
3061 STps->eof = ST_NOEOF;
3062 if ((STp->buffer)->syscall_result != 0) {
3063 result = (-EIO);
3064 if (STp->can_partitions &&
3065 (STp->device)->scsi_level >= SCSI_2 &&
3066 (p = find_partition(STp)) >= 0)
3067 STp->partition = p;
3068 } else {
3069 if (STp->can_partitions) {
3070 STp->partition = partition;
3071 STps = &(STp->ps[partition]);
3072 if (!STps->last_block_valid ||
3073 STps->last_block_visited != block) {
3074 STps->at_sm = 0;
3075 STps->rw = ST_IDLE;
3076 }
3077 } else
3078 STps->at_sm = 0;
3079 if (block == 0)
3080 STps->drv_block = STps->drv_file = 0;
3081 result = 0;
3082 }
3083
8b05b773 3084 st_release_request(SRpnt);
1da177e4
LT		 3085 SRpnt = NULL;
3086
3087 return result;
3088}
3089
3090
3091/* Find the current partition number for the drive status. Called from open and
3092 returns either partition number of negative error code. */
3093static int find_partition(struct scsi_tape *STp)
3094{
3095 int i, partition;
3096 unsigned int block;
3097
3098 if ((i = get_location(STp, &block, &partition, 1)) < 0)
3099 return i;
3100 if (partition >= ST_NBR_PARTITIONS)
3101 return (-EIO);
3102 return partition;
3103}
3104
3105
3106/* Change the partition if necessary */
3107static int switch_partition(struct scsi_tape *STp)
3108{
3109 struct st_partstat *STps;
3110
3111 if (STp->partition == STp->new_partition)
3112 return 0;
3113 STps = &(STp->ps[STp->new_partition]);
3114 if (!STps->last_block_valid)
3115 STps->last_block_visited = 0;
3116 return set_location(STp, STps->last_block_visited, STp->new_partition, 1);
3117}
3118\f
3119/* Functions for reading and writing the medium partition mode page. */
3120
3121#define PART_PAGE 0x11
3122#define PART_PAGE_FIXED_LENGTH 8
3123
3124#define PP_OFF_MAX_ADD_PARTS 2
3125#define PP_OFF_NBR_ADD_PARTS 3
3126#define PP_OFF_FLAGS 4
3127#define PP_OFF_PART_UNITS 6
3128#define PP_OFF_RESERVED 7
3129
3130#define PP_BIT_IDP 0x20
3131#define PP_MSK_PSUM_MB 0x10
3132
3133/* Get the number of partitions on the tape. As a side effect reads the
3134 mode page into the tape buffer. */
3135static int nbr_partitions(struct scsi_tape *STp)
3136{
3137 int result;
3138 DEB( char *name = tape_name(STp); )
3139
3140 if (STp->ready != ST_READY)
3141 return (-EIO);
3142
3143 result = read_mode_page(STp, PART_PAGE, 1);
3144
3145 if (result) {
3146 DEBC(printk(ST_DEB_MSG "%s: Can't read medium partition page.\n",
3147 name));
3148 result = (-EIO);
3149 } else {
3150 result = (STp->buffer)->b_data[MODE_HEADER_LENGTH +
3151 PP_OFF_NBR_ADD_PARTS] + 1;
3152 DEBC(printk(ST_DEB_MSG "%s: Number of partitions %d.\n", name, result));
3153 }
3154
3155 return result;
3156}
3157
3158
3159/* Partition the tape into two partitions if size > 0 or one partition if
3160 size == 0.
3161
3162 The block descriptors are read and written because Sony SDT-7000 does not
3163 work without this (suggestion from Michael Schaefer <Michael.Schaefer@dlr.de>).
3164
3165 My HP C1533A drive returns only one partition size field. This is used to
3166 set the size of partition 1. There is no size field for the default partition.
3167 Michael Schaefer's Sony SDT-7000 returns two descriptors and the second is
3168 used to set the size of partition 1 (this is what the SCSI-3 standard specifies).
3169 The following algorithm is used to accommodate both drives: if the number of
3170 partition size fields is greater than the maximum number of additional partitions
3171 in the mode page, the second field is used. Otherwise the first field is used.
3172
3173 For Seagate DDS drives the page length must be 8 when no partitions is defined
3174 and 10 when 1 partition is defined (information from Eric Lee Green). This is
3175 is acceptable also to some other old drives and enforced if the first partition
3176 size field is used for the first additional partition size.
3177 */
3178static int partition_tape(struct scsi_tape *STp, int size)
3179{
3180 char *name = tape_name(STp);
3181 int result;
3182 int pgo, psd_cnt, psdo;
3183 unsigned char *bp;
3184
3185 result = read_mode_page(STp, PART_PAGE, 0);
3186 if (result) {
3187 DEBC(printk(ST_DEB_MSG "%s: Can't read partition mode page.\n", name));
3188 return result;
3189 }
3190 /* The mode page is in the buffer. Let's modify it and write it. */
3191 bp = (STp->buffer)->b_data;
3192 pgo = MODE_HEADER_LENGTH + bp[MH_OFF_BDESCS_LENGTH];
3193 DEBC(printk(ST_DEB_MSG "%s: Partition page length is %d bytes.\n",
3194 name, bp[pgo + MP_OFF_PAGE_LENGTH] + 2));
3195
3196 psd_cnt = (bp[pgo + MP_OFF_PAGE_LENGTH] + 2 - PART_PAGE_FIXED_LENGTH) / 2;
3197 psdo = pgo + PART_PAGE_FIXED_LENGTH;
3198 if (psd_cnt > bp[pgo + PP_OFF_MAX_ADD_PARTS]) {
3199 bp[psdo] = bp[psdo + 1] = 0xff; /* Rest of the tape */
3200 psdo += 2;
3201 }
3202 memset(bp + psdo, 0, bp[pgo + PP_OFF_NBR_ADD_PARTS] * 2);
3203
3204 DEBC(printk("%s: psd_cnt %d, max.parts %d, nbr_parts %d\n", name,
3205 psd_cnt, bp[pgo + PP_OFF_MAX_ADD_PARTS],
3206 bp[pgo + PP_OFF_NBR_ADD_PARTS]));
3207
3208 if (size <= 0) {
3209 bp[pgo + PP_OFF_NBR_ADD_PARTS] = 0;
3210 if (psd_cnt <= bp[pgo + PP_OFF_MAX_ADD_PARTS])
3211 bp[pgo + MP_OFF_PAGE_LENGTH] = 6;
3212 DEBC(printk(ST_DEB_MSG "%s: Formatting tape with one partition.\n",
3213 name));
3214 } else {
3215 bp[psdo] = (size >> 8) & 0xff;
3216 bp[psdo + 1] = size & 0xff;
3217 bp[pgo + 3] = 1;
3218 if (bp[pgo + MP_OFF_PAGE_LENGTH] < 8)
3219 bp[pgo + MP_OFF_PAGE_LENGTH] = 8;
3220 DEBC(printk(ST_DEB_MSG
3221 "%s: Formatting tape with two partitions (1 = %d MB).\n",
3222 name, size));
3223 }
3224 bp[pgo + PP_OFF_PART_UNITS] = 0;
3225 bp[pgo + PP_OFF_RESERVED] = 0;
3226 bp[pgo + PP_OFF_FLAGS] = PP_BIT_IDP | PP_MSK_PSUM_MB;
3227
3228 result = write_mode_page(STp, PART_PAGE, 1);
3229 if (result) {
3230 printk(KERN_INFO "%s: Partitioning of tape failed.\n", name);
3231 result = (-EIO);
3232 }
3233
3234 return result;
3235}
3236\f
3237
3238
3239/* The ioctl command */
fd66c1b4 3240static long st_ioctl(struct file *file, unsigned int cmd_in, unsigned long arg)
1da177e4
LT		 3241{
3242 int i, cmd_nr, cmd_type, bt;
3243 int retval = 0;
3244 unsigned int blk;
3245 struct scsi_tape *STp = file->private_data;
3246 struct st_modedef *STm;
3247 struct st_partstat *STps;
3248 char *name = tape_name(STp);
3249 void __user *p = (void __user *)arg;
3250
28f85009 3251 if (mutex_lock_interruptible(&STp->lock))
1da177e4
LT		 3252 return -ERESTARTSYS;
3253
3254 DEB(
3255 if (debugging && !STp->in_use) {
3256 printk(ST_DEB_MSG "%s: Incorrect device.\n", name);
3257 retval = (-EIO);
3258 goto out;
3259 } ) /* end DEB */
3260
3261 STm = &(STp->modes[STp->current_mode]);
3262 STps = &(STp->ps[STp->partition]);
3263
3264 /*
3265 * If we are in the middle of error recovery, don't let anyone
3266 * else try and use this device. Also, if error recovery fails, it
3267 * may try and take the device offline, in which case all further
3268 * access to the device is prohibited.
3269 */
3270 retval = scsi_nonblockable_ioctl(STp->device, cmd_in, p, file);
3271 if (!scsi_block_when_processing_errors(STp->device) || retval != -ENODEV)
3272 goto out;
3273 retval = 0;
3274
3275 cmd_type = _IOC_TYPE(cmd_in);
3276 cmd_nr = _IOC_NR(cmd_in);
3277
3278 if (cmd_type == _IOC_TYPE(MTIOCTOP) && cmd_nr == _IOC_NR(MTIOCTOP)) {
3279 struct mtop mtc;
3280
3281 if (_IOC_SIZE(cmd_in) != sizeof(mtc)) {
3282 retval = (-EINVAL);
3283 goto out;
3284 }
3285
3286 i = copy_from_user(&mtc, p, sizeof(struct mtop));
3287 if (i) {
3288 retval = (-EFAULT);
3289 goto out;
3290 }
3291
3292 if (mtc.mt_op == MTSETDRVBUFFER && !capable(CAP_SYS_ADMIN)) {
3293 printk(KERN_WARNING
3294 "%s: MTSETDRVBUFFER only allowed for root.\n", name);
3295 retval = (-EPERM);
3296 goto out;
3297 }
3298 if (!STm->defined &&
3299 (mtc.mt_op != MTSETDRVBUFFER &&
3300 (mtc.mt_count & MT_ST_OPTIONS) == 0)) {
3301 retval = (-ENXIO);
3302 goto out;
3303 }
3304
3305 if (!STp->pos_unknown) {
3306
3307 if (STps->eof == ST_FM_HIT) {
3308 if (mtc.mt_op == MTFSF || mtc.mt_op == MTFSFM ||
3309 mtc.mt_op == MTEOM) {
3310 mtc.mt_count -= 1;
3311 if (STps->drv_file >= 0)
3312 STps->drv_file += 1;
3313 } else if (mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM) {
3314 mtc.mt_count += 1;
3315 if (STps->drv_file >= 0)
3316 STps->drv_file += 1;
3317 }
3318 }
3319
3320 if (mtc.mt_op == MTSEEK) {
3321 /* Old position must be restored if partition will be
3322 changed */
3323 i = !STp->can_partitions ||
3324 (STp->new_partition != STp->partition);
3325 } else {
3326 i = mtc.mt_op == MTREW || mtc.mt_op == MTOFFL ||
3327 mtc.mt_op == MTRETEN || mtc.mt_op == MTEOM ||
3328 mtc.mt_op == MTLOCK || mtc.mt_op == MTLOAD ||
3329 mtc.mt_op == MTFSF || mtc.mt_op == MTFSFM ||
3330 mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM ||
3331 mtc.mt_op == MTCOMPRESSION;
3332 }
3333 i = flush_buffer(STp, i);
3334 if (i < 0) {
3335 retval = i;
3336 goto out;
3337 }
3338 if (STps->rw == ST_WRITING &&
3339 (mtc.mt_op == MTREW || mtc.mt_op == MTOFFL ||
3340 mtc.mt_op == MTSEEK ||
3341 mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM)) {
3342 i = st_int_ioctl(STp, MTWEOF, 1);
3343 if (i < 0) {
3344 retval = i;
3345 goto out;
3346 }
3347 if (mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM)
3348 mtc.mt_count++;
3349 STps->rw = ST_IDLE;
3350 }
3351
3352 } else {
3353 /*
3354 * If there was a bus reset, block further access
3355 * to this device. If the user wants to rewind the tape,
3356 * then reset the flag and allow access again.
3357 */
3358 if (mtc.mt_op != MTREW &&
3359 mtc.mt_op != MTOFFL &&
3360 mtc.mt_op != MTRETEN &&
3361 mtc.mt_op != MTERASE &&
3362 mtc.mt_op != MTSEEK &&
3363 mtc.mt_op != MTEOM) {
3364 retval = (-EIO);
3365 goto out;
3366 }
3367 reset_state(STp);
3368 /* remove this when the midlevel properly clears was_reset */
3369 STp->device->was_reset = 0;
3370 }
3371
3372 if (mtc.mt_op != MTNOP && mtc.mt_op != MTSETBLK &&
3373 mtc.mt_op != MTSETDENSITY && mtc.mt_op != MTWSM &&
3374 mtc.mt_op != MTSETDRVBUFFER && mtc.mt_op != MTSETPART)
3375 STps->rw = ST_IDLE; /* Prevent automatic WEOF and fsf */
3376
3377 if (mtc.mt_op == MTOFFL && STp->door_locked != ST_UNLOCKED)
3378 do_door_lock(STp, 0); /* Ignore result! */
3379
3380 if (mtc.mt_op == MTSETDRVBUFFER &&
3381 (mtc.mt_count & MT_ST_OPTIONS) != 0) {
3382 retval = st_set_options(STp, mtc.mt_count);
3383 goto out;
3384 }
3385
3386 if (mtc.mt_op == MTSETPART) {
3387 if (!STp->can_partitions ||
3388 mtc.mt_count < 0 || mtc.mt_count >= ST_NBR_PARTITIONS) {
3389 retval = (-EINVAL);
3390 goto out;
3391 }
3392 if (mtc.mt_count >= STp->nbr_partitions &&
3393 (STp->nbr_partitions = nbr_partitions(STp)) < 0) {
3394 retval = (-EIO);
3395 goto out;
3396 }
3397 if (mtc.mt_count >= STp->nbr_partitions) {
3398 retval = (-EINVAL);
3399 goto out;
3400 }
3401 STp->new_partition = mtc.mt_count;
3402 retval = 0;
3403 goto out;
3404 }
3405
3406 if (mtc.mt_op == MTMKPART) {
3407 if (!STp->can_partitions) {
3408 retval = (-EINVAL);
3409 goto out;
3410 }
3411 if ((i = st_int_ioctl(STp, MTREW, 0)) < 0 ||
3412 (i = partition_tape(STp, mtc.mt_count)) < 0) {
3413 retval = i;
3414 goto out;
3415 }
3416 for (i = 0; i < ST_NBR_PARTITIONS; i++) {
3417 STp->ps[i].rw = ST_IDLE;
3418 STp->ps[i].at_sm = 0;
3419 STp->ps[i].last_block_valid = 0;
3420 }
3421 STp->partition = STp->new_partition = 0;
3422 STp->nbr_partitions = 1; /* Bad guess ?-) */
3423 STps->drv_block = STps->drv_file = 0;
3424 retval = 0;
3425 goto out;
3426 }
3427
3428 if (mtc.mt_op == MTSEEK) {
3429 i = set_location(STp, mtc.mt_count, STp->new_partition, 0);
3430 if (!STp->can_partitions)
3431 STp->ps[0].rw = ST_IDLE;
3432 retval = i;
3433 goto out;
3434 }
3435
3436 if (mtc.mt_op == MTUNLOAD || mtc.mt_op == MTOFFL) {
3437 retval = do_load_unload(STp, file, 0);
3438 goto out;
3439 }
3440
3441 if (mtc.mt_op == MTLOAD) {
3442 retval = do_load_unload(STp, file, max(1, mtc.mt_count));
3443 goto out;
3444 }
3445
3446 if (mtc.mt_op == MTLOCK || mtc.mt_op == MTUNLOCK) {
3447 retval = do_door_lock(STp, (mtc.mt_op == MTLOCK));
3448 goto out;
3449 }
3450
3451 if (STp->can_partitions && STp->ready == ST_READY &&
3452 (i = switch_partition(STp)) < 0) {
3453 retval = i;
3454 goto out;
3455 }
3456
3457 if (mtc.mt_op == MTCOMPRESSION)
3458 retval = st_compression(STp, (mtc.mt_count & 1));
3459 else
3460 retval = st_int_ioctl(STp, mtc.mt_op, mtc.mt_count);
3461 goto out;
3462 }
3463 if (!STm->defined) {
3464 retval = (-ENXIO);
3465 goto out;
3466 }
3467
3468 if ((i = flush_buffer(STp, 0)) < 0) {
3469 retval = i;
3470 goto out;
3471 }
3472 if (STp->can_partitions &&
3473 (i = switch_partition(STp)) < 0) {
3474 retval = i;
3475 goto out;
3476 }
3477
3478 if (cmd_type == _IOC_TYPE(MTIOCGET) && cmd_nr == _IOC_NR(MTIOCGET)) {
3479 struct mtget mt_status;
3480
3481 if (_IOC_SIZE(cmd_in) != sizeof(struct mtget)) {
3482 retval = (-EINVAL);
3483 goto out;
3484 }
3485
3486 mt_status.mt_type = STp->tape_type;
3487 mt_status.mt_dsreg =
3488 ((STp->block_size << MT_ST_BLKSIZE_SHIFT) & MT_ST_BLKSIZE_MASK) |
3489 ((STp->density << MT_ST_DENSITY_SHIFT) & MT_ST_DENSITY_MASK);
3490 mt_status.mt_blkno = STps->drv_block;
3491 mt_status.mt_fileno = STps->drv_file;
3492 if (STp->block_size != 0) {
3493 if (STps->rw == ST_WRITING)
3494 mt_status.mt_blkno +=
3495 (STp->buffer)->buffer_bytes / STp->block_size;
3496 else if (STps->rw == ST_READING)
3497 mt_status.mt_blkno -=
3498 ((STp->buffer)->buffer_bytes +
3499 STp->block_size - 1) / STp->block_size;
3500 }
3501
3502 mt_status.mt_gstat = 0;
3503 if (STp->drv_write_prot)
3504 mt_status.mt_gstat |= GMT_WR_PROT(0xffffffff);
3505 if (mt_status.mt_blkno == 0) {
3506 if (mt_status.mt_fileno == 0)
3507 mt_status.mt_gstat |= GMT_BOT(0xffffffff);
3508 else
3509 mt_status.mt_gstat |= GMT_EOF(0xffffffff);
3510 }
3511 mt_status.mt_erreg = (STp->recover_reg << MT_ST_SOFTERR_SHIFT);
3512 mt_status.mt_resid = STp->partition;
3513 if (STps->eof == ST_EOM_OK || STps->eof == ST_EOM_ERROR)
3514 mt_status.mt_gstat |= GMT_EOT(0xffffffff);
3515 else if (STps->eof >= ST_EOM_OK)
3516 mt_status.mt_gstat |= GMT_EOD(0xffffffff);
3517 if (STp->density == 1)
3518 mt_status.mt_gstat |= GMT_D_800(0xffffffff);
3519 else if (STp->density == 2)
3520 mt_status.mt_gstat |= GMT_D_1600(0xffffffff);
3521 else if (STp->density == 3)
3522 mt_status.mt_gstat |= GMT_D_6250(0xffffffff);
3523 if (STp->ready == ST_READY)
3524 mt_status.mt_gstat |= GMT_ONLINE(0xffffffff);
3525 if (STp->ready == ST_NO_TAPE)
3526 mt_status.mt_gstat |= GMT_DR_OPEN(0xffffffff);
3527 if (STps->at_sm)
3528 mt_status.mt_gstat |= GMT_SM(0xffffffff);
3529 if (STm->do_async_writes ||
3530 (STm->do_buffer_writes && STp->block_size != 0) ||
3531 STp->drv_buffer != 0)
3532 mt_status.mt_gstat |= GMT_IM_REP_EN(0xffffffff);
3533 if (STp->cleaning_req)
3534 mt_status.mt_gstat |= GMT_CLN(0xffffffff);
3535
3536 i = copy_to_user(p, &mt_status, sizeof(struct mtget));
3537 if (i) {
3538 retval = (-EFAULT);
3539 goto out;
3540 }
3541
3542 STp->recover_reg = 0; /* Clear after read */
3543 retval = 0;
3544 goto out;
3545 } /* End of MTIOCGET */
3546 if (cmd_type == _IOC_TYPE(MTIOCPOS) && cmd_nr == _IOC_NR(MTIOCPOS)) {
3547 struct mtpos mt_pos;
3548 if (_IOC_SIZE(cmd_in) != sizeof(struct mtpos)) {
3549 retval = (-EINVAL);
3550 goto out;
3551 }
3552 if ((i = get_location(STp, &blk, &bt, 0)) < 0) {
3553 retval = i;
3554 goto out;
3555 }
3556 mt_pos.mt_blkno = blk;
3557 i = copy_to_user(p, &mt_pos, sizeof(struct mtpos));
3558 if (i)
3559 retval = (-EFAULT);
3560 goto out;
3561 }
28f85009 3562 mutex_unlock(&STp->lock);
1da177e4
LT		 3563 switch (cmd_in) {
3564 case SCSI_IOCTL_GET_IDLUN:
3565 case SCSI_IOCTL_GET_BUS_NUMBER:
3566 break;
3567 default:
16c4b3e2
KM		 3568 if ((cmd_in == SG_IO ||
3569 cmd_in == SCSI_IOCTL_SEND_COMMAND ||
3570 cmd_in == CDROM_SEND_PACKET) &&
3571 !capable(CAP_SYS_RAWIO))
1da177e4
LT		 3572 i = -EPERM;
3573 else
45e79a3a
FT		 3574 i = scsi_cmd_ioctl(file, STp->disk->queue,
3575 STp->disk, cmd_in, p);
1da177e4
LT		 3576 if (i != -ENOTTY)
3577 return i;
3578 break;
3579 }
16c4b3e2
KM		 3580 retval = scsi_ioctl(STp->device, cmd_in, p);
3581 if (!retval && cmd_in == SCSI_IOCTL_STOP_UNIT) { /* unload */
3582 STp->rew_at_close = 0;
3583 STp->ready = ST_NO_TAPE;
3584 }
3585 return retval;
1da177e4
LT		 3586
3587 out:
28f85009 3588 mutex_unlock(&STp->lock);
1da177e4
LT		 3589 return retval;
3590}
3591
3592#ifdef CONFIG_COMPAT
3593static long st_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
3594{
3595 struct scsi_tape *STp = file->private_data;
3596 struct scsi_device *sdev = STp->device;
3597 int ret = -ENOIOCTLCMD;
3598 if (sdev->host->hostt->compat_ioctl) {
3599
3600 ret = sdev->host->hostt->compat_ioctl(sdev, cmd, (void __user *)arg);
3601
3602 }
3603 return ret;
3604}
3605#endif
3606
3607\f
3608
3609/* Try to allocate a new tape buffer. Calling function must not hold
3610 dev_arr_lock. */
3611static struct st_buffer *
3612 new_tape_buffer(int from_initialization, int need_dma, int max_sg)
3613{
8b05b773 3614 int i, got = 0;
c53033f6 3615 gfp_t priority;
1da177e4
LT		 3616 struct st_buffer *tb;
3617
3618 if (from_initialization)
3619 priority = GFP_ATOMIC;
3620 else
3621 priority = GFP_KERNEL;
3622
3623 i = sizeof(struct st_buffer) + (max_sg - 1) * sizeof(struct scatterlist) +
3624 max_sg * sizeof(struct st_buf_fragment);
24669f75 3625 tb = kzalloc(i, priority);
1da177e4
LT		 3626 if (!tb) {
3627 printk(KERN_NOTICE "st: Can't allocate new tape buffer.\n");
3628 return NULL;
3629 }
8b05b773 3630 tb->frp_segs = tb->orig_frp_segs = 0;
1da177e4 3631 tb->use_sg = max_sg;
1da177e4
LT		 3632 tb->frp = (struct st_buf_fragment *)(&(tb->sg[0]) + max_sg);
3633
1da177e4
LT		 3634 tb->dma = need_dma;
3635 tb->buffer_size = got;
cd81621c 3636 sg_init_table(tb->sg, max_sg);
1da177e4
LT		 3637
3638 return tb;
3639}
3640
3641
3642/* Try to allocate enough space in the tape buffer */
3643static int enlarge_buffer(struct st_buffer * STbuffer, int new_size, int need_dma)
3644{
c53033f6
AV		 3645 int segs, nbr, max_segs, b_size, order, got;
3646 gfp_t priority;
1da177e4
LT		 3647
3648 if (new_size <= STbuffer->buffer_size)
3649 return 1;
3650
3651 if (STbuffer->buffer_size <= PAGE_SIZE)
3652 normalize_buffer(STbuffer); /* Avoid extra segment */
3653
3654 max_segs = STbuffer->use_sg;
3655 nbr = max_segs - STbuffer->frp_segs;
3656 if (nbr <= 0)
3657 return 0;
3658
3659 priority = GFP_KERNEL | __GFP_NOWARN;
3660 if (need_dma)
3661 priority |= GFP_DMA;
8b05b773 3662 for (b_size = PAGE_SIZE, order=0; order <= 6 &&
1da177e4
LT		 3663 b_size < new_size - STbuffer->buffer_size;
3664 order++, b_size *= 2)
3665 ; /* empty */
3666
3667 for (segs = STbuffer->frp_segs, got = STbuffer->buffer_size;
3668 segs < max_segs && got < new_size;) {
3669 STbuffer->frp[segs].page = alloc_pages(priority, order);
3670 if (STbuffer->frp[segs].page == NULL) {
3671 if (new_size - got <= (max_segs - segs) * b_size / 2) {
3672 b_size /= 2; /* Large enough for the rest of the buffers */
3673 order--;
3674 continue;
3675 }
3676 DEB(STbuffer->buffer_size = got);
3677 normalize_buffer(STbuffer);
3678 return 0;
3679 }
3680 STbuffer->frp[segs].length = b_size;
3681 STbuffer->frp_segs += 1;
3682 got += b_size;
3683 STbuffer->buffer_size = got;
40f6b36c
KM		 3684 if (STbuffer->cleared)
3685 memset(page_address(STbuffer->frp[segs].page), 0, b_size);
1da177e4
LT		 3686 segs++;
3687 }
3688 STbuffer->b_data = page_address(STbuffer->frp[0].page);
3689
3690 return 1;
3691}
3692
3693
40f6b36c
KM		 3694/* Make sure that no data from previous user is in the internal buffer */
3695static void clear_buffer(struct st_buffer * st_bp)
3696{
3697 int i;
3698
3699 for (i=0; i < st_bp->frp_segs; i++)
3700 memset(page_address(st_bp->frp[i].page), 0, st_bp->frp[i].length);
3701 st_bp->cleared = 1;
3702}
3703
3704
1da177e4
LT		 3705/* Release the extra buffer */
3706static void normalize_buffer(struct st_buffer * STbuffer)
3707{
3708 int i, order;
3709
3710 for (i = STbuffer->orig_frp_segs; i < STbuffer->frp_segs; i++) {
3711 order = get_order(STbuffer->frp[i].length);
3712 __free_pages(STbuffer->frp[i].page, order);
3713 STbuffer->buffer_size -= STbuffer->frp[i].length;
3714 }
3715 STbuffer->frp_segs = STbuffer->orig_frp_segs;
3716 STbuffer->frp_sg_current = 0;
8b05b773 3717 STbuffer->sg_segs = 0;
1da177e4
LT		 3718}
3719
3720
3721/* Move data from the user buffer to the tape buffer. Returns zero (success) or
3722 negative error code. */
3723static int append_to_buffer(const char __user *ubp, struct st_buffer * st_bp, int do_count)
3724{
3725 int i, cnt, res, offset;
3726
3727 for (i = 0, offset = st_bp->buffer_bytes;
3728 i < st_bp->frp_segs && offset >= st_bp->frp[i].length; i++)
3729 offset -= st_bp->frp[i].length;
3730 if (i == st_bp->frp_segs) { /* Should never happen */
3731 printk(KERN_WARNING "st: append_to_buffer offset overflow.\n");
3732 return (-EIO);
3733 }
3734 for (; i < st_bp->frp_segs && do_count > 0; i++) {
3735 cnt = st_bp->frp[i].length - offset < do_count ?
3736 st_bp->frp[i].length - offset : do_count;
3737 res = copy_from_user(page_address(st_bp->frp[i].page) + offset, ubp, cnt);
3738 if (res)
3739 return (-EFAULT);
3740 do_count -= cnt;
3741 st_bp->buffer_bytes += cnt;
3742 ubp += cnt;
3743 offset = 0;
3744 }
3745 if (do_count) /* Should never happen */
3746 return (-EIO);
3747
3748 return 0;
3749}
3750
3751
3752/* Move data from the tape buffer to the user buffer. Returns zero (success) or
3753 negative error code. */
3754static int from_buffer(struct st_buffer * st_bp, char __user *ubp, int do_count)
3755{
3756 int i, cnt, res, offset;
3757
3758 for (i = 0, offset = st_bp->read_pointer;
3759 i < st_bp->frp_segs && offset >= st_bp->frp[i].length; i++)
3760 offset -= st_bp->frp[i].length;
3761 if (i == st_bp->frp_segs) { /* Should never happen */
3762 printk(KERN_WARNING "st: from_buffer offset overflow.\n");
3763 return (-EIO);
3764 }
3765 for (; i < st_bp->frp_segs && do_count > 0; i++) {
3766 cnt = st_bp->frp[i].length - offset < do_count ?
3767 st_bp->frp[i].length - offset : do_count;
3768 res = copy_to_user(ubp, page_address(st_bp->frp[i].page) + offset, cnt);
3769 if (res)
3770 return (-EFAULT);
3771 do_count -= cnt;
3772 st_bp->buffer_bytes -= cnt;
3773 st_bp->read_pointer += cnt;
3774 ubp += cnt;
3775 offset = 0;
3776 }
3777 if (do_count) /* Should never happen */
3778 return (-EIO);
3779
3780 return 0;
3781}
3782
3783
3784/* Move data towards start of buffer */
3785static void move_buffer_data(struct st_buffer * st_bp, int offset)
3786{
3787 int src_seg, dst_seg, src_offset = 0, dst_offset;
3788 int count, total;
3789
3790 if (offset == 0)
3791 return;
3792
3793 total=st_bp->buffer_bytes - offset;
3794 for (src_seg=0; src_seg < st_bp->frp_segs; src_seg++) {
3795 src_offset = offset;
3796 if (src_offset < st_bp->frp[src_seg].length)
3797 break;
3798 offset -= st_bp->frp[src_seg].length;
3799 }
3800
3801 st_bp->buffer_bytes = st_bp->read_pointer = total;
3802 for (dst_seg=dst_offset=0; total > 0; ) {
3803 count = min(st_bp->frp[dst_seg].length - dst_offset,
3804 st_bp->frp[src_seg].length - src_offset);
3805 memmove(page_address(st_bp->frp[dst_seg].page) + dst_offset,
3806 page_address(st_bp->frp[src_seg].page) + src_offset, count);
3807 src_offset += count;
3808 if (src_offset >= st_bp->frp[src_seg].length) {
3809 src_seg++;
3810 src_offset = 0;
3811 }
3812 dst_offset += count;
3813 if (dst_offset >= st_bp->frp[dst_seg].length) {
3814 dst_seg++;
3815 dst_offset = 0;
3816 }
3817 total -= count;
3818 }
3819}
3820
3821
3822/* Fill the s/g list up to the length required for this transfer */
3823static void buf_to_sg(struct st_buffer *STbp, unsigned int length)
3824{
3825 int i;
3826 unsigned int count;
3827 struct scatterlist *sg;
3828 struct st_buf_fragment *frp;
3829
3830 if (length == STbp->frp_sg_current)
3831 return; /* work already done */
3832
3833 sg = &(STbp->sg[0]);
3834 frp = STbp->frp;
3835 for (i=count=0; count < length; i++) {
1da177e4 3836 if (length - count > frp[i].length)
642f1490 3837 sg_set_page(&sg[i], frp[i].page, frp[i].length, 0);
1da177e4 3838 else
642f1490 3839 sg_set_page(&sg[i], frp[i].page, length - count, 0);
1da177e4 3840 count += sg[i].length;
1da177e4
LT		 3841 }
3842 STbp->sg_segs = i;
3843 STbp->frp_sg_current = length;
3844}
3845
3846
3847/* Validate the options from command line or module parameters */
3848static void validate_options(void)
3849{
3850 if (buffer_kbs > 0)
3851 st_fixed_buffer_size = buffer_kbs * ST_KILOBYTE;
3852 if (max_sg_segs >= ST_FIRST_SG)
3853 st_max_sg_segs = max_sg_segs;
3854}
3855
3856#ifndef MODULE
3857/* Set the boot options. Syntax is defined in Documenation/scsi/st.txt.
3858 */
3859static int __init st_setup(char *str)
3860{
3861 int i, len, ints[5];
3862 char *stp;
3863
3864 stp = get_options(str, ARRAY_SIZE(ints), ints);
3865
3866 if (ints[0] > 0) {
3867 for (i = 0; i < ints[0] && i < ARRAY_SIZE(parms); i++)
3868 if (parms[i].val)
3869 *parms[i].val = ints[i + 1];
3870 } else {
3871 while (stp != NULL) {
3872 for (i = 0; i < ARRAY_SIZE(parms); i++) {
3873 len = strlen(parms[i].name);
3874 if (!strncmp(stp, parms[i].name, len) &&
3875 (*(stp + len) == ':' || *(stp + len) == '=')) {
3876 if (parms[i].val)
3877 *parms[i].val =
3878 simple_strtoul(stp + len + 1, NULL, 0);
3879 else
3880 printk(KERN_WARNING "st: Obsolete parameter %s\n",
3881 parms[i].name);
3882 break;
3883 }
3884 }
6391a113 3885 if (i >= ARRAY_SIZE(parms))
1da177e4
LT		 3886 printk(KERN_WARNING "st: invalid parameter in '%s'\n",
3887 stp);
3888 stp = strchr(stp, ',');
3889 if (stp)
3890 stp++;
3891 }
3892 }
3893
3894 validate_options();
3895
3896 return 1;
3897}
3898
3899__setup("st=", st_setup);
3900
3901#endif
3902
00977a59 3903static const struct file_operations st_fops =
1da177e4
LT		 3904{
3905 .owner = THIS_MODULE,
3906 .read = st_read,
3907 .write = st_write,
fd66c1b4 3908 .unlocked_ioctl = st_ioctl,
1da177e4
LT		 3909#ifdef CONFIG_COMPAT
3910 .compat_ioctl = st_compat_ioctl,
3911#endif
3912 .open = st_open,
3913 .flush = st_flush,
3914 .release = st_release,
3915};
3916
3917static int st_probe(struct device *dev)
3918{
3919 struct scsi_device *SDp = to_scsi_device(dev);
3920 struct gendisk *disk = NULL;
3921 struct cdev *cdev = NULL;
3922 struct scsi_tape *tpnt = NULL;
3923 struct st_modedef *STm;
3924 struct st_partstat *STps;
3925 struct st_buffer *buffer;
3926 int i, j, mode, dev_num, error;
3927 char *stp;
1da177e4
LT		 3928
3929 if (SDp->type != TYPE_TAPE)
3930 return -ENODEV;
3931 if ((stp = st_incompatible(SDp))) {
3bf743e7 3932 sdev_printk(KERN_INFO, SDp, "Found incompatible tape\n");
1da177e4
LT		 3933 printk(KERN_INFO "st: The suggested driver is %s.\n", stp);
3934 return -ENODEV;
3935 }
3936
8b05b773
MC		 3937 i = min(SDp->request_queue->max_hw_segments,
3938 SDp->request_queue->max_phys_segments);
1da177e4
LT		 3939 if (st_max_sg_segs < i)
3940 i = st_max_sg_segs;
3941 buffer = new_tape_buffer(1, (SDp->host)->unchecked_isa_dma, i);
3942 if (buffer == NULL) {
3943 printk(KERN_ERR
3944 "st: Can't allocate new tape buffer. Device not attached.\n");
3945 goto out;
3946 }
3947
3948 disk = alloc_disk(1);
3949 if (!disk) {
3950 printk(KERN_ERR "st: out of memory. Device not attached.\n");
3951 goto out_buffer_free;
3952 }
3953
3954 write_lock(&st_dev_arr_lock);
3955 if (st_nr_dev >= st_dev_max) {
3956 struct scsi_tape **tmp_da;
3957 int tmp_dev_max;
3958
3959 tmp_dev_max = max(st_nr_dev * 2, 8);
3960 if (tmp_dev_max > ST_MAX_TAPES)
3961 tmp_dev_max = ST_MAX_TAPES;
3962 if (tmp_dev_max <= st_nr_dev) {
3963 write_unlock(&st_dev_arr_lock);
3964 printk(KERN_ERR "st: Too many tape devices (max. %d).\n",
3965 ST_MAX_TAPES);
3966 goto out_put_disk;
3967 }
3968
24669f75 3969 tmp_da = kzalloc(tmp_dev_max * sizeof(struct scsi_tape *), GFP_ATOMIC);
1da177e4
LT		 3970 if (tmp_da == NULL) {
3971 write_unlock(&st_dev_arr_lock);
3972 printk(KERN_ERR "st: Can't extend device array.\n");
3973 goto out_put_disk;
3974 }
3975
1da177e4
LT		 3976 if (scsi_tapes != NULL) {
3977 memcpy(tmp_da, scsi_tapes,
3978 st_dev_max * sizeof(struct scsi_tape *));
3979 kfree(scsi_tapes);
3980 }
3981 scsi_tapes = tmp_da;
3982
3983 st_dev_max = tmp_dev_max;
3984 }
3985
3986 for (i = 0; i < st_dev_max; i++)
3987 if (scsi_tapes[i] == NULL)
3988 break;
3989 if (i >= st_dev_max)
3990 panic("scsi_devices corrupt (st)");
3991
24669f75 3992 tpnt = kzalloc(sizeof(struct scsi_tape), GFP_ATOMIC);
1da177e4
LT		 3993 if (tpnt == NULL) {
3994 write_unlock(&st_dev_arr_lock);
3995 printk(KERN_ERR "st: Can't allocate device descriptor.\n");
3996 goto out_put_disk;
3997 }
f03a5670 3998 kref_init(&tpnt->kref);
1da177e4
LT		 3999 tpnt->disk = disk;
4000 sprintf(disk->disk_name, "st%d", i);
4001 disk->private_data = &tpnt->driver;
4002 disk->queue = SDp->request_queue;
4003 tpnt->driver = &st_template;
4004 scsi_tapes[i] = tpnt;
4005 dev_num = i;
4006
4007 tpnt->device = SDp;
4008 if (SDp->scsi_level <= 2)
4009 tpnt->tape_type = MT_ISSCSI1;
4010 else
4011 tpnt->tape_type = MT_ISSCSI2;
4012
4013 tpnt->buffer = buffer;
f03a5670 4014 tpnt->buffer->last_SRpnt = NULL;
1da177e4
LT		 4015
4016 tpnt->inited = 0;
4017 tpnt->dirty = 0;
4018 tpnt->in_use = 0;
4019 tpnt->drv_buffer = 1; /* Try buffering if no mode sense */
4020 tpnt->restr_dma = (SDp->host)->unchecked_isa_dma;
4021 tpnt->use_pf = (SDp->scsi_level >= SCSI_2);
4022 tpnt->density = 0;
4023 tpnt->do_auto_lock = ST_AUTO_LOCK;
4024 tpnt->can_bsr = (SDp->scsi_level > 2 ? 1 : ST_IN_FILE_POS); /* BSR mandatory in SCSI3 */
4025 tpnt->can_partitions = 0;
4026 tpnt->two_fm = ST_TWO_FM;
4027 tpnt->fast_mteom = ST_FAST_MTEOM;
4028 tpnt->scsi2_logical = ST_SCSI2LOGICAL;
40f6b36c 4029 tpnt->sili = ST_SILI;
1da177e4
LT		 4030 tpnt->immediate = ST_NOWAIT;
4031 tpnt->default_drvbuffer = 0xff; /* No forced buffering */
4032 tpnt->partition = 0;
4033 tpnt->new_partition = 0;
4034 tpnt->nbr_partitions = 0;
4035 tpnt->device->timeout = ST_TIMEOUT;
4036 tpnt->long_timeout = ST_LONG_TIMEOUT;
4037 tpnt->try_dio = try_direct_io && !SDp->host->unchecked_isa_dma;
4038
1da177e4
LT		 4039 for (i = 0; i < ST_NBR_MODES; i++) {
4040 STm = &(tpnt->modes[i]);
4041 STm->defined = 0;
4042 STm->sysv = ST_SYSV;
4043 STm->defaults_for_writes = 0;
4044 STm->do_async_writes = ST_ASYNC_WRITES;
4045 STm->do_buffer_writes = ST_BUFFER_WRITES;
4046 STm->do_read_ahead = ST_READ_AHEAD;
4047 STm->default_compression = ST_DONT_TOUCH;
4048 STm->default_blksize = (-1); /* No forced size */
4049 STm->default_density = (-1); /* No forced density */
4050 }
4051
4052 for (i = 0; i < ST_NBR_PARTITIONS; i++) {
4053 STps = &(tpnt->ps[i]);
4054 STps->rw = ST_IDLE;
4055 STps->eof = ST_NOEOF;
4056 STps->at_sm = 0;
4057 STps->last_block_valid = 0;
4058 STps->drv_block = (-1);
4059 STps->drv_file = (-1);
4060 }
4061
4062 tpnt->current_mode = 0;
4063 tpnt->modes[0].defined = 1;
4064
4065 tpnt->density_changed = tpnt->compression_changed =
4066 tpnt->blksize_changed = 0;
28f85009 4067 mutex_init(&tpnt->lock);
1da177e4
LT		 4068
4069 st_nr_dev++;
4070 write_unlock(&st_dev_arr_lock);
4071
4072 for (mode = 0; mode < ST_NBR_MODES; ++mode) {
4073 STm = &(tpnt->modes[mode]);
4074 for (j=0; j < 2; j++) {
4075 cdev = cdev_alloc();
4076 if (!cdev) {
4077 printk(KERN_ERR
4078 "st%d: out of memory. Device not attached.\n",
4079 dev_num);
4080 goto out_free_tape;
4081 }
4082 cdev->owner = THIS_MODULE;
4083 cdev->ops = &st_fops;
4084
4085 error = cdev_add(cdev,
4086 MKDEV(SCSI_TAPE_MAJOR, TAPE_MINOR(dev_num, mode, j)),
4087 1);
4088 if (error) {
4089 printk(KERN_ERR "st%d: Can't add %s-rewind mode %d\n",
4090 dev_num, j ? "non" : "auto", mode);
4091 printk(KERN_ERR "st%d: Device not attached.\n", dev_num);
4092 goto out_free_tape;
4093 }
4094 STm->cdevs[j] = cdev;
4095
4096 }
13026a6b
JG		 4097 error = do_create_class_files(tpnt, dev_num, mode);
4098 if (error)
4099 goto out_free_tape;
1da177e4
LT		 4100 }
4101
42252854 4102 sdev_printk(KERN_NOTICE, SDp,
8b1ea24c 4103 "Attached scsi tape %s\n", tape_name(tpnt));
42252854
KM		 4104 sdev_printk(KERN_INFO, SDp, "%s: try direct i/o: %s (alignment %d B)\n",
4105 tape_name(tpnt), tpnt->try_dio ? "yes" : "no",
4106 queue_dma_alignment(SDp->request_queue) + 1);
1da177e4
LT		 4107
4108 return 0;
4109
4110out_free_tape:
4111 for (mode=0; mode < ST_NBR_MODES; mode++) {
4112 STm = &(tpnt->modes[mode]);
4113 sysfs_remove_link(&tpnt->device->sdev_gendev.kobj,
4114 "tape");
4115 for (j=0; j < 2; j++) {
4116 if (STm->cdevs[j]) {
4117 if (cdev == STm->cdevs[j])
4118 cdev = NULL;
ee959b00
TJ		 4119 device_destroy(st_sysfs_class,
4120 MKDEV(SCSI_TAPE_MAJOR,
4121 TAPE_MINOR(i, mode, j)));
1da177e4
LT		 4122 cdev_del(STm->cdevs[j]);
4123 }
4124 }
4125 }
4126 if (cdev)
4127 cdev_del(cdev);
4128 write_lock(&st_dev_arr_lock);
4129 scsi_tapes[dev_num] = NULL;
4130 st_nr_dev--;
4131 write_unlock(&st_dev_arr_lock);
4132out_put_disk:
4133 put_disk(disk);
c9475cb0 4134 kfree(tpnt);
1da177e4
LT		 4135out_buffer_free:
4136 kfree(buffer);
4137out:
4138 return -ENODEV;
4139};
4140
4141
4142static int st_remove(struct device *dev)
4143{
4144 struct scsi_device *SDp = to_scsi_device(dev);
4145 struct scsi_tape *tpnt;
4146 int i, j, mode;
4147
4148 write_lock(&st_dev_arr_lock);
4149 for (i = 0; i < st_dev_max; i++) {
4150 tpnt = scsi_tapes[i];
4151 if (tpnt != NULL && tpnt->device == SDp) {
4152 scsi_tapes[i] = NULL;
4153 st_nr_dev--;
4154 write_unlock(&st_dev_arr_lock);
1da177e4
LT		 4155 sysfs_remove_link(&tpnt->device->sdev_gendev.kobj,
4156 "tape");
4157 for (mode = 0; mode < ST_NBR_MODES; ++mode) {
1da177e4 4158 for (j=0; j < 2; j++) {
ee959b00
TJ		 4159 device_destroy(st_sysfs_class,
4160 MKDEV(SCSI_TAPE_MAJOR,
4161 TAPE_MINOR(i, mode, j)));
1da177e4
LT		 4162 cdev_del(tpnt->modes[mode].cdevs[j]);
4163 tpnt->modes[mode].cdevs[j] = NULL;
4164 }
4165 }
1da177e4 4166
0b950672 4167 mutex_lock(&st_ref_mutex);
f03a5670 4168 kref_put(&tpnt->kref, scsi_tape_release);
0b950672 4169 mutex_unlock(&st_ref_mutex);
1da177e4
LT		 4170 return 0;
4171 }
4172 }
4173
4174 write_unlock(&st_dev_arr_lock);
4175 return 0;
4176}
4177
f03a5670
KM		 4178/**
4179 * scsi_tape_release - Called to free the Scsi_Tape structure
4180 * @kref: pointer to embedded kref
4181 *
0b950672 4182 * st_ref_mutex must be held entering this routine. Because it is
f03a5670
KM		 4183 * called on last put, you should always use the scsi_tape_get()
4184 * scsi_tape_put() helpers which manipulate the semaphore directly
4185 * and never do a direct kref_put().
4186 **/
4187static void scsi_tape_release(struct kref *kref)
4188{
4189 struct scsi_tape *tpnt = to_scsi_tape(kref);
4190 struct gendisk *disk = tpnt->disk;
4191
4192 tpnt->device = NULL;
4193
4194 if (tpnt->buffer) {
4195 tpnt->buffer->orig_frp_segs = 0;
4196 normalize_buffer(tpnt->buffer);
4197 kfree(tpnt->buffer);
4198 }
4199
4200 disk->private_data = NULL;
4201 put_disk(disk);
4202 kfree(tpnt);
4203 return;
4204}
4205
1da177e4
LT		 4206static int __init init_st(void)
4207{
13026a6b
JG		 4208 int err;
4209
1da177e4
LT		 4210 validate_options();
4211
13026a6b 4212 printk(KERN_INFO "st: Version %s, fixed bufsize %d, s/g segs %d\n",
1da177e4
LT		 4213 verstr, st_fixed_buffer_size, st_max_sg_segs);
4214
d253878b 4215 st_sysfs_class = class_create(THIS_MODULE, "scsi_tape");
1da177e4 4216 if (IS_ERR(st_sysfs_class)) {
1da177e4 4217 printk(KERN_ERR "Unable create sysfs class for SCSI tapes\n");
13026a6b 4218 return PTR_ERR(st_sysfs_class);
1da177e4
LT		 4219 }
4220
13026a6b
JG		 4221 err = register_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0),
4222 ST_MAX_TAPE_ENTRIES, "st");
4223 if (err) {
4224 printk(KERN_ERR "Unable to get major %d for SCSI tapes\n",
4225 SCSI_TAPE_MAJOR);
4226 goto err_class;
1da177e4
LT		 4227 }
4228
13026a6b
JG		 4229 err = scsi_register_driver(&st_template.gendrv);
4230 if (err)
4231 goto err_chrdev;
4232
405ae7d3 4233 err = do_create_sysfs_files();
13026a6b
JG		 4234 if (err)
4235 goto err_scsidrv;
4236
4237 return 0;
4238
4239err_scsidrv:
4240 scsi_unregister_driver(&st_template.gendrv);
4241err_chrdev:
4242 unregister_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0),
4243 ST_MAX_TAPE_ENTRIES);
4244err_class:
4245 class_destroy(st_sysfs_class);
4246 return err;
1da177e4
LT		 4247}
4248
4249static void __exit exit_st(void)
4250{
405ae7d3 4251 do_remove_sysfs_files();
1da177e4
LT		 4252 scsi_unregister_driver(&st_template.gendrv);
4253 unregister_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0),
4254 ST_MAX_TAPE_ENTRIES);
c2c96f46 4255 class_destroy(st_sysfs_class);
1da177e4
LT		 4256 kfree(scsi_tapes);
4257 printk(KERN_INFO "st: Unloaded.\n");
4258}
4259
4260module_init(init_st);
4261module_exit(exit_st);
4262
4263
4264/* The sysfs driver interface. Read-only at the moment */
4265static ssize_t st_try_direct_io_show(struct device_driver *ddp, char *buf)
4266{
4267 return snprintf(buf, PAGE_SIZE, "%d\n", try_direct_io);
4268}
4269static DRIVER_ATTR(try_direct_io, S_IRUGO, st_try_direct_io_show, NULL);
4270
4271static ssize_t st_fixed_buffer_size_show(struct device_driver *ddp, char *buf)
4272{
4273 return snprintf(buf, PAGE_SIZE, "%d\n", st_fixed_buffer_size);
4274}
4275static DRIVER_ATTR(fixed_buffer_size, S_IRUGO, st_fixed_buffer_size_show, NULL);
4276
4277static ssize_t st_max_sg_segs_show(struct device_driver *ddp, char *buf)
4278{
4279 return snprintf(buf, PAGE_SIZE, "%d\n", st_max_sg_segs);
4280}
4281static DRIVER_ATTR(max_sg_segs, S_IRUGO, st_max_sg_segs_show, NULL);
4282
4283static ssize_t st_version_show(struct device_driver *ddd, char *buf)
4284{
4285 return snprintf(buf, PAGE_SIZE, "[%s]\n", verstr);
4286}
4287static DRIVER_ATTR(version, S_IRUGO, st_version_show, NULL);
4288
405ae7d3 4289static int do_create_sysfs_files(void)
1da177e4 4290{
405ae7d3 4291 struct device_driver *sysfs = &st_template.gendrv;
13026a6b
JG		 4292 int err;
4293
405ae7d3 4294 err = driver_create_file(sysfs, &driver_attr_try_direct_io);
13026a6b
JG		 4295 if (err)
4296 return err;
405ae7d3 4297 err = driver_create_file(sysfs, &driver_attr_fixed_buffer_size);
13026a6b
JG		 4298 if (err)
4299 goto err_try_direct_io;
405ae7d3 4300 err = driver_create_file(sysfs, &driver_attr_max_sg_segs);
13026a6b
JG		 4301 if (err)
4302 goto err_attr_fixed_buf;
405ae7d3 4303 err = driver_create_file(sysfs, &driver_attr_version);
13026a6b
JG		 4304 if (err)
4305 goto err_attr_max_sg;
1da177e4 4306
13026a6b
JG		 4307 return 0;
4308
4309err_attr_max_sg:
405ae7d3 4310 driver_remove_file(sysfs, &driver_attr_max_sg_segs);
13026a6b 4311err_attr_fixed_buf:
405ae7d3 4312 driver_remove_file(sysfs, &driver_attr_fixed_buffer_size);
13026a6b 4313err_try_direct_io:
405ae7d3 4314 driver_remove_file(sysfs, &driver_attr_try_direct_io);
13026a6b 4315 return err;
1da177e4
LT		 4316}
4317
405ae7d3 4318static void do_remove_sysfs_files(void)
1da177e4 4319{
405ae7d3 4320 struct device_driver *sysfs = &st_template.gendrv;
1da177e4 4321
405ae7d3
RD		 4322 driver_remove_file(sysfs, &driver_attr_version);
4323 driver_remove_file(sysfs, &driver_attr_max_sg_segs);
4324 driver_remove_file(sysfs, &driver_attr_fixed_buffer_size);
4325 driver_remove_file(sysfs, &driver_attr_try_direct_io);
1da177e4
LT		 4326}
4327
4328
4329/* The sysfs simple class interface */
ee959b00
TJ		 4330static ssize_t
4331st_defined_show(struct device *dev, struct device_attribute *attr, char *buf)
1da177e4 4332{
7d15d6a4 4333 struct st_modedef *STm = dev_get_drvdata(dev);
1da177e4
LT		 4334 ssize_t l = 0;
4335
4336 l = snprintf(buf, PAGE_SIZE, "%d\n", STm->defined);
4337 return l;
4338}
4339
ee959b00 4340DEVICE_ATTR(defined, S_IRUGO, st_defined_show, NULL);
1da177e4 4341
ee959b00
TJ		 4342static ssize_t
4343st_defblk_show(struct device *dev, struct device_attribute *attr, char *buf)
1da177e4 4344{
7d15d6a4 4345 struct st_modedef *STm = dev_get_drvdata(dev);
1da177e4
LT		 4346 ssize_t l = 0;
4347
4348 l = snprintf(buf, PAGE_SIZE, "%d\n", STm->default_blksize);
4349 return l;
4350}
4351
ee959b00 4352DEVICE_ATTR(default_blksize, S_IRUGO, st_defblk_show, NULL);
1da177e4 4353
ee959b00
TJ		 4354static ssize_t
4355st_defdensity_show(struct device *dev, struct device_attribute *attr, char *buf)
1da177e4 4356{
7d15d6a4 4357 struct st_modedef *STm = dev_get_drvdata(dev);
1da177e4
LT		 4358 ssize_t l = 0;
4359 char *fmt;
4360
4361 fmt = STm->default_density >= 0 ? "0x%02x\n" : "%d\n";
4362 l = snprintf(buf, PAGE_SIZE, fmt, STm->default_density);
4363 return l;
4364}
4365
ee959b00 4366DEVICE_ATTR(default_density, S_IRUGO, st_defdensity_show, NULL);
1da177e4 4367
ee959b00
TJ		 4368static ssize_t
4369st_defcompression_show(struct device *dev, struct device_attribute *attr,
4370 char *buf)
1da177e4 4371{
7d15d6a4 4372 struct st_modedef *STm = dev_get_drvdata(dev);
1da177e4
LT		 4373 ssize_t l = 0;
4374
4375 l = snprintf(buf, PAGE_SIZE, "%d\n", STm->default_compression - 1);
4376 return l;
4377}
4378
ee959b00 4379DEVICE_ATTR(default_compression, S_IRUGO, st_defcompression_show, NULL);
1da177e4 4380
ee959b00
TJ		 4381static ssize_t
4382st_options_show(struct device *dev, struct device_attribute *attr, char *buf)
b174be02 4383{
7d15d6a4 4384 struct st_modedef *STm = dev_get_drvdata(dev);
b174be02
KM		 4385 struct scsi_tape *STp;
4386 int i, j, options;
4387 ssize_t l = 0;
4388
4389 for (i=0; i < st_dev_max; i++) {
4390 for (j=0; j < ST_NBR_MODES; j++)
4391 if (&scsi_tapes[i]->modes[j] == STm)
4392 break;
4393 if (j < ST_NBR_MODES)
4394 break;
4395 }
4396 if (i == st_dev_max)
4397 return 0; /* should never happen */
4398
4399 STp = scsi_tapes[i];
4400
4401 options = STm->do_buffer_writes ? MT_ST_BUFFER_WRITES : 0;
4402 options |= STm->do_async_writes ? MT_ST_ASYNC_WRITES : 0;
4403 options |= STm->do_read_ahead ? MT_ST_READ_AHEAD : 0;
4404 DEB( options |= debugging ? MT_ST_DEBUGGING : 0 );
4405 options |= STp->two_fm ? MT_ST_TWO_FM : 0;
4406 options |= STp->fast_mteom ? MT_ST_FAST_MTEOM : 0;
4407 options |= STm->defaults_for_writes ? MT_ST_DEF_WRITES : 0;
4408 options |= STp->can_bsr ? MT_ST_CAN_BSR : 0;
4409 options |= STp->omit_blklims ? MT_ST_NO_BLKLIMS : 0;
4410 options |= STp->can_partitions ? MT_ST_CAN_PARTITIONS : 0;
4411 options |= STp->scsi2_logical ? MT_ST_SCSI2LOGICAL : 0;
4412 options |= STm->sysv ? MT_ST_SYSV : 0;
4413 options |= STp->immediate ? MT_ST_NOWAIT : 0;
4414 options |= STp->sili ? MT_ST_SILI : 0;
4415
4416 l = snprintf(buf, PAGE_SIZE, "0x%08x\n", options);
4417 return l;
4418}
4419
ee959b00 4420DEVICE_ATTR(options, S_IRUGO, st_options_show, NULL);
b174be02 4421
13026a6b 4422static int do_create_class_files(struct scsi_tape *STp, int dev_num, int mode)
1da177e4
LT		 4423{
4424 int i, rew, error;
4425 char name[10];
ee959b00 4426 struct device *st_class_member;
1da177e4 4427
1da177e4
LT		 4428 for (rew=0; rew < 2; rew++) {
4429 /* Make sure that the minor numbers corresponding to the four
4430 first modes always get the same names */
4431 i = mode << (4 - ST_NBR_MODE_BITS);
4432 snprintf(name, 10, "%s%s%s", rew ? "n" : "",
4433 STp->disk->disk_name, st_formats[i]);
4434 st_class_member =
24b42566
GKH		 4435 device_create_drvdata(st_sysfs_class,
4436 &STp->device->sdev_gendev,
4437 MKDEV(SCSI_TAPE_MAJOR,
4438 TAPE_MINOR(dev_num,
4439 mode, rew)),
4440 &STp->modes[mode],
4441 "%s", name);
1da177e4 4442 if (IS_ERR(st_class_member)) {
ee959b00 4443 printk(KERN_WARNING "st%d: device_create failed\n",
1da177e4 4444 dev_num);
13026a6b 4445 error = PTR_ERR(st_class_member);
1da177e4
LT		 4446 goto out;
4447 }
1da177e4 4448
ee959b00
TJ		 4449 error = device_create_file(st_class_member,
4450 &dev_attr_defined);
13026a6b 4451 if (error) goto out;
ee959b00
TJ		 4452 error = device_create_file(st_class_member,
4453 &dev_attr_default_blksize);
13026a6b 4454 if (error) goto out;
ee959b00
TJ		 4455 error = device_create_file(st_class_member,
4456 &dev_attr_default_density);
13026a6b 4457 if (error) goto out;
ee959b00
TJ		 4458 error = device_create_file(st_class_member,
4459 &dev_attr_default_compression);
13026a6b 4460 if (error) goto out;
ee959b00
TJ		 4461 error = device_create_file(st_class_member,
4462 &dev_attr_options);
b174be02 4463 if (error) goto out;
13026a6b 4464
1da177e4
LT		 4465 if (mode == 0 && rew == 0) {
4466 error = sysfs_create_link(&STp->device->sdev_gendev.kobj,
4467 &st_class_member->kobj,
4468 "tape");
4469 if (error) {
4470 printk(KERN_ERR
4471 "st%d: Can't create sysfs link from SCSI device.\n",
4472 dev_num);
13026a6b 4473 goto out;
1da177e4
LT		 4474 }
4475 }
4476 }
13026a6b
JG		 4477
4478 return 0;
4479
4480out:
4481 return error;
1da177e4
LT		 4482}
4483
1da177e4
LT		 4484/* The following functions may be useful for a larger audience. */
4485static int sgl_map_user_pages(struct scatterlist *sgl, const unsigned int max_pages,
4486 unsigned long uaddr, size_t count, int rw)
4487{
07542b83
JB		 4488 unsigned long end = (uaddr + count + PAGE_SIZE - 1) >> PAGE_SHIFT;
4489 unsigned long start = uaddr >> PAGE_SHIFT;
4490 const int nr_pages = end - start;
1da177e4 4491 int res, i, j;
1da177e4
LT		 4492 struct page **pages;
4493
1da177e4
LT		 4494 /* User attempted Overflow! */
4495 if ((uaddr + count) < uaddr)
4496 return -EINVAL;
4497
4498 /* Too big */
4499 if (nr_pages > max_pages)
4500 return -ENOMEM;
4501
4502 /* Hmm? */
4503 if (count == 0)
4504 return 0;
4505
4506 if ((pages = kmalloc(max_pages * sizeof(*pages), GFP_KERNEL)) == NULL)
4507 return -ENOMEM;
4508
4509 /* Try to fault in all of the necessary pages */
4510 down_read(&current->mm->mmap_sem);
4511 /* rw==READ means read from drive, write into memory area */
4512 res = get_user_pages(
4513 current,
4514 current->mm,
4515 uaddr,
4516 nr_pages,
4517 rw == READ,
4518 0, /* don't force */
4519 pages,
4520 NULL);
4521 up_read(&current->mm->mmap_sem);
4522
4523 /* Errors and no page mapped should return here */
4524 if (res < nr_pages)
4525 goto out_unmap;
4526
4527 for (i=0; i < nr_pages; i++) {
4528 /* FIXME: flush superflous for rw==READ,
4529 * probably wrong function for rw==WRITE
4530 */
4531 flush_dcache_page(pages[i]);
4532 }
4533
4534 /* Populate the scatter/gather list */
642f1490 4535 sg_set_page(&sgl[0], pages[0], 0, uaddr & ~PAGE_MASK);
1da177e4
LT		 4536 if (nr_pages > 1) {
4537 sgl[0].length = PAGE_SIZE - sgl[0].offset;
4538 count -= sgl[0].length;
4539 for (i=1; i < nr_pages ; i++) {
642f1490
JA		 4540 sg_set_page(&sgl[i], pages[i],
4541 count < PAGE_SIZE ? count : PAGE_SIZE, 0);;
1da177e4
LT		 4542 count -= PAGE_SIZE;
4543 }
4544 }
4545 else {
4546 sgl[0].length = count;
4547 }
4548
4549 kfree(pages);
4550 return nr_pages;
4551
4552 out_unmap:
4553 if (res > 0) {
4554 for (j=0; j < res; j++)
4555 page_cache_release(pages[j]);
6bc733e9 4556 res = 0;
1da177e4
LT		 4557 }
4558 kfree(pages);
4559 return res;
4560}
4561
4562
4563/* And unmap them... */
4564static int sgl_unmap_user_pages(struct scatterlist *sgl, const unsigned int nr_pages,
4565 int dirtied)
4566{
4567 int i;
4568
4569 for (i=0; i < nr_pages; i++) {
45711f1a 4570 struct page *page = sg_page(&sgl[i]);
b5810039 4571
b5810039
NP		 4572 if (dirtied)
4573 SetPageDirty(page);
1da177e4
LT		 4574 /* FIXME: cache flush missing for rw==READ
4575 * FIXME: call the correct reference counting function
4576 */
b5810039 4577 page_cache_release(page);
1da177e4
LT		 4578 }
4579
4580 return 0;
4581}
Clone of davem's net-next-2.6 tree