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