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