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