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