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