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