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