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