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