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