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