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