?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
x86: Cleanup highmap after brk is concluded
[linux/fpc-iii.git] / drivers / scsi / st.c
blob5081f97cbdaa2ac26e5ef5d873ac8841f8e81d88
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 && value >= SCSI_SENSE_BUFFERSIZE)
2286 return (-EINVAL);
2287 STp->cln_mode = value;
2288 STp->cln_sense_mask = (options >> 8) & 0xff;
2289 STp->cln_sense_value = (options >> 16) & 0xff;
2290 printk(KERN_INFO
2291 "%s: Cleaning request mode %d, mask %02x, value %02x\n",
2292 name, value, STp->cln_sense_mask, STp->cln_sense_value);
2293 } else if (code == MT_ST_DEF_OPTIONS) {
2294 code = (options & ~MT_ST_CLEAR_DEFAULT);
2295 value = (options & MT_ST_CLEAR_DEFAULT);
2296 if (code == MT_ST_DEF_DENSITY) {
2297 if (value == MT_ST_CLEAR_DEFAULT) {
2298 STm->default_density = (-1);
2299 DEBC( printk(KERN_INFO "%s: Density default disabled.\n",
2300 name));
2301 } else {
2302 STm->default_density = value & 0xff;
2303 DEBC( printk(KERN_INFO "%s: Density default set to %x\n",
2304 name, STm->default_density));
2305 if (STp->ready == ST_READY) {
2306 STp->density_changed = 0;
2307 set_mode_densblk(STp, STm);
2308 }
2309 }
2310 } else if (code == MT_ST_DEF_DRVBUFFER) {
2311 if (value == MT_ST_CLEAR_DEFAULT) {
2312 STp->default_drvbuffer = 0xff;
2313 DEBC( printk(KERN_INFO
2314 "%s: Drive buffer default disabled.\n", name));
2315 } else {
2316 STp->default_drvbuffer = value & 7;
2317 DEBC( printk(KERN_INFO
2318 "%s: Drive buffer default set to %x\n",
2319 name, STp->default_drvbuffer));
2320 if (STp->ready == ST_READY)
2321 st_int_ioctl(STp, MTSETDRVBUFFER, STp->default_drvbuffer);
2322 }
2323 } else if (code == MT_ST_DEF_COMPRESSION) {
2324 if (value == MT_ST_CLEAR_DEFAULT) {
2325 STm->default_compression = ST_DONT_TOUCH;
2326 DEBC( printk(KERN_INFO
2327 "%s: Compression default disabled.\n", name));
2328 } else {
2329 if ((value & 0xff00) != 0) {
2330 STp->c_algo = (value & 0xff00) >> 8;
2331 DEBC( printk(KERN_INFO "%s: Compression algorithm set to 0x%x.\n",
2332 name, STp->c_algo));
2333 }
2334 if ((value & 0xff) != 0xff) {
2335 STm->default_compression = (value & 1 ? ST_YES : ST_NO);
2336 DEBC( printk(KERN_INFO "%s: Compression default set to %x\n",
2337 name, (value & 1)));
2338 if (STp->ready == ST_READY) {
2339 STp->compression_changed = 0;
2340 st_compression(STp, (STm->default_compression == ST_YES));
2341 }
2342 }
2343 }
2344 }
2345 } else
2346 return (-EIO);
2347
2348 return 0;
2349 }
2350 \f
2351 #define MODE_HEADER_LENGTH 4
2352
2353 /* Mode header and page byte offsets */
2354 #define MH_OFF_DATA_LENGTH 0
2355 #define MH_OFF_MEDIUM_TYPE 1
2356 #define MH_OFF_DEV_SPECIFIC 2
2357 #define MH_OFF_BDESCS_LENGTH 3
2358 #define MP_OFF_PAGE_NBR 0
2359 #define MP_OFF_PAGE_LENGTH 1
2360
2361 /* Mode header and page bit masks */
2362 #define MH_BIT_WP 0x80
2363 #define MP_MSK_PAGE_NBR 0x3f
2364
2365 /* Don't return block descriptors */
2366 #define MODE_SENSE_OMIT_BDESCS 0x08
2367
2368 #define MODE_SELECT_PAGE_FORMAT 0x10
2369
2370 /* Read a mode page into the tape buffer. The block descriptors are included
2371 if incl_block_descs is true. The page control is ored to the page number
2372 parameter, if necessary. */
2373 static int read_mode_page(struct scsi_tape *STp, int page, int omit_block_descs)
2374 {
2375 unsigned char cmd[MAX_COMMAND_SIZE];
2376 struct st_request *SRpnt;
2377
2378 memset(cmd, 0, MAX_COMMAND_SIZE);
2379 cmd[0] = MODE_SENSE;
2380 if (omit_block_descs)
2381 cmd[1] = MODE_SENSE_OMIT_BDESCS;
2382 cmd[2] = page;
2383 cmd[4] = 255;
2384
2385 SRpnt = st_do_scsi(NULL, STp, cmd, cmd[4], DMA_FROM_DEVICE,
2386 STp->device->request_queue->rq_timeout, 0, 1);
2387 if (SRpnt == NULL)
2388 return (STp->buffer)->syscall_result;
2389
2390 st_release_request(SRpnt);
2391
2392 return STp->buffer->syscall_result;
2393 }
2394
2395
2396 /* Send the mode page in the tape buffer to the drive. Assumes that the mode data
2397 in the buffer is correctly formatted. The long timeout is used if slow is non-zero. */
2398 static int write_mode_page(struct scsi_tape *STp, int page, int slow)
2399 {
2400 int pgo;
2401 unsigned char cmd[MAX_COMMAND_SIZE];
2402 struct st_request *SRpnt;
2403 int timeout;
2404
2405 memset(cmd, 0, MAX_COMMAND_SIZE);
2406 cmd[0] = MODE_SELECT;
2407 cmd[1] = MODE_SELECT_PAGE_FORMAT;
2408 pgo = MODE_HEADER_LENGTH + (STp->buffer)->b_data[MH_OFF_BDESCS_LENGTH];
2409 cmd[4] = pgo + (STp->buffer)->b_data[pgo + MP_OFF_PAGE_LENGTH] + 2;
2410
2411 /* Clear reserved fields */
2412 (STp->buffer)->b_data[MH_OFF_DATA_LENGTH] = 0;
2413 (STp->buffer)->b_data[MH_OFF_MEDIUM_TYPE] = 0;
2414 (STp->buffer)->b_data[MH_OFF_DEV_SPECIFIC] &= ~MH_BIT_WP;
2415 (STp->buffer)->b_data[pgo + MP_OFF_PAGE_NBR] &= MP_MSK_PAGE_NBR;
2416
2417 timeout = slow ?
2418 STp->long_timeout : STp->device->request_queue->rq_timeout;
2419 SRpnt = st_do_scsi(NULL, STp, cmd, cmd[4], DMA_TO_DEVICE,
2420 timeout, 0, 1);
2421 if (SRpnt == NULL)
2422 return (STp->buffer)->syscall_result;
2423
2424 st_release_request(SRpnt);
2425
2426 return STp->buffer->syscall_result;
2427 }
2428
2429
2430 #define COMPRESSION_PAGE 0x0f
2431 #define COMPRESSION_PAGE_LENGTH 16
2432
2433 #define CP_OFF_DCE_DCC 2
2434 #define CP_OFF_C_ALGO 7
2435
2436 #define DCE_MASK 0x80
2437 #define DCC_MASK 0x40
2438 #define RED_MASK 0x60
2439
2440
2441 /* Control the compression with mode page 15. Algorithm not changed if zero.
2442
2443 The block descriptors are read and written because Sony SDT-7000 does not
2444 work without this (suggestion from Michael Schaefer <Michael.Schaefer@dlr.de>).
2445 Including block descriptors should not cause any harm to other drives. */
2446
2447 static int st_compression(struct scsi_tape * STp, int state)
2448 {
2449 int retval;
2450 int mpoffs; /* Offset to mode page start */
2451 unsigned char *b_data = (STp->buffer)->b_data;
2452 DEB( char *name = tape_name(STp); )
2453
2454 if (STp->ready != ST_READY)
2455 return (-EIO);
2456
2457 /* Read the current page contents */
2458 retval = read_mode_page(STp, COMPRESSION_PAGE, 0);
2459 if (retval) {
2460 DEBC(printk(ST_DEB_MSG "%s: Compression mode page not supported.\n",
2461 name));
2462 return (-EIO);
2463 }
2464
2465 mpoffs = MODE_HEADER_LENGTH + b_data[MH_OFF_BDESCS_LENGTH];
2466 DEBC(printk(ST_DEB_MSG "%s: Compression state is %d.\n", name,
2467 (b_data[mpoffs + CP_OFF_DCE_DCC] & DCE_MASK ? 1 : 0)));
2468
2469 /* Check if compression can be changed */
2470 if ((b_data[mpoffs + CP_OFF_DCE_DCC] & DCC_MASK) == 0) {
2471 DEBC(printk(ST_DEB_MSG "%s: Compression not supported.\n", name));
2472 return (-EIO);
2473 }
2474
2475 /* Do the change */
2476 if (state) {
2477 b_data[mpoffs + CP_OFF_DCE_DCC] |= DCE_MASK;
2478 if (STp->c_algo != 0)
2479 b_data[mpoffs + CP_OFF_C_ALGO] = STp->c_algo;
2480 }
2481 else {
2482 b_data[mpoffs + CP_OFF_DCE_DCC] &= ~DCE_MASK;
2483 if (STp->c_algo != 0)
2484 b_data[mpoffs + CP_OFF_C_ALGO] = 0; /* no compression */
2485 }
2486
2487 retval = write_mode_page(STp, COMPRESSION_PAGE, 0);
2488 if (retval) {
2489 DEBC(printk(ST_DEB_MSG "%s: Compression change failed.\n", name));
2490 return (-EIO);
2491 }
2492 DEBC(printk(ST_DEB_MSG "%s: Compression state changed to %d.\n",
2493 name, state));
2494
2495 STp->compression_changed = 1;
2496 return 0;
2497 }
2498
2499
2500 /* Process the load and unload commands (does unload if the load code is zero) */
2501 static int do_load_unload(struct scsi_tape *STp, struct file *filp, int load_code)
2502 {
2503 int retval = (-EIO), timeout;
2504 DEB( char *name = tape_name(STp); )
2505 unsigned char cmd[MAX_COMMAND_SIZE];
2506 struct st_partstat *STps;
2507 struct st_request *SRpnt;
2508
2509 if (STp->ready != ST_READY && !load_code) {
2510 if (STp->ready == ST_NO_TAPE)
2511 return (-ENOMEDIUM);
2512 else
2513 return (-EIO);
2514 }
2515
2516 memset(cmd, 0, MAX_COMMAND_SIZE);
2517 cmd[0] = START_STOP;
2518 if (load_code)
2519 cmd[4] |= 1;
2520 /*
2521 * If arg >= 1 && arg <= 6 Enhanced load/unload in HP C1553A
2522 */
2523 if (load_code >= 1 + MT_ST_HPLOADER_OFFSET
2524 && load_code <= 6 + MT_ST_HPLOADER_OFFSET) {
2525 DEBC(printk(ST_DEB_MSG "%s: Enhanced %sload slot %2d.\n",
2526 name, (cmd[4]) ? "" : "un",
2527 load_code - MT_ST_HPLOADER_OFFSET));
2528 cmd[3] = load_code - MT_ST_HPLOADER_OFFSET; /* MediaID field of C1553A */
2529 }
2530 if (STp->immediate) {
2531 cmd[1] = 1; /* Don't wait for completion */
2532 timeout = STp->device->request_queue->rq_timeout;
2533 }
2534 else
2535 timeout = STp->long_timeout;
2536
2537 DEBC(
2538 if (!load_code)
2539 printk(ST_DEB_MSG "%s: Unloading tape.\n", name);
2540 else
2541 printk(ST_DEB_MSG "%s: Loading tape.\n", name);
2542 );
2543
2544 SRpnt = st_do_scsi(NULL, STp, cmd, 0, DMA_NONE,
2545 timeout, MAX_RETRIES, 1);
2546 if (!SRpnt)
2547 return (STp->buffer)->syscall_result;
2548
2549 retval = (STp->buffer)->syscall_result;
2550 st_release_request(SRpnt);
2551
2552 if (!retval) { /* SCSI command successful */
2553
2554 if (!load_code) {
2555 STp->rew_at_close = 0;
2556 STp->ready = ST_NO_TAPE;
2557 }
2558 else {
2559 STp->rew_at_close = STp->autorew_dev;
2560 retval = check_tape(STp, filp);
2561 if (retval > 0)
2562 retval = 0;
2563 }
2564 }
2565 else {
2566 STps = &(STp->ps[STp->partition]);
2567 STps->drv_file = STps->drv_block = (-1);
2568 }
2569
2570 return retval;
2571 }
2572 \f
2573 #if DEBUG
2574 #define ST_DEB_FORWARD 0
2575 #define ST_DEB_BACKWARD 1
2576 static void deb_space_print(char *name, int direction, char *units, unsigned char *cmd)
2577 {
2578 s32 sc;
2579
2580 sc = cmd[2] & 0x80 ? 0xff000000 : 0;
2581 sc |= (cmd[2] << 16) | (cmd[3] << 8) | cmd[4];
2582 if (direction)
2583 sc = -sc;
2584 printk(ST_DEB_MSG "%s: Spacing tape %s over %d %s.\n", name,
2585 direction ? "backward" : "forward", sc, units);
2586 }
2587 #endif
2588
2589
2590 /* Internal ioctl function */
2591 static int st_int_ioctl(struct scsi_tape *STp, unsigned int cmd_in, unsigned long arg)
2592 {
2593 int timeout;
2594 long ltmp;
2595 int ioctl_result;
2596 int chg_eof = 1;
2597 unsigned char cmd[MAX_COMMAND_SIZE];
2598 struct st_request *SRpnt;
2599 struct st_partstat *STps;
2600 int fileno, blkno, at_sm, undone;
2601 int datalen = 0, direction = DMA_NONE;
2602 char *name = tape_name(STp);
2603
2604 WARN_ON(STp->buffer->do_dio != 0);
2605 if (STp->ready != ST_READY) {
2606 if (STp->ready == ST_NO_TAPE)
2607 return (-ENOMEDIUM);
2608 else
2609 return (-EIO);
2610 }
2611 timeout = STp->long_timeout;
2612 STps = &(STp->ps[STp->partition]);
2613 fileno = STps->drv_file;
2614 blkno = STps->drv_block;
2615 at_sm = STps->at_sm;
2616
2617 memset(cmd, 0, MAX_COMMAND_SIZE);
2618 switch (cmd_in) {
2619 case MTFSFM:
2620 chg_eof = 0; /* Changed from the FSF after this */
2621 case MTFSF:
2622 cmd[0] = SPACE;
2623 cmd[1] = 0x01; /* Space FileMarks */
2624 cmd[2] = (arg >> 16);
2625 cmd[3] = (arg >> 8);
2626 cmd[4] = arg;
2627 DEBC(deb_space_print(name, ST_DEB_FORWARD, "filemarks", cmd);)
2628 if (fileno >= 0)
2629 fileno += arg;
2630 blkno = 0;
2631 at_sm &= (arg == 0);
2632 break;
2633 case MTBSFM:
2634 chg_eof = 0; /* Changed from the FSF after this */
2635 case MTBSF:
2636 cmd[0] = SPACE;
2637 cmd[1] = 0x01; /* Space FileMarks */
2638 ltmp = (-arg);
2639 cmd[2] = (ltmp >> 16);
2640 cmd[3] = (ltmp >> 8);
2641 cmd[4] = ltmp;
2642 DEBC(deb_space_print(name, ST_DEB_BACKWARD, "filemarks", cmd);)
2643 if (fileno >= 0)
2644 fileno -= arg;
2645 blkno = (-1); /* We can't know the block number */
2646 at_sm &= (arg == 0);
2647 break;
2648 case MTFSR:
2649 cmd[0] = SPACE;
2650 cmd[1] = 0x00; /* Space Blocks */
2651 cmd[2] = (arg >> 16);
2652 cmd[3] = (arg >> 8);
2653 cmd[4] = arg;
2654 DEBC(deb_space_print(name, ST_DEB_FORWARD, "blocks", cmd);)
2655 if (blkno >= 0)
2656 blkno += arg;
2657 at_sm &= (arg == 0);
2658 break;
2659 case MTBSR:
2660 cmd[0] = SPACE;
2661 cmd[1] = 0x00; /* Space Blocks */
2662 ltmp = (-arg);
2663 cmd[2] = (ltmp >> 16);
2664 cmd[3] = (ltmp >> 8);
2665 cmd[4] = ltmp;
2666 DEBC(deb_space_print(name, ST_DEB_BACKWARD, "blocks", cmd);)
2667 if (blkno >= 0)
2668 blkno -= arg;
2669 at_sm &= (arg == 0);
2670 break;
2671 case MTFSS:
2672 cmd[0] = SPACE;
2673 cmd[1] = 0x04; /* Space Setmarks */
2674 cmd[2] = (arg >> 16);
2675 cmd[3] = (arg >> 8);
2676 cmd[4] = arg;
2677 DEBC(deb_space_print(name, ST_DEB_FORWARD, "setmarks", cmd);)
2678 if (arg != 0) {
2679 blkno = fileno = (-1);
2680 at_sm = 1;
2681 }
2682 break;
2683 case MTBSS:
2684 cmd[0] = SPACE;
2685 cmd[1] = 0x04; /* Space Setmarks */
2686 ltmp = (-arg);
2687 cmd[2] = (ltmp >> 16);
2688 cmd[3] = (ltmp >> 8);
2689 cmd[4] = ltmp;
2690 DEBC(deb_space_print(name, ST_DEB_BACKWARD, "setmarks", cmd);)
2691 if (arg != 0) {
2692 blkno = fileno = (-1);
2693 at_sm = 1;
2694 }
2695 break;
2696 case MTWEOF:
2697 case MTWSM:
2698 if (STp->write_prot)
2699 return (-EACCES);
2700 cmd[0] = WRITE_FILEMARKS;
2701 if (cmd_in == MTWSM)
2702 cmd[1] = 2;
2703 cmd[2] = (arg >> 16);
2704 cmd[3] = (arg >> 8);
2705 cmd[4] = arg;
2706 timeout = STp->device->request_queue->rq_timeout;
2707 DEBC(
2708 if (cmd_in == MTWEOF)
2709 printk(ST_DEB_MSG "%s: Writing %d filemarks.\n", name,
2710 cmd[2] * 65536 + cmd[3] * 256 + cmd[4]);
2711 else
2712 printk(ST_DEB_MSG "%s: Writing %d setmarks.\n", name,
2713 cmd[2] * 65536 + cmd[3] * 256 + cmd[4]);
2714 )
2715 if (fileno >= 0)
2716 fileno += arg;
2717 blkno = 0;
2718 at_sm = (cmd_in == MTWSM);
2719 break;
2720 case MTREW:
2721 cmd[0] = REZERO_UNIT;
2722 if (STp->immediate) {
2723 cmd[1] = 1; /* Don't wait for completion */
2724 timeout = STp->device->request_queue->rq_timeout;
2725 }
2726 DEBC(printk(ST_DEB_MSG "%s: Rewinding tape.\n", name));
2727 fileno = blkno = at_sm = 0;
2728 break;
2729 case MTNOP:
2730 DEBC(printk(ST_DEB_MSG "%s: No op on tape.\n", name));
2731 return 0; /* Should do something ? */
2732 break;
2733 case MTRETEN:
2734 cmd[0] = START_STOP;
2735 if (STp->immediate) {
2736 cmd[1] = 1; /* Don't wait for completion */
2737 timeout = STp->device->request_queue->rq_timeout;
2738 }
2739 cmd[4] = 3;
2740 DEBC(printk(ST_DEB_MSG "%s: Retensioning tape.\n", name));
2741 fileno = blkno = at_sm = 0;
2742 break;
2743 case MTEOM:
2744 if (!STp->fast_mteom) {
2745 /* space to the end of tape */
2746 ioctl_result = st_int_ioctl(STp, MTFSF, 0x7fffff);
2747 fileno = STps->drv_file;
2748 if (STps->eof >= ST_EOD_1)
2749 return 0;
2750 /* The next lines would hide the number of spaced FileMarks
2751 That's why I inserted the previous lines. I had no luck
2752 with detecting EOM with FSF, so we go now to EOM.
2753 Joerg Weule */
2754 } else
2755 fileno = (-1);
2756 cmd[0] = SPACE;
2757 cmd[1] = 3;
2758 DEBC(printk(ST_DEB_MSG "%s: Spacing to end of recorded medium.\n",
2759 name));
2760 blkno = -1;
2761 at_sm = 0;
2762 break;
2763 case MTERASE:
2764 if (STp->write_prot)
2765 return (-EACCES);
2766 cmd[0] = ERASE;
2767 cmd[1] = (arg ? 1 : 0); /* Long erase with non-zero argument */
2768 if (STp->immediate) {
2769 cmd[1] |= 2; /* Don't wait for completion */
2770 timeout = STp->device->request_queue->rq_timeout;
2771 }
2772 else
2773 timeout = STp->long_timeout * 8;
2774
2775 DEBC(printk(ST_DEB_MSG "%s: Erasing tape.\n", name));
2776 fileno = blkno = at_sm = 0;
2777 break;
2778 case MTSETBLK: /* Set block length */
2779 case MTSETDENSITY: /* Set tape density */
2780 case MTSETDRVBUFFER: /* Set drive buffering */
2781 case SET_DENS_AND_BLK: /* Set density and block size */
2782 chg_eof = 0;
2783 if (STp->dirty || (STp->buffer)->buffer_bytes != 0)
2784 return (-EIO); /* Not allowed if data in buffer */
2785 if ((cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) &&
2786 (arg & MT_ST_BLKSIZE_MASK) != 0 &&
2787 STp->max_block > 0 &&
2788 ((arg & MT_ST_BLKSIZE_MASK) < STp->min_block ||
2789 (arg & MT_ST_BLKSIZE_MASK) > STp->max_block)) {
2790 printk(KERN_WARNING "%s: Illegal block size.\n", name);
2791 return (-EINVAL);
2792 }
2793 cmd[0] = MODE_SELECT;
2794 if ((STp->use_pf & USE_PF))
2795 cmd[1] = MODE_SELECT_PAGE_FORMAT;
2796 cmd[4] = datalen = 12;
2797 direction = DMA_TO_DEVICE;
2798
2799 memset((STp->buffer)->b_data, 0, 12);
2800 if (cmd_in == MTSETDRVBUFFER)
2801 (STp->buffer)->b_data[2] = (arg & 7) << 4;
2802 else
2803 (STp->buffer)->b_data[2] =
2804 STp->drv_buffer << 4;
2805 (STp->buffer)->b_data[3] = 8; /* block descriptor length */
2806 if (cmd_in == MTSETDENSITY) {
2807 (STp->buffer)->b_data[4] = arg;
2808 STp->density_changed = 1; /* At least we tried ;-) */
2809 } else if (cmd_in == SET_DENS_AND_BLK)
2810 (STp->buffer)->b_data[4] = arg >> 24;
2811 else
2812 (STp->buffer)->b_data[4] = STp->density;
2813 if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) {
2814 ltmp = arg & MT_ST_BLKSIZE_MASK;
2815 if (cmd_in == MTSETBLK)
2816 STp->blksize_changed = 1; /* At least we tried ;-) */
2817 } else
2818 ltmp = STp->block_size;
2819 (STp->buffer)->b_data[9] = (ltmp >> 16);
2820 (STp->buffer)->b_data[10] = (ltmp >> 8);
2821 (STp->buffer)->b_data[11] = ltmp;
2822 timeout = STp->device->request_queue->rq_timeout;
2823 DEBC(
2824 if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK)
2825 printk(ST_DEB_MSG
2826 "%s: Setting block size to %d bytes.\n", name,
2827 (STp->buffer)->b_data[9] * 65536 +
2828 (STp->buffer)->b_data[10] * 256 +
2829 (STp->buffer)->b_data[11]);
2830 if (cmd_in == MTSETDENSITY || cmd_in == SET_DENS_AND_BLK)
2831 printk(ST_DEB_MSG
2832 "%s: Setting density code to %x.\n", name,
2833 (STp->buffer)->b_data[4]);
2834 if (cmd_in == MTSETDRVBUFFER)
2835 printk(ST_DEB_MSG
2836 "%s: Setting drive buffer code to %d.\n", name,
2837 ((STp->buffer)->b_data[2] >> 4) & 7);
2838 )
2839 break;
2840 default:
2841 return (-ENOSYS);
2842 }
2843
2844 SRpnt = st_do_scsi(NULL, STp, cmd, datalen, direction,
2845 timeout, MAX_RETRIES, 1);
2846 if (!SRpnt)
2847 return (STp->buffer)->syscall_result;
2848
2849 ioctl_result = (STp->buffer)->syscall_result;
2850
2851 if (!ioctl_result) { /* SCSI command successful */
2852 st_release_request(SRpnt);
2853 SRpnt = NULL;
2854 STps->drv_block = blkno;
2855 STps->drv_file = fileno;
2856 STps->at_sm = at_sm;
2857
2858 if (cmd_in == MTBSFM)
2859 ioctl_result = st_int_ioctl(STp, MTFSF, 1);
2860 else if (cmd_in == MTFSFM)
2861 ioctl_result = st_int_ioctl(STp, MTBSF, 1);
2862
2863 if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) {
2864 STp->block_size = arg & MT_ST_BLKSIZE_MASK;
2865 if (STp->block_size != 0) {
2866 (STp->buffer)->buffer_blocks =
2867 (STp->buffer)->buffer_size / STp->block_size;
2868 }
2869 (STp->buffer)->buffer_bytes = (STp->buffer)->read_pointer = 0;
2870 if (cmd_in == SET_DENS_AND_BLK)
2871 STp->density = arg >> MT_ST_DENSITY_SHIFT;
2872 } else if (cmd_in == MTSETDRVBUFFER)
2873 STp->drv_buffer = (arg & 7);
2874 else if (cmd_in == MTSETDENSITY)
2875 STp->density = arg;
2876
2877 if (cmd_in == MTEOM)
2878 STps->eof = ST_EOD;
2879 else if (cmd_in == MTFSF)
2880 STps->eof = ST_FM;
2881 else if (chg_eof)
2882 STps->eof = ST_NOEOF;
2883
2884 if (cmd_in == MTWEOF)
2885 STps->rw = ST_IDLE;
2886 } else { /* SCSI command was not completely successful. Don't return
2887 from this block without releasing the SCSI command block! */
2888 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
2889
2890 if (cmdstatp->flags & SENSE_EOM) {
2891 if (cmd_in != MTBSF && cmd_in != MTBSFM &&
2892 cmd_in != MTBSR && cmd_in != MTBSS)
2893 STps->eof = ST_EOM_OK;
2894 STps->drv_block = 0;
2895 }
2896
2897 if (cmdstatp->remainder_valid)
2898 undone = (int)cmdstatp->uremainder64;
2899 else
2900 undone = 0;
2901
2902 if (cmd_in == MTWEOF &&
2903 cmdstatp->have_sense &&
2904 (cmdstatp->flags & SENSE_EOM)) {
2905 if (cmdstatp->sense_hdr.sense_key == NO_SENSE ||
2906 cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR) {
2907 ioctl_result = 0; /* EOF(s) written successfully at EOM */
2908 STps->eof = ST_NOEOF;
2909 } else { /* Writing EOF(s) failed */
2910 if (fileno >= 0)
2911 fileno -= undone;
2912 if (undone < arg)
2913 STps->eof = ST_NOEOF;
2914 }
2915 STps->drv_file = fileno;
2916 } else if ((cmd_in == MTFSF) || (cmd_in == MTFSFM)) {
2917 if (fileno >= 0)
2918 STps->drv_file = fileno - undone;
2919 else
2920 STps->drv_file = fileno;
2921 STps->drv_block = -1;
2922 STps->eof = ST_NOEOF;
2923 } else if ((cmd_in == MTBSF) || (cmd_in == MTBSFM)) {
2924 if (arg > 0 && undone < 0) /* Some drives get this wrong */
2925 undone = (-undone);
2926 if (STps->drv_file >= 0)
2927 STps->drv_file = fileno + undone;
2928 STps->drv_block = 0;
2929 STps->eof = ST_NOEOF;
2930 } else if (cmd_in == MTFSR) {
2931 if (cmdstatp->flags & SENSE_FMK) { /* Hit filemark */
2932 if (STps->drv_file >= 0)
2933 STps->drv_file++;
2934 STps->drv_block = 0;
2935 STps->eof = ST_FM;
2936 } else {
2937 if (blkno >= undone)
2938 STps->drv_block = blkno - undone;
2939 else
2940 STps->drv_block = (-1);
2941 STps->eof = ST_NOEOF;
2942 }
2943 } else if (cmd_in == MTBSR) {
2944 if (cmdstatp->flags & SENSE_FMK) { /* Hit filemark */
2945 STps->drv_file--;
2946 STps->drv_block = (-1);
2947 } else {
2948 if (arg > 0 && undone < 0) /* Some drives get this wrong */
2949 undone = (-undone);
2950 if (STps->drv_block >= 0)
2951 STps->drv_block = blkno + undone;
2952 }
2953 STps->eof = ST_NOEOF;
2954 } else if (cmd_in == MTEOM) {
2955 STps->drv_file = (-1);
2956 STps->drv_block = (-1);
2957 STps->eof = ST_EOD;
2958 } else if (cmd_in == MTSETBLK ||
2959 cmd_in == MTSETDENSITY ||
2960 cmd_in == MTSETDRVBUFFER ||
2961 cmd_in == SET_DENS_AND_BLK) {
2962 if (cmdstatp->sense_hdr.sense_key == ILLEGAL_REQUEST &&
2963 !(STp->use_pf & PF_TESTED)) {
2964 /* Try the other possible state of Page Format if not
2965 already tried */
2966 STp->use_pf = (STp->use_pf ^ USE_PF) | PF_TESTED;
2967 st_release_request(SRpnt);
2968 SRpnt = NULL;
2969 return st_int_ioctl(STp, cmd_in, arg);
2970 }
2971 } else if (chg_eof)
2972 STps->eof = ST_NOEOF;
2973
2974 if (cmdstatp->sense_hdr.sense_key == BLANK_CHECK)
2975 STps->eof = ST_EOD;
2976
2977 st_release_request(SRpnt);
2978 SRpnt = NULL;
2979 }
2980
2981 return ioctl_result;
2982 }
2983 \f
2984
2985 /* Get the tape position. If bt == 2, arg points into a kernel space mt_loc
2986 structure. */
2987
2988 static int get_location(struct scsi_tape *STp, unsigned int *block, int *partition,
2989 int logical)
2990 {
2991 int result;
2992 unsigned char scmd[MAX_COMMAND_SIZE];
2993 struct st_request *SRpnt;
2994 DEB( char *name = tape_name(STp); )
2995
2996 if (STp->ready != ST_READY)
2997 return (-EIO);
2998
2999 memset(scmd, 0, MAX_COMMAND_SIZE);
3000 if ((STp->device)->scsi_level < SCSI_2) {
3001 scmd[0] = QFA_REQUEST_BLOCK;
3002 scmd[4] = 3;
3003 } else {
3004 scmd[0] = READ_POSITION;
3005 if (!logical && !STp->scsi2_logical)
3006 scmd[1] = 1;
3007 }
3008 SRpnt = st_do_scsi(NULL, STp, scmd, 20, DMA_FROM_DEVICE,
3009 STp->device->request_queue->rq_timeout,
3010 MAX_READY_RETRIES, 1);
3011 if (!SRpnt)
3012 return (STp->buffer)->syscall_result;
3013
3014 if ((STp->buffer)->syscall_result != 0 ||
3015 (STp->device->scsi_level >= SCSI_2 &&
3016 ((STp->buffer)->b_data[0] & 4) != 0)) {
3017 *block = *partition = 0;
3018 DEBC(printk(ST_DEB_MSG "%s: Can't read tape position.\n", name));
3019 result = (-EIO);
3020 } else {
3021 result = 0;
3022 if ((STp->device)->scsi_level < SCSI_2) {
3023 *block = ((STp->buffer)->b_data[0] << 16)
3024 + ((STp->buffer)->b_data[1] << 8)
3025 + (STp->buffer)->b_data[2];
3026 *partition = 0;
3027 } else {
3028 *block = ((STp->buffer)->b_data[4] << 24)
3029 + ((STp->buffer)->b_data[5] << 16)
3030 + ((STp->buffer)->b_data[6] << 8)
3031 + (STp->buffer)->b_data[7];
3032 *partition = (STp->buffer)->b_data[1];
3033 if (((STp->buffer)->b_data[0] & 0x80) &&
3034 (STp->buffer)->b_data[1] == 0) /* BOP of partition 0 */
3035 STp->ps[0].drv_block = STp->ps[0].drv_file = 0;
3036 }
3037 DEBC(printk(ST_DEB_MSG "%s: Got tape pos. blk %d part %d.\n", name,
3038 *block, *partition));
3039 }
3040 st_release_request(SRpnt);
3041 SRpnt = NULL;
3042
3043 return result;
3044 }
3045
3046
3047 /* Set the tape block and partition. Negative partition means that only the
3048 block should be set in vendor specific way. */
3049 static int set_location(struct scsi_tape *STp, unsigned int block, int partition,
3050 int logical)
3051 {
3052 struct st_partstat *STps;
3053 int result, p;
3054 unsigned int blk;
3055 int timeout;
3056 unsigned char scmd[MAX_COMMAND_SIZE];
3057 struct st_request *SRpnt;
3058 DEB( char *name = tape_name(STp); )
3059
3060 if (STp->ready != ST_READY)
3061 return (-EIO);
3062 timeout = STp->long_timeout;
3063 STps = &(STp->ps[STp->partition]);
3064
3065 DEBC(printk(ST_DEB_MSG "%s: Setting block to %d and partition to %d.\n",
3066 name, block, partition));
3067 DEB(if (partition < 0)
3068 return (-EIO); )
3069
3070 /* Update the location at the partition we are leaving */
3071 if ((!STp->can_partitions && partition != 0) ||
3072 partition >= ST_NBR_PARTITIONS)
3073 return (-EINVAL);
3074 if (partition != STp->partition) {
3075 if (get_location(STp, &blk, &p, 1))
3076 STps->last_block_valid = 0;
3077 else {
3078 STps->last_block_valid = 1;
3079 STps->last_block_visited = blk;
3080 DEBC(printk(ST_DEB_MSG
3081 "%s: Visited block %d for partition %d saved.\n",
3082 name, blk, STp->partition));
3083 }
3084 }
3085
3086 memset(scmd, 0, MAX_COMMAND_SIZE);
3087 if ((STp->device)->scsi_level < SCSI_2) {
3088 scmd[0] = QFA_SEEK_BLOCK;
3089 scmd[2] = (block >> 16);
3090 scmd[3] = (block >> 8);
3091 scmd[4] = block;
3092 scmd[5] = 0;
3093 } else {
3094 scmd[0] = SEEK_10;
3095 scmd[3] = (block >> 24);
3096 scmd[4] = (block >> 16);
3097 scmd[5] = (block >> 8);
3098 scmd[6] = block;
3099 if (!logical && !STp->scsi2_logical)
3100 scmd[1] = 4;
3101 if (STp->partition != partition) {
3102 scmd[1] |= 2;
3103 scmd[8] = partition;
3104 DEBC(printk(ST_DEB_MSG
3105 "%s: Trying to change partition from %d to %d\n",
3106 name, STp->partition, partition));
3107 }
3108 }
3109 if (STp->immediate) {
3110 scmd[1] |= 1; /* Don't wait for completion */
3111 timeout = STp->device->request_queue->rq_timeout;
3112 }
3113
3114 SRpnt = st_do_scsi(NULL, STp, scmd, 0, DMA_NONE,
3115 timeout, MAX_READY_RETRIES, 1);
3116 if (!SRpnt)
3117 return (STp->buffer)->syscall_result;
3118
3119 STps->drv_block = STps->drv_file = (-1);
3120 STps->eof = ST_NOEOF;
3121 if ((STp->buffer)->syscall_result != 0) {
3122 result = (-EIO);
3123 if (STp->can_partitions &&
3124 (STp->device)->scsi_level >= SCSI_2 &&
3125 (p = find_partition(STp)) >= 0)
3126 STp->partition = p;
3127 } else {
3128 if (STp->can_partitions) {
3129 STp->partition = partition;
3130 STps = &(STp->ps[partition]);
3131 if (!STps->last_block_valid ||
3132 STps->last_block_visited != block) {
3133 STps->at_sm = 0;
3134 STps->rw = ST_IDLE;
3135 }
3136 } else
3137 STps->at_sm = 0;
3138 if (block == 0)
3139 STps->drv_block = STps->drv_file = 0;
3140 result = 0;
3141 }
3142
3143 st_release_request(SRpnt);
3144 SRpnt = NULL;
3145
3146 return result;
3147 }
3148
3149
3150 /* Find the current partition number for the drive status. Called from open and
3151 returns either partition number of negative error code. */
3152 static int find_partition(struct scsi_tape *STp)
3153 {
3154 int i, partition;
3155 unsigned int block;
3156
3157 if ((i = get_location(STp, &block, &partition, 1)) < 0)
3158 return i;
3159 if (partition >= ST_NBR_PARTITIONS)
3160 return (-EIO);
3161 return partition;
3162 }
3163
3164
3165 /* Change the partition if necessary */
3166 static int switch_partition(struct scsi_tape *STp)
3167 {
3168 struct st_partstat *STps;
3169
3170 if (STp->partition == STp->new_partition)
3171 return 0;
3172 STps = &(STp->ps[STp->new_partition]);
3173 if (!STps->last_block_valid)
3174 STps->last_block_visited = 0;
3175 return set_location(STp, STps->last_block_visited, STp->new_partition, 1);
3176 }
3177 \f
3178 /* Functions for reading and writing the medium partition mode page. */
3179
3180 #define PART_PAGE 0x11
3181 #define PART_PAGE_FIXED_LENGTH 8
3182
3183 #define PP_OFF_MAX_ADD_PARTS 2
3184 #define PP_OFF_NBR_ADD_PARTS 3
3185 #define PP_OFF_FLAGS 4
3186 #define PP_OFF_PART_UNITS 6
3187 #define PP_OFF_RESERVED 7
3188
3189 #define PP_BIT_IDP 0x20
3190 #define PP_MSK_PSUM_MB 0x10
3191
3192 /* Get the number of partitions on the tape. As a side effect reads the
3193 mode page into the tape buffer. */
3194 static int nbr_partitions(struct scsi_tape *STp)
3195 {
3196 int result;
3197 DEB( char *name = tape_name(STp); )
3198
3199 if (STp->ready != ST_READY)
3200 return (-EIO);
3201
3202 result = read_mode_page(STp, PART_PAGE, 1);
3203
3204 if (result) {
3205 DEBC(printk(ST_DEB_MSG "%s: Can't read medium partition page.\n",
3206 name));
3207 result = (-EIO);
3208 } else {
3209 result = (STp->buffer)->b_data[MODE_HEADER_LENGTH +
3210 PP_OFF_NBR_ADD_PARTS] + 1;
3211 DEBC(printk(ST_DEB_MSG "%s: Number of partitions %d.\n", name, result));
3212 }
3213
3214 return result;
3215 }
3216
3217
3218 /* Partition the tape into two partitions if size > 0 or one partition if
3219 size == 0.
3220
3221 The block descriptors are read and written because Sony SDT-7000 does not
3222 work without this (suggestion from Michael Schaefer <Michael.Schaefer@dlr.de>).
3223
3224 My HP C1533A drive returns only one partition size field. This is used to
3225 set the size of partition 1. There is no size field for the default partition.
3226 Michael Schaefer's Sony SDT-7000 returns two descriptors and the second is
3227 used to set the size of partition 1 (this is what the SCSI-3 standard specifies).
3228 The following algorithm is used to accommodate both drives: if the number of
3229 partition size fields is greater than the maximum number of additional partitions
3230 in the mode page, the second field is used. Otherwise the first field is used.
3231
3232 For Seagate DDS drives the page length must be 8 when no partitions is defined
3233 and 10 when 1 partition is defined (information from Eric Lee Green). This is
3234 is acceptable also to some other old drives and enforced if the first partition
3235 size field is used for the first additional partition size.
3236 */
3237 static int partition_tape(struct scsi_tape *STp, int size)
3238 {
3239 char *name = tape_name(STp);
3240 int result;
3241 int pgo, psd_cnt, psdo;
3242 unsigned char *bp;
3243
3244 result = read_mode_page(STp, PART_PAGE, 0);
3245 if (result) {
3246 DEBC(printk(ST_DEB_MSG "%s: Can't read partition mode page.\n", name));
3247 return result;
3248 }
3249 /* The mode page is in the buffer. Let's modify it and write it. */
3250 bp = (STp->buffer)->b_data;
3251 pgo = MODE_HEADER_LENGTH + bp[MH_OFF_BDESCS_LENGTH];
3252 DEBC(printk(ST_DEB_MSG "%s: Partition page length is %d bytes.\n",
3253 name, bp[pgo + MP_OFF_PAGE_LENGTH] + 2));
3254
3255 psd_cnt = (bp[pgo + MP_OFF_PAGE_LENGTH] + 2 - PART_PAGE_FIXED_LENGTH) / 2;
3256 psdo = pgo + PART_PAGE_FIXED_LENGTH;
3257 if (psd_cnt > bp[pgo + PP_OFF_MAX_ADD_PARTS]) {
3258 bp[psdo] = bp[psdo + 1] = 0xff; /* Rest of the tape */
3259 psdo += 2;
3260 }
3261 memset(bp + psdo, 0, bp[pgo + PP_OFF_NBR_ADD_PARTS] * 2);
3262
3263 DEBC(printk("%s: psd_cnt %d, max.parts %d, nbr_parts %d\n", name,
3264 psd_cnt, bp[pgo + PP_OFF_MAX_ADD_PARTS],
3265 bp[pgo + PP_OFF_NBR_ADD_PARTS]));
3266
3267 if (size <= 0) {
3268 bp[pgo + PP_OFF_NBR_ADD_PARTS] = 0;
3269 if (psd_cnt <= bp[pgo + PP_OFF_MAX_ADD_PARTS])
3270 bp[pgo + MP_OFF_PAGE_LENGTH] = 6;
3271 DEBC(printk(ST_DEB_MSG "%s: Formatting tape with one partition.\n",
3272 name));
3273 } else {
3274 bp[psdo] = (size >> 8) & 0xff;
3275 bp[psdo + 1] = size & 0xff;
3276 bp[pgo + 3] = 1;
3277 if (bp[pgo + MP_OFF_PAGE_LENGTH] < 8)
3278 bp[pgo + MP_OFF_PAGE_LENGTH] = 8;
3279 DEBC(printk(ST_DEB_MSG
3280 "%s: Formatting tape with two partitions (1 = %d MB).\n",
3281 name, size));
3282 }
3283 bp[pgo + PP_OFF_PART_UNITS] = 0;
3284 bp[pgo + PP_OFF_RESERVED] = 0;
3285 bp[pgo + PP_OFF_FLAGS] = PP_BIT_IDP | PP_MSK_PSUM_MB;
3286
3287 result = write_mode_page(STp, PART_PAGE, 1);
3288 if (result) {
3289 printk(KERN_INFO "%s: Partitioning of tape failed.\n", name);
3290 result = (-EIO);
3291 }
3292
3293 return result;
3294 }
3295 \f
3296
3297
3298 /* The ioctl command */
3299 static long st_ioctl(struct file *file, unsigned int cmd_in, unsigned long arg)
3300 {
3301 int i, cmd_nr, cmd_type, bt;
3302 int retval = 0;
3303 unsigned int blk;
3304 struct scsi_tape *STp = file->private_data;
3305 struct st_modedef *STm;
3306 struct st_partstat *STps;
3307 char *name = tape_name(STp);
3308 void __user *p = (void __user *)arg;
3309
3310 if (mutex_lock_interruptible(&STp->lock))
3311 return -ERESTARTSYS;
3312
3313 DEB(
3314 if (debugging && !STp->in_use) {
3315 printk(ST_DEB_MSG "%s: Incorrect device.\n", name);
3316 retval = (-EIO);
3317 goto out;
3318 } ) /* end DEB */
3319
3320 STm = &(STp->modes[STp->current_mode]);
3321 STps = &(STp->ps[STp->partition]);
3322
3323 /*
3324 * If we are in the middle of error recovery, don't let anyone
3325 * else try and use this device. Also, if error recovery fails, it
3326 * may try and take the device offline, in which case all further
3327 * access to the device is prohibited.
3328 */
3329 retval = scsi_nonblockable_ioctl(STp->device, cmd_in, p,
3330 file->f_flags & O_NDELAY);
3331 if (!scsi_block_when_processing_errors(STp->device) || retval != -ENODEV)
3332 goto out;
3333 retval = 0;
3334
3335 cmd_type = _IOC_TYPE(cmd_in);
3336 cmd_nr = _IOC_NR(cmd_in);
3337
3338 if (cmd_type == _IOC_TYPE(MTIOCTOP) && cmd_nr == _IOC_NR(MTIOCTOP)) {
3339 struct mtop mtc;
3340
3341 if (_IOC_SIZE(cmd_in) != sizeof(mtc)) {
3342 retval = (-EINVAL);
3343 goto out;
3344 }
3345
3346 i = copy_from_user(&mtc, p, sizeof(struct mtop));
3347 if (i) {
3348 retval = (-EFAULT);
3349 goto out;
3350 }
3351
3352 if (mtc.mt_op == MTSETDRVBUFFER && !capable(CAP_SYS_ADMIN)) {
3353 printk(KERN_WARNING
3354 "%s: MTSETDRVBUFFER only allowed for root.\n", name);
3355 retval = (-EPERM);
3356 goto out;
3357 }
3358 if (!STm->defined &&
3359 (mtc.mt_op != MTSETDRVBUFFER &&
3360 (mtc.mt_count & MT_ST_OPTIONS) == 0)) {
3361 retval = (-ENXIO);
3362 goto out;
3363 }
3364
3365 if (!STp->pos_unknown) {
3366
3367 if (STps->eof == ST_FM_HIT) {
3368 if (mtc.mt_op == MTFSF || mtc.mt_op == MTFSFM ||
3369 mtc.mt_op == MTEOM) {
3370 mtc.mt_count -= 1;
3371 if (STps->drv_file >= 0)
3372 STps->drv_file += 1;
3373 } else if (mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM) {
3374 mtc.mt_count += 1;
3375 if (STps->drv_file >= 0)
3376 STps->drv_file += 1;
3377 }
3378 }
3379
3380 if (mtc.mt_op == MTSEEK) {
3381 /* Old position must be restored if partition will be
3382 changed */
3383 i = !STp->can_partitions ||
3384 (STp->new_partition != STp->partition);
3385 } else {
3386 i = mtc.mt_op == MTREW || mtc.mt_op == MTOFFL ||
3387 mtc.mt_op == MTRETEN || mtc.mt_op == MTEOM ||
3388 mtc.mt_op == MTLOCK || mtc.mt_op == MTLOAD ||
3389 mtc.mt_op == MTFSF || mtc.mt_op == MTFSFM ||
3390 mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM ||
3391 mtc.mt_op == MTCOMPRESSION;
3392 }
3393 i = flush_buffer(STp, i);
3394 if (i < 0) {
3395 retval = i;
3396 goto out;
3397 }
3398 if (STps->rw == ST_WRITING &&
3399 (mtc.mt_op == MTREW || mtc.mt_op == MTOFFL ||
3400 mtc.mt_op == MTSEEK ||
3401 mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM)) {
3402 i = st_int_ioctl(STp, MTWEOF, 1);
3403 if (i < 0) {
3404 retval = i;
3405 goto out;
3406 }
3407 if (mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM)
3408 mtc.mt_count++;
3409 STps->rw = ST_IDLE;
3410 }
3411
3412 } else {
3413 /*
3414 * If there was a bus reset, block further access
3415 * to this device. If the user wants to rewind the tape,
3416 * then reset the flag and allow access again.
3417 */
3418 if (mtc.mt_op != MTREW &&
3419 mtc.mt_op != MTOFFL &&
3420 mtc.mt_op != MTRETEN &&
3421 mtc.mt_op != MTERASE &&
3422 mtc.mt_op != MTSEEK &&
3423 mtc.mt_op != MTEOM) {
3424 retval = (-EIO);
3425 goto out;
3426 }
3427 reset_state(STp);
3428 /* remove this when the midlevel properly clears was_reset */
3429 STp->device->was_reset = 0;
3430 }
3431
3432 if (mtc.mt_op != MTNOP && mtc.mt_op != MTSETBLK &&
3433 mtc.mt_op != MTSETDENSITY && mtc.mt_op != MTWSM &&
3434 mtc.mt_op != MTSETDRVBUFFER && mtc.mt_op != MTSETPART)
3435 STps->rw = ST_IDLE; /* Prevent automatic WEOF and fsf */
3436
3437 if (mtc.mt_op == MTOFFL && STp->door_locked != ST_UNLOCKED)
3438 do_door_lock(STp, 0); /* Ignore result! */
3439
3440 if (mtc.mt_op == MTSETDRVBUFFER &&
3441 (mtc.mt_count & MT_ST_OPTIONS) != 0) {
3442 retval = st_set_options(STp, mtc.mt_count);
3443 goto out;
3444 }
3445
3446 if (mtc.mt_op == MTSETPART) {
3447 if (!STp->can_partitions ||
3448 mtc.mt_count < 0 || mtc.mt_count >= ST_NBR_PARTITIONS) {
3449 retval = (-EINVAL);
3450 goto out;
3451 }
3452 if (mtc.mt_count >= STp->nbr_partitions &&
3453 (STp->nbr_partitions = nbr_partitions(STp)) < 0) {
3454 retval = (-EIO);
3455 goto out;
3456 }
3457 if (mtc.mt_count >= STp->nbr_partitions) {
3458 retval = (-EINVAL);
3459 goto out;
3460 }
3461 STp->new_partition = mtc.mt_count;
3462 retval = 0;
3463 goto out;
3464 }
3465
3466 if (mtc.mt_op == MTMKPART) {
3467 if (!STp->can_partitions) {
3468 retval = (-EINVAL);
3469 goto out;
3470 }
3471 if ((i = st_int_ioctl(STp, MTREW, 0)) < 0 ||
3472 (i = partition_tape(STp, mtc.mt_count)) < 0) {
3473 retval = i;
3474 goto out;
3475 }
3476 for (i = 0; i < ST_NBR_PARTITIONS; i++) {
3477 STp->ps[i].rw = ST_IDLE;
3478 STp->ps[i].at_sm = 0;
3479 STp->ps[i].last_block_valid = 0;
3480 }
3481 STp->partition = STp->new_partition = 0;
3482 STp->nbr_partitions = 1; /* Bad guess ?-) */
3483 STps->drv_block = STps->drv_file = 0;
3484 retval = 0;
3485 goto out;
3486 }
3487
3488 if (mtc.mt_op == MTSEEK) {
3489 i = set_location(STp, mtc.mt_count, STp->new_partition, 0);
3490 if (!STp->can_partitions)
3491 STp->ps[0].rw = ST_IDLE;
3492 retval = i;
3493 goto out;
3494 }
3495
3496 if (mtc.mt_op == MTUNLOAD || mtc.mt_op == MTOFFL) {
3497 retval = do_load_unload(STp, file, 0);
3498 goto out;
3499 }
3500
3501 if (mtc.mt_op == MTLOAD) {
3502 retval = do_load_unload(STp, file, max(1, mtc.mt_count));
3503 goto out;
3504 }
3505
3506 if (mtc.mt_op == MTLOCK || mtc.mt_op == MTUNLOCK) {
3507 retval = do_door_lock(STp, (mtc.mt_op == MTLOCK));
3508 goto out;
3509 }
3510
3511 if (STp->can_partitions && STp->ready == ST_READY &&
3512 (i = switch_partition(STp)) < 0) {
3513 retval = i;
3514 goto out;
3515 }
3516
3517 if (mtc.mt_op == MTCOMPRESSION)
3518 retval = st_compression(STp, (mtc.mt_count & 1));
3519 else
3520 retval = st_int_ioctl(STp, mtc.mt_op, mtc.mt_count);
3521 goto out;
3522 }
3523 if (!STm->defined) {
3524 retval = (-ENXIO);
3525 goto out;
3526 }
3527
3528 if ((i = flush_buffer(STp, 0)) < 0) {
3529 retval = i;
3530 goto out;
3531 }
3532 if (STp->can_partitions &&
3533 (i = switch_partition(STp)) < 0) {
3534 retval = i;
3535 goto out;
3536 }
3537
3538 if (cmd_type == _IOC_TYPE(MTIOCGET) && cmd_nr == _IOC_NR(MTIOCGET)) {
3539 struct mtget mt_status;
3540
3541 if (_IOC_SIZE(cmd_in) != sizeof(struct mtget)) {
3542 retval = (-EINVAL);
3543 goto out;
3544 }
3545
3546 mt_status.mt_type = STp->tape_type;
3547 mt_status.mt_dsreg =
3548 ((STp->block_size << MT_ST_BLKSIZE_SHIFT) & MT_ST_BLKSIZE_MASK) |
3549 ((STp->density << MT_ST_DENSITY_SHIFT) & MT_ST_DENSITY_MASK);
3550 mt_status.mt_blkno = STps->drv_block;
3551 mt_status.mt_fileno = STps->drv_file;
3552 if (STp->block_size != 0) {
3553 if (STps->rw == ST_WRITING)
3554 mt_status.mt_blkno +=
3555 (STp->buffer)->buffer_bytes / STp->block_size;
3556 else if (STps->rw == ST_READING)
3557 mt_status.mt_blkno -=
3558 ((STp->buffer)->buffer_bytes +
3559 STp->block_size - 1) / STp->block_size;
3560 }
3561
3562 mt_status.mt_gstat = 0;
3563 if (STp->drv_write_prot)
3564 mt_status.mt_gstat |= GMT_WR_PROT(0xffffffff);
3565 if (mt_status.mt_blkno == 0) {
3566 if (mt_status.mt_fileno == 0)
3567 mt_status.mt_gstat |= GMT_BOT(0xffffffff);
3568 else
3569 mt_status.mt_gstat |= GMT_EOF(0xffffffff);
3570 }
3571 mt_status.mt_erreg = (STp->recover_reg << MT_ST_SOFTERR_SHIFT);
3572 mt_status.mt_resid = STp->partition;
3573 if (STps->eof == ST_EOM_OK || STps->eof == ST_EOM_ERROR)
3574 mt_status.mt_gstat |= GMT_EOT(0xffffffff);
3575 else if (STps->eof >= ST_EOM_OK)
3576 mt_status.mt_gstat |= GMT_EOD(0xffffffff);
3577 if (STp->density == 1)
3578 mt_status.mt_gstat |= GMT_D_800(0xffffffff);
3579 else if (STp->density == 2)
3580 mt_status.mt_gstat |= GMT_D_1600(0xffffffff);
3581 else if (STp->density == 3)
3582 mt_status.mt_gstat |= GMT_D_6250(0xffffffff);
3583 if (STp->ready == ST_READY)
3584 mt_status.mt_gstat |= GMT_ONLINE(0xffffffff);
3585 if (STp->ready == ST_NO_TAPE)
3586 mt_status.mt_gstat |= GMT_DR_OPEN(0xffffffff);
3587 if (STps->at_sm)
3588 mt_status.mt_gstat |= GMT_SM(0xffffffff);
3589 if (STm->do_async_writes ||
3590 (STm->do_buffer_writes && STp->block_size != 0) ||
3591 STp->drv_buffer != 0)
3592 mt_status.mt_gstat |= GMT_IM_REP_EN(0xffffffff);
3593 if (STp->cleaning_req)
3594 mt_status.mt_gstat |= GMT_CLN(0xffffffff);
3595
3596 i = copy_to_user(p, &mt_status, sizeof(struct mtget));
3597 if (i) {
3598 retval = (-EFAULT);
3599 goto out;
3600 }
3601
3602 STp->recover_reg = 0; /* Clear after read */
3603 retval = 0;
3604 goto out;
3605 } /* End of MTIOCGET */
3606 if (cmd_type == _IOC_TYPE(MTIOCPOS) && cmd_nr == _IOC_NR(MTIOCPOS)) {
3607 struct mtpos mt_pos;
3608 if (_IOC_SIZE(cmd_in) != sizeof(struct mtpos)) {
3609 retval = (-EINVAL);
3610 goto out;
3611 }
3612 if ((i = get_location(STp, &blk, &bt, 0)) < 0) {
3613 retval = i;
3614 goto out;
3615 }
3616 mt_pos.mt_blkno = blk;
3617 i = copy_to_user(p, &mt_pos, sizeof(struct mtpos));
3618 if (i)
3619 retval = (-EFAULT);
3620 goto out;
3621 }
3622 mutex_unlock(&STp->lock);
3623 switch (cmd_in) {
3624 case SCSI_IOCTL_GET_IDLUN:
3625 case SCSI_IOCTL_GET_BUS_NUMBER:
3626 break;
3627 default:
3628 if ((cmd_in == SG_IO ||
3629 cmd_in == SCSI_IOCTL_SEND_COMMAND ||
3630 cmd_in == CDROM_SEND_PACKET) &&
3631 !capable(CAP_SYS_RAWIO))
3632 i = -EPERM;
3633 else
3634 i = scsi_cmd_ioctl(STp->disk->queue, STp->disk,
3635 file->f_mode, cmd_in, p);
3636 if (i != -ENOTTY)
3637 return i;
3638 break;
3639 }
3640 retval = scsi_ioctl(STp->device, cmd_in, p);
3641 if (!retval && cmd_in == SCSI_IOCTL_STOP_UNIT) { /* unload */
3642 STp->rew_at_close = 0;
3643 STp->ready = ST_NO_TAPE;
3644 }
3645 return retval;
3646
3647 out:
3648 mutex_unlock(&STp->lock);
3649 return retval;
3650 }
3651
3652 #ifdef CONFIG_COMPAT
3653 static long st_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
3654 {
3655 struct scsi_tape *STp = file->private_data;
3656 struct scsi_device *sdev = STp->device;
3657 int ret = -ENOIOCTLCMD;
3658 if (sdev->host->hostt->compat_ioctl) {
3659
3660 ret = sdev->host->hostt->compat_ioctl(sdev, cmd, (void __user *)arg);
3661
3662 }
3663 return ret;
3664 }
3665 #endif
3666
3667 \f
3668
3669 /* Try to allocate a new tape buffer. Calling function must not hold
3670 dev_arr_lock. */
3671 static struct st_buffer *new_tape_buffer(int need_dma, int max_sg)
3672 {
3673 struct st_buffer *tb;
3674
3675 tb = kzalloc(sizeof(struct st_buffer), GFP_ATOMIC);
3676 if (!tb) {
3677 printk(KERN_NOTICE "st: Can't allocate new tape buffer.\n");
3678 return NULL;
3679 }
3680 tb->frp_segs = 0;
3681 tb->use_sg = max_sg;
3682 tb->dma = need_dma;
3683 tb->buffer_size = 0;
3684
3685 tb->reserved_pages = kzalloc(max_sg * sizeof(struct page *),
3686 GFP_ATOMIC);
3687 if (!tb->reserved_pages) {
3688 kfree(tb);
3689 return NULL;
3690 }
3691
3692 return tb;
3693 }
3694
3695
3696 /* Try to allocate enough space in the tape buffer */
3697 #define ST_MAX_ORDER 6
3698
3699 static int enlarge_buffer(struct st_buffer * STbuffer, int new_size, int need_dma)
3700 {
3701 int segs, nbr, max_segs, b_size, order, got;
3702 gfp_t priority;
3703
3704 if (new_size <= STbuffer->buffer_size)
3705 return 1;
3706
3707 if (STbuffer->buffer_size <= PAGE_SIZE)
3708 normalize_buffer(STbuffer); /* Avoid extra segment */
3709
3710 max_segs = STbuffer->use_sg;
3711 nbr = max_segs - STbuffer->frp_segs;
3712 if (nbr <= 0)
3713 return 0;
3714
3715 priority = GFP_KERNEL | __GFP_NOWARN;
3716 if (need_dma)
3717 priority |= GFP_DMA;
3718
3719 if (STbuffer->cleared)
3720 priority |= __GFP_ZERO;
3721
3722 if (STbuffer->frp_segs) {
3723 order = STbuffer->reserved_page_order;
3724 b_size = PAGE_SIZE << order;
3725 } else {
3726 for (b_size = PAGE_SIZE, order = 0;
3727 order < ST_MAX_ORDER && b_size < new_size;
3728 order++, b_size *= 2)
3729 ; /* empty */
3730 }
3731 if (max_segs * (PAGE_SIZE << order) < new_size) {
3732 if (order == ST_MAX_ORDER)
3733 return 0;
3734 normalize_buffer(STbuffer);
3735 return enlarge_buffer(STbuffer, new_size, need_dma);
3736 }
3737
3738 for (segs = STbuffer->frp_segs, got = STbuffer->buffer_size;
3739 segs < max_segs && got < new_size;) {
3740 struct page *page;
3741
3742 page = alloc_pages(priority, order);
3743 if (!page) {
3744 DEB(STbuffer->buffer_size = got);
3745 normalize_buffer(STbuffer);
3746 return 0;
3747 }
3748
3749 STbuffer->frp_segs += 1;
3750 got += b_size;
3751 STbuffer->buffer_size = got;
3752 STbuffer->reserved_pages[segs] = page;
3753 segs++;
3754 }
3755 STbuffer->b_data = page_address(STbuffer->reserved_pages[0]);
3756 STbuffer->reserved_page_order = order;
3757
3758 return 1;
3759 }
3760
3761
3762 /* Make sure that no data from previous user is in the internal buffer */
3763 static void clear_buffer(struct st_buffer * st_bp)
3764 {
3765 int i;
3766
3767 for (i=0; i < st_bp->frp_segs; i++)
3768 memset(page_address(st_bp->reserved_pages[i]), 0,
3769 PAGE_SIZE << st_bp->reserved_page_order);
3770 st_bp->cleared = 1;
3771 }
3772
3773
3774 /* Release the extra buffer */
3775 static void normalize_buffer(struct st_buffer * STbuffer)
3776 {
3777 int i, order = STbuffer->reserved_page_order;
3778
3779 for (i = 0; i < STbuffer->frp_segs; i++) {
3780 __free_pages(STbuffer->reserved_pages[i], order);
3781 STbuffer->buffer_size -= (PAGE_SIZE << order);
3782 }
3783 STbuffer->frp_segs = 0;
3784 STbuffer->sg_segs = 0;
3785 STbuffer->reserved_page_order = 0;
3786 STbuffer->map_data.offset = 0;
3787 }
3788
3789
3790 /* Move data from the user buffer to the tape buffer. Returns zero (success) or
3791 negative error code. */
3792 static int append_to_buffer(const char __user *ubp, struct st_buffer * st_bp, int do_count)
3793 {
3794 int i, cnt, res, offset;
3795 int length = PAGE_SIZE << st_bp->reserved_page_order;
3796
3797 for (i = 0, offset = st_bp->buffer_bytes;
3798 i < st_bp->frp_segs && offset >= length; i++)
3799 offset -= length;
3800 if (i == st_bp->frp_segs) { /* Should never happen */
3801 printk(KERN_WARNING "st: append_to_buffer offset overflow.\n");
3802 return (-EIO);
3803 }
3804 for (; i < st_bp->frp_segs && do_count > 0; i++) {
3805 struct page *page = st_bp->reserved_pages[i];
3806 cnt = length - offset < do_count ? length - offset : do_count;
3807 res = copy_from_user(page_address(page) + offset, ubp, cnt);
3808 if (res)
3809 return (-EFAULT);
3810 do_count -= cnt;
3811 st_bp->buffer_bytes += cnt;
3812 ubp += cnt;
3813 offset = 0;
3814 }
3815 if (do_count) /* Should never happen */
3816 return (-EIO);
3817
3818 return 0;
3819 }
3820
3821
3822 /* Move data from the tape buffer to the user buffer. Returns zero (success) or
3823 negative error code. */
3824 static int from_buffer(struct st_buffer * st_bp, char __user *ubp, int do_count)
3825 {
3826 int i, cnt, res, offset;
3827 int length = PAGE_SIZE << st_bp->reserved_page_order;
3828
3829 for (i = 0, offset = st_bp->read_pointer;
3830 i < st_bp->frp_segs && offset >= length; i++)
3831 offset -= length;
3832 if (i == st_bp->frp_segs) { /* Should never happen */
3833 printk(KERN_WARNING "st: from_buffer offset overflow.\n");
3834 return (-EIO);
3835 }
3836 for (; i < st_bp->frp_segs && do_count > 0; i++) {
3837 struct page *page = st_bp->reserved_pages[i];
3838 cnt = length - offset < do_count ? length - offset : do_count;
3839 res = copy_to_user(ubp, page_address(page) + offset, cnt);
3840 if (res)
3841 return (-EFAULT);
3842 do_count -= cnt;
3843 st_bp->buffer_bytes -= cnt;
3844 st_bp->read_pointer += cnt;
3845 ubp += cnt;
3846 offset = 0;
3847 }
3848 if (do_count) /* Should never happen */
3849 return (-EIO);
3850
3851 return 0;
3852 }
3853
3854
3855 /* Move data towards start of buffer */
3856 static void move_buffer_data(struct st_buffer * st_bp, int offset)
3857 {
3858 int src_seg, dst_seg, src_offset = 0, dst_offset;
3859 int count, total;
3860 int length = PAGE_SIZE << st_bp->reserved_page_order;
3861
3862 if (offset == 0)
3863 return;
3864
3865 total=st_bp->buffer_bytes - offset;
3866 for (src_seg=0; src_seg < st_bp->frp_segs; src_seg++) {
3867 src_offset = offset;
3868 if (src_offset < length)
3869 break;
3870 offset -= length;
3871 }
3872
3873 st_bp->buffer_bytes = st_bp->read_pointer = total;
3874 for (dst_seg=dst_offset=0; total > 0; ) {
3875 struct page *dpage = st_bp->reserved_pages[dst_seg];
3876 struct page *spage = st_bp->reserved_pages[src_seg];
3877
3878 count = min(length - dst_offset, length - src_offset);
3879 memmove(page_address(dpage) + dst_offset,
3880 page_address(spage) + src_offset, count);
3881 src_offset += count;
3882 if (src_offset >= length) {
3883 src_seg++;
3884 src_offset = 0;
3885 }
3886 dst_offset += count;
3887 if (dst_offset >= length) {
3888 dst_seg++;
3889 dst_offset = 0;
3890 }
3891 total -= count;
3892 }
3893 }
3894
3895 /* Validate the options from command line or module parameters */
3896 static void validate_options(void)
3897 {
3898 if (buffer_kbs > 0)
3899 st_fixed_buffer_size = buffer_kbs * ST_KILOBYTE;
3900 if (max_sg_segs >= ST_FIRST_SG)
3901 st_max_sg_segs = max_sg_segs;
3902 }
3903
3904 #ifndef MODULE
3905 /* Set the boot options. Syntax is defined in Documenation/scsi/st.txt.
3906 */
3907 static int __init st_setup(char *str)
3908 {
3909 int i, len, ints[5];
3910 char *stp;
3911
3912 stp = get_options(str, ARRAY_SIZE(ints), ints);
3913
3914 if (ints[0] > 0) {
3915 for (i = 0; i < ints[0] && i < ARRAY_SIZE(parms); i++)
3916 if (parms[i].val)
3917 *parms[i].val = ints[i + 1];
3918 } else {
3919 while (stp != NULL) {
3920 for (i = 0; i < ARRAY_SIZE(parms); i++) {
3921 len = strlen(parms[i].name);
3922 if (!strncmp(stp, parms[i].name, len) &&
3923 (*(stp + len) == ':' || *(stp + len) == '=')) {
3924 if (parms[i].val)
3925 *parms[i].val =
3926 simple_strtoul(stp + len + 1, NULL, 0);
3927 else
3928 printk(KERN_WARNING "st: Obsolete parameter %s\n",
3929 parms[i].name);
3930 break;
3931 }
3932 }
3933 if (i >= ARRAY_SIZE(parms))
3934 printk(KERN_WARNING "st: invalid parameter in '%s'\n",
3935 stp);
3936 stp = strchr(stp, ',');
3937 if (stp)
3938 stp++;
3939 }
3940 }
3941
3942 validate_options();
3943
3944 return 1;
3945 }
3946
3947 __setup("st=", st_setup);
3948
3949 #endif
3950
3951 static const struct file_operations st_fops =
3952 {
3953 .owner = THIS_MODULE,
3954 .read = st_read,
3955 .write = st_write,
3956 .unlocked_ioctl = st_ioctl,
3957 #ifdef CONFIG_COMPAT
3958 .compat_ioctl = st_compat_ioctl,
3959 #endif
3960 .open = st_open,
3961 .flush = st_flush,
3962 .release = st_release,
3963 };
3964
3965 static int st_probe(struct device *dev)
3966 {
3967 struct scsi_device *SDp = to_scsi_device(dev);
3968 struct gendisk *disk = NULL;
3969 struct cdev *cdev = NULL;
3970 struct scsi_tape *tpnt = NULL;
3971 struct st_modedef *STm;
3972 struct st_partstat *STps;
3973 struct st_buffer *buffer;
3974 int i, j, mode, dev_num, error;
3975 char *stp;
3976
3977 if (SDp->type != TYPE_TAPE)
3978 return -ENODEV;
3979 if ((stp = st_incompatible(SDp))) {
3980 sdev_printk(KERN_INFO, SDp, "Found incompatible tape\n");
3981 printk(KERN_INFO "st: The suggested driver is %s.\n", stp);
3982 return -ENODEV;
3983 }
3984
3985 i = min(queue_max_hw_segments(SDp->request_queue),
3986 queue_max_phys_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 }
Linux with added FPC-III support