projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
[SCSI] st: clean up dev cleanup in st_probe
[deliverable/linux.git] / drivers / scsi / st.c
1 /*
2 SCSI Tape Driver for Linux version 1.1 and newer. See the accompanying
3 file Documentation/scsi/st.txt for more information.
4
5 History:
6 Rewritten from Dwayne Forsyth's SCSI tape driver by Kai Makisara.
7 Contribution and ideas from several people including (in alphabetical
8 order) Klaus Ehrenfried, Eugene Exarevsky, Eric Lee Green, Wolfgang Denk,
9 Steve Hirsch, Andreas Koppenh"ofer, Michael Leodolter, Eyal Lebedinsky,
10 Michael Schaefer, J"org Weule, and Eric Youngdale.
11
12 Copyright 1992 - 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
46 #include <scsi/scsi.h>
47 #include <scsi/scsi_dbg.h>
48 #include <scsi/scsi_device.h>
49 #include <scsi/scsi_driver.h>
50 #include <scsi/scsi_eh.h>
51 #include <scsi/scsi_host.h>
52 #include <scsi/scsi_ioctl.h>
53 #include <scsi/sg.h>
54
55
56 /* The driver prints some debugging information on the console if DEBUG
57 is defined and non-zero. */
58 #define DEBUG 0
59
60 #if DEBUG
61 /* The message level for the debug messages is currently set to KERN_NOTICE
62 so that people can easily see the messages. Later when the debugging messages
63 in the drivers are more widely classified, this may be changed to KERN_DEBUG. */
64 #define ST_DEB_MSG KERN_NOTICE
65 #define DEB(a) a
66 #define DEBC(a) if (debugging) { a ; }
67 #else
68 #define DEB(a)
69 #define DEBC(a)
70 #endif
71
72 #define ST_KILOBYTE 1024
73
74 #include "st_options.h"
75 #include "st.h"
76
77 static DEFINE_MUTEX(st_mutex);
78 static int buffer_kbs;
79 static int max_sg_segs;
80 static int try_direct_io = TRY_DIRECT_IO;
81 static int try_rdio = 1;
82 static int try_wdio = 1;
83
84 static int st_dev_max;
85 static int st_nr_dev;
86
87 static struct class st_sysfs_class;
88 static struct device_attribute st_dev_attrs[];
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 if (!STp->drv_buffer && STp->immediate_filemark) {
1110 printk(KERN_WARNING
1111 "%s: non-buffered tape: disabling writing immediate filemarks\n",
1112 name);
1113 STp->immediate_filemark = 0;
1114 }
1115 }
1116 st_release_request(SRpnt);
1117 SRpnt = NULL;
1118 STp->inited = 1;
1119
1120 if (STp->block_size > 0)
1121 (STp->buffer)->buffer_blocks =
1122 (STp->buffer)->buffer_size / STp->block_size;
1123 else
1124 (STp->buffer)->buffer_blocks = 1;
1125 (STp->buffer)->buffer_bytes = (STp->buffer)->read_pointer = 0;
1126
1127 DEBC(printk(ST_DEB_MSG
1128 "%s: Block size: %d, buffer size: %d (%d blocks).\n", name,
1129 STp->block_size, (STp->buffer)->buffer_size,
1130 (STp->buffer)->buffer_blocks));
1131
1132 if (STp->drv_write_prot) {
1133 STp->write_prot = 1;
1134
1135 DEBC(printk(ST_DEB_MSG "%s: Write protected\n", name));
1136
1137 if (do_wait &&
1138 ((st_flags & O_ACCMODE) == O_WRONLY ||
1139 (st_flags & O_ACCMODE) == O_RDWR)) {
1140 retval = (-EROFS);
1141 goto err_out;
1142 }
1143 }
1144
1145 if (STp->can_partitions && STp->nbr_partitions < 1) {
1146 /* This code is reached when the device is opened for the first time
1147 after the driver has been initialized with tape in the drive and the
1148 partition support has been enabled. */
1149 DEBC(printk(ST_DEB_MSG
1150 "%s: Updating partition number in status.\n", name));
1151 if ((STp->partition = find_partition(STp)) < 0) {
1152 retval = STp->partition;
1153 goto err_out;
1154 }
1155 STp->new_partition = STp->partition;
1156 STp->nbr_partitions = 1; /* This guess will be updated when necessary */
1157 }
1158
1159 if (new_session) { /* Change the drive parameters for the new mode */
1160 STp->density_changed = STp->blksize_changed = 0;
1161 STp->compression_changed = 0;
1162 if (!(STm->defaults_for_writes) &&
1163 (retval = set_mode_densblk(STp, STm)) < 0)
1164 goto err_out;
1165
1166 if (STp->default_drvbuffer != 0xff) {
1167 if (st_int_ioctl(STp, MTSETDRVBUFFER, STp->default_drvbuffer))
1168 printk(KERN_WARNING
1169 "%s: Can't set default drive buffering to %d.\n",
1170 name, STp->default_drvbuffer);
1171 }
1172 }
1173
1174 return CHKRES_READY;
1175
1176 err_out:
1177 return retval;
1178 }
1179
1180
1181 \f/* Open the device. Needs to take the BKL only because of incrementing the SCSI host
1182 module count. */
1183 static int st_open(struct inode *inode, struct file *filp)
1184 {
1185 int i, retval = (-EIO);
1186 int resumed = 0;
1187 struct scsi_tape *STp;
1188 struct st_partstat *STps;
1189 int dev = TAPE_NR(inode);
1190 char *name;
1191
1192 mutex_lock(&st_mutex);
1193 /*
1194 * We really want to do nonseekable_open(inode, filp); here, but some
1195 * versions of tar incorrectly call lseek on tapes and bail out if that
1196 * fails. So we disallow pread() and pwrite(), but permit lseeks.
1197 */
1198 filp->f_mode &= ~(FMODE_PREAD | FMODE_PWRITE);
1199
1200 if (!(STp = scsi_tape_get(dev))) {
1201 mutex_unlock(&st_mutex);
1202 return -ENXIO;
1203 }
1204
1205 write_lock(&st_dev_arr_lock);
1206 filp->private_data = STp;
1207 name = tape_name(STp);
1208
1209 if (STp->in_use) {
1210 write_unlock(&st_dev_arr_lock);
1211 scsi_tape_put(STp);
1212 mutex_unlock(&st_mutex);
1213 DEB( printk(ST_DEB_MSG "%s: Device already in use.\n", name); )
1214 return (-EBUSY);
1215 }
1216
1217 STp->in_use = 1;
1218 write_unlock(&st_dev_arr_lock);
1219 STp->rew_at_close = STp->autorew_dev = (iminor(inode) & 0x80) == 0;
1220
1221 if (scsi_autopm_get_device(STp->device) < 0) {
1222 retval = -EIO;
1223 goto err_out;
1224 }
1225 resumed = 1;
1226 if (!scsi_block_when_processing_errors(STp->device)) {
1227 retval = (-ENXIO);
1228 goto err_out;
1229 }
1230
1231 /* See that we have at least a one page buffer available */
1232 if (!enlarge_buffer(STp->buffer, PAGE_SIZE, STp->restr_dma)) {
1233 printk(KERN_WARNING "%s: Can't allocate one page tape buffer.\n",
1234 name);
1235 retval = (-EOVERFLOW);
1236 goto err_out;
1237 }
1238
1239 (STp->buffer)->cleared = 0;
1240 (STp->buffer)->writing = 0;
1241 (STp->buffer)->syscall_result = 0;
1242
1243 STp->write_prot = ((filp->f_flags & O_ACCMODE) == O_RDONLY);
1244
1245 STp->dirty = 0;
1246 for (i = 0; i < ST_NBR_PARTITIONS; i++) {
1247 STps = &(STp->ps[i]);
1248 STps->rw = ST_IDLE;
1249 }
1250 STp->try_dio_now = STp->try_dio;
1251 STp->recover_count = 0;
1252 DEB( STp->nbr_waits = STp->nbr_finished = 0;
1253 STp->nbr_requests = STp->nbr_dio = STp->nbr_pages = 0; )
1254
1255 retval = check_tape(STp, filp);
1256 if (retval < 0)
1257 goto err_out;
1258 if ((filp->f_flags & O_NONBLOCK) == 0 &&
1259 retval != CHKRES_READY) {
1260 if (STp->ready == NO_TAPE)
1261 retval = (-ENOMEDIUM);
1262 else
1263 retval = (-EIO);
1264 goto err_out;
1265 }
1266 mutex_unlock(&st_mutex);
1267 return 0;
1268
1269 err_out:
1270 normalize_buffer(STp->buffer);
1271 STp->in_use = 0;
1272 scsi_tape_put(STp);
1273 if (resumed)
1274 scsi_autopm_put_device(STp->device);
1275 mutex_unlock(&st_mutex);
1276 return retval;
1277
1278 }
1279 \f
1280
1281 /* Flush the tape buffer before close */
1282 static int st_flush(struct file *filp, fl_owner_t id)
1283 {
1284 int result = 0, result2;
1285 unsigned char cmd[MAX_COMMAND_SIZE];
1286 struct st_request *SRpnt;
1287 struct scsi_tape *STp = filp->private_data;
1288 struct st_modedef *STm = &(STp->modes[STp->current_mode]);
1289 struct st_partstat *STps = &(STp->ps[STp->partition]);
1290 char *name = tape_name(STp);
1291
1292 if (file_count(filp) > 1)
1293 return 0;
1294
1295 if (STps->rw == ST_WRITING && !STp->pos_unknown) {
1296 result = st_flush_write_buffer(STp);
1297 if (result != 0 && result != (-ENOSPC))
1298 goto out;
1299 }
1300
1301 if (STp->can_partitions &&
1302 (result2 = switch_partition(STp)) < 0) {
1303 DEBC(printk(ST_DEB_MSG
1304 "%s: switch_partition at close failed.\n", name));
1305 if (result == 0)
1306 result = result2;
1307 goto out;
1308 }
1309
1310 DEBC( if (STp->nbr_requests)
1311 printk(KERN_DEBUG "%s: Number of r/w requests %d, dio used in %d, pages %d.\n",
1312 name, STp->nbr_requests, STp->nbr_dio, STp->nbr_pages));
1313
1314 if (STps->rw == ST_WRITING && !STp->pos_unknown) {
1315 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
1316
1317 DEBC(printk(ST_DEB_MSG "%s: Async write waits %d, finished %d.\n",
1318 name, STp->nbr_waits, STp->nbr_finished);
1319 )
1320
1321 memset(cmd, 0, MAX_COMMAND_SIZE);
1322 cmd[0] = WRITE_FILEMARKS;
1323 if (STp->immediate_filemark)
1324 cmd[1] = 1;
1325 cmd[4] = 1 + STp->two_fm;
1326
1327 SRpnt = st_do_scsi(NULL, STp, cmd, 0, DMA_NONE,
1328 STp->device->request_queue->rq_timeout,
1329 MAX_WRITE_RETRIES, 1);
1330 if (!SRpnt) {
1331 result = (STp->buffer)->syscall_result;
1332 goto out;
1333 }
1334
1335 if (STp->buffer->syscall_result == 0 ||
1336 (cmdstatp->have_sense && !cmdstatp->deferred &&
1337 (cmdstatp->flags & SENSE_EOM) &&
1338 (cmdstatp->sense_hdr.sense_key == NO_SENSE ||
1339 cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR) &&
1340 (!cmdstatp->remainder_valid || cmdstatp->uremainder64 == 0))) {
1341 /* Write successful at EOM */
1342 st_release_request(SRpnt);
1343 SRpnt = NULL;
1344 if (STps->drv_file >= 0)
1345 STps->drv_file++;
1346 STps->drv_block = 0;
1347 if (STp->two_fm)
1348 cross_eof(STp, 0);
1349 STps->eof = ST_FM;
1350 }
1351 else { /* Write error */
1352 st_release_request(SRpnt);
1353 SRpnt = NULL;
1354 printk(KERN_ERR "%s: Error on write filemark.\n", name);
1355 if (result == 0)
1356 result = (-EIO);
1357 }
1358
1359 DEBC(printk(ST_DEB_MSG "%s: Buffer flushed, %d EOF(s) written\n",
1360 name, cmd[4]));
1361 } else if (!STp->rew_at_close) {
1362 STps = &(STp->ps[STp->partition]);
1363 if (!STm->sysv || STps->rw != ST_READING) {
1364 if (STp->can_bsr)
1365 result = flush_buffer(STp, 0);
1366 else if (STps->eof == ST_FM_HIT) {
1367 result = cross_eof(STp, 0);
1368 if (result) {
1369 if (STps->drv_file >= 0)
1370 STps->drv_file++;
1371 STps->drv_block = 0;
1372 STps->eof = ST_FM;
1373 } else
1374 STps->eof = ST_NOEOF;
1375 }
1376 } else if ((STps->eof == ST_NOEOF &&
1377 !(result = cross_eof(STp, 1))) ||
1378 STps->eof == ST_FM_HIT) {
1379 if (STps->drv_file >= 0)
1380 STps->drv_file++;
1381 STps->drv_block = 0;
1382 STps->eof = ST_FM;
1383 }
1384 }
1385
1386 out:
1387 if (STp->rew_at_close) {
1388 result2 = st_int_ioctl(STp, MTREW, 1);
1389 if (result == 0)
1390 result = result2;
1391 }
1392 return result;
1393 }
1394
1395
1396 /* Close the device and release it. BKL is not needed: this is the only thread
1397 accessing this tape. */
1398 static int st_release(struct inode *inode, struct file *filp)
1399 {
1400 int result = 0;
1401 struct scsi_tape *STp = filp->private_data;
1402
1403 if (STp->door_locked == ST_LOCKED_AUTO)
1404 do_door_lock(STp, 0);
1405
1406 normalize_buffer(STp->buffer);
1407 write_lock(&st_dev_arr_lock);
1408 STp->in_use = 0;
1409 write_unlock(&st_dev_arr_lock);
1410 scsi_autopm_put_device(STp->device);
1411 scsi_tape_put(STp);
1412
1413 return result;
1414 }
1415 \f
1416 /* The checks common to both reading and writing */
1417 static ssize_t rw_checks(struct scsi_tape *STp, struct file *filp, size_t count)
1418 {
1419 ssize_t retval = 0;
1420
1421 /*
1422 * If we are in the middle of error recovery, don't let anyone
1423 * else try and use this device. Also, if error recovery fails, it
1424 * may try and take the device offline, in which case all further
1425 * access to the device is prohibited.
1426 */
1427 if (!scsi_block_when_processing_errors(STp->device)) {
1428 retval = (-ENXIO);
1429 goto out;
1430 }
1431
1432 if (STp->ready != ST_READY) {
1433 if (STp->ready == ST_NO_TAPE)
1434 retval = (-ENOMEDIUM);
1435 else
1436 retval = (-EIO);
1437 goto out;
1438 }
1439
1440 if (! STp->modes[STp->current_mode].defined) {
1441 retval = (-ENXIO);
1442 goto out;
1443 }
1444
1445
1446 /*
1447 * If there was a bus reset, block further access
1448 * to this device.
1449 */
1450 if (STp->pos_unknown) {
1451 retval = (-EIO);
1452 goto out;
1453 }
1454
1455 if (count == 0)
1456 goto out;
1457
1458 DEB(
1459 if (!STp->in_use) {
1460 printk(ST_DEB_MSG "%s: Incorrect device.\n", tape_name(STp));
1461 retval = (-EIO);
1462 goto out;
1463 } ) /* end DEB */
1464
1465 if (STp->can_partitions &&
1466 (retval = switch_partition(STp)) < 0)
1467 goto out;
1468
1469 if (STp->block_size == 0 && STp->max_block > 0 &&
1470 (count < STp->min_block || count > STp->max_block)) {
1471 retval = (-EINVAL);
1472 goto out;
1473 }
1474
1475 if (STp->do_auto_lock && STp->door_locked == ST_UNLOCKED &&
1476 !do_door_lock(STp, 1))
1477 STp->door_locked = ST_LOCKED_AUTO;
1478
1479 out:
1480 return retval;
1481 }
1482
1483
1484 static int setup_buffering(struct scsi_tape *STp, const char __user *buf,
1485 size_t count, int is_read)
1486 {
1487 int i, bufsize, retval = 0;
1488 struct st_buffer *STbp = STp->buffer;
1489
1490 if (is_read)
1491 i = STp->try_dio_now && try_rdio;
1492 else
1493 i = STp->try_dio_now && try_wdio;
1494
1495 if (i && ((unsigned long)buf & queue_dma_alignment(
1496 STp->device->request_queue)) == 0) {
1497 i = sgl_map_user_pages(STbp, STbp->use_sg, (unsigned long)buf,
1498 count, (is_read ? READ : WRITE));
1499 if (i > 0) {
1500 STbp->do_dio = i;
1501 STbp->buffer_bytes = 0; /* can be used as transfer counter */
1502 }
1503 else
1504 STbp->do_dio = 0; /* fall back to buffering with any error */
1505 STbp->sg_segs = STbp->do_dio;
1506 DEB(
1507 if (STbp->do_dio) {
1508 STp->nbr_dio++;
1509 STp->nbr_pages += STbp->do_dio;
1510 }
1511 )
1512 } else
1513 STbp->do_dio = 0;
1514 DEB( STp->nbr_requests++; )
1515
1516 if (!STbp->do_dio) {
1517 if (STp->block_size)
1518 bufsize = STp->block_size > st_fixed_buffer_size ?
1519 STp->block_size : st_fixed_buffer_size;
1520 else {
1521 bufsize = count;
1522 /* Make sure that data from previous user is not leaked even if
1523 HBA does not return correct residual */
1524 if (is_read && STp->sili && !STbp->cleared)
1525 clear_buffer(STbp);
1526 }
1527
1528 if (bufsize > STbp->buffer_size &&
1529 !enlarge_buffer(STbp, bufsize, STp->restr_dma)) {
1530 printk(KERN_WARNING "%s: Can't allocate %d byte tape buffer.\n",
1531 tape_name(STp), bufsize);
1532 retval = (-EOVERFLOW);
1533 goto out;
1534 }
1535 if (STp->block_size)
1536 STbp->buffer_blocks = bufsize / STp->block_size;
1537 }
1538
1539 out:
1540 return retval;
1541 }
1542
1543
1544 /* Can be called more than once after each setup_buffer() */
1545 static void release_buffering(struct scsi_tape *STp, int is_read)
1546 {
1547 struct st_buffer *STbp;
1548
1549 STbp = STp->buffer;
1550 if (STbp->do_dio) {
1551 sgl_unmap_user_pages(STbp, STbp->do_dio, is_read);
1552 STbp->do_dio = 0;
1553 STbp->sg_segs = 0;
1554 }
1555 }
1556
1557
1558 /* Write command */
1559 static ssize_t
1560 st_write(struct file *filp, const char __user *buf, size_t count, loff_t * ppos)
1561 {
1562 ssize_t total;
1563 ssize_t i, do_count, blks, transfer;
1564 ssize_t retval;
1565 int undone, retry_eot = 0, scode;
1566 int async_write;
1567 unsigned char cmd[MAX_COMMAND_SIZE];
1568 const char __user *b_point;
1569 struct st_request *SRpnt = NULL;
1570 struct scsi_tape *STp = filp->private_data;
1571 struct st_modedef *STm;
1572 struct st_partstat *STps;
1573 struct st_buffer *STbp;
1574 char *name = tape_name(STp);
1575
1576 if (mutex_lock_interruptible(&STp->lock))
1577 return -ERESTARTSYS;
1578
1579 retval = rw_checks(STp, filp, count);
1580 if (retval || count == 0)
1581 goto out;
1582
1583 /* Write must be integral number of blocks */
1584 if (STp->block_size != 0 && (count % STp->block_size) != 0) {
1585 printk(KERN_WARNING "%s: Write not multiple of tape block size.\n",
1586 name);
1587 retval = (-EINVAL);
1588 goto out;
1589 }
1590
1591 STm = &(STp->modes[STp->current_mode]);
1592 STps = &(STp->ps[STp->partition]);
1593
1594 if (STp->write_prot) {
1595 retval = (-EACCES);
1596 goto out;
1597 }
1598
1599
1600 if (STps->rw == ST_READING) {
1601 retval = flush_buffer(STp, 0);
1602 if (retval)
1603 goto out;
1604 STps->rw = ST_WRITING;
1605 } else if (STps->rw != ST_WRITING &&
1606 STps->drv_file == 0 && STps->drv_block == 0) {
1607 if ((retval = set_mode_densblk(STp, STm)) < 0)
1608 goto out;
1609 if (STm->default_compression != ST_DONT_TOUCH &&
1610 !(STp->compression_changed)) {
1611 if (st_compression(STp, (STm->default_compression == ST_YES))) {
1612 printk(KERN_WARNING "%s: Can't set default compression.\n",
1613 name);
1614 if (modes_defined) {
1615 retval = (-EINVAL);
1616 goto out;
1617 }
1618 }
1619 }
1620 }
1621
1622 STbp = STp->buffer;
1623 i = write_behind_check(STp);
1624 if (i) {
1625 if (i == -ENOSPC)
1626 STps->eof = ST_EOM_OK;
1627 else
1628 STps->eof = ST_EOM_ERROR;
1629 }
1630
1631 if (STps->eof == ST_EOM_OK) {
1632 STps->eof = ST_EOD_1; /* allow next write */
1633 retval = (-ENOSPC);
1634 goto out;
1635 }
1636 else if (STps->eof == ST_EOM_ERROR) {
1637 retval = (-EIO);
1638 goto out;
1639 }
1640
1641 /* Check the buffer readability in cases where copy_user might catch
1642 the problems after some tape movement. */
1643 if (STp->block_size != 0 &&
1644 !STbp->do_dio &&
1645 (copy_from_user(&i, buf, 1) != 0 ||
1646 copy_from_user(&i, buf + count - 1, 1) != 0)) {
1647 retval = (-EFAULT);
1648 goto out;
1649 }
1650
1651 retval = setup_buffering(STp, buf, count, 0);
1652 if (retval)
1653 goto out;
1654
1655 total = count;
1656
1657 memset(cmd, 0, MAX_COMMAND_SIZE);
1658 cmd[0] = WRITE_6;
1659 cmd[1] = (STp->block_size != 0);
1660
1661 STps->rw = ST_WRITING;
1662
1663 b_point = buf;
1664 while (count > 0 && !retry_eot) {
1665
1666 if (STbp->do_dio) {
1667 do_count = count;
1668 }
1669 else {
1670 if (STp->block_size == 0)
1671 do_count = count;
1672 else {
1673 do_count = STbp->buffer_blocks * STp->block_size -
1674 STbp->buffer_bytes;
1675 if (do_count > count)
1676 do_count = count;
1677 }
1678
1679 i = append_to_buffer(b_point, STbp, do_count);
1680 if (i) {
1681 retval = i;
1682 goto out;
1683 }
1684 }
1685 count -= do_count;
1686 b_point += do_count;
1687
1688 async_write = STp->block_size == 0 && !STbp->do_dio &&
1689 STm->do_async_writes && STps->eof < ST_EOM_OK;
1690
1691 if (STp->block_size != 0 && STm->do_buffer_writes &&
1692 !(STp->try_dio_now && try_wdio) && STps->eof < ST_EOM_OK &&
1693 STbp->buffer_bytes < STbp->buffer_size) {
1694 STp->dirty = 1;
1695 /* Don't write a buffer that is not full enough. */
1696 if (!async_write && count == 0)
1697 break;
1698 }
1699
1700 retry_write:
1701 if (STp->block_size == 0)
1702 blks = transfer = do_count;
1703 else {
1704 if (!STbp->do_dio)
1705 blks = STbp->buffer_bytes;
1706 else
1707 blks = do_count;
1708 blks /= STp->block_size;
1709 transfer = blks * STp->block_size;
1710 }
1711 cmd[2] = blks >> 16;
1712 cmd[3] = blks >> 8;
1713 cmd[4] = blks;
1714
1715 SRpnt = st_do_scsi(SRpnt, STp, cmd, transfer, DMA_TO_DEVICE,
1716 STp->device->request_queue->rq_timeout,
1717 MAX_WRITE_RETRIES, !async_write);
1718 if (!SRpnt) {
1719 retval = STbp->syscall_result;
1720 goto out;
1721 }
1722 if (async_write && !STbp->syscall_result) {
1723 STbp->writing = transfer;
1724 STp->dirty = !(STbp->writing ==
1725 STbp->buffer_bytes);
1726 SRpnt = NULL; /* Prevent releasing this request! */
1727 DEB( STp->write_pending = 1; )
1728 break;
1729 }
1730
1731 if (STbp->syscall_result != 0) {
1732 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
1733
1734 DEBC(printk(ST_DEB_MSG "%s: Error on write:\n", name));
1735 if (cmdstatp->have_sense && (cmdstatp->flags & SENSE_EOM)) {
1736 scode = cmdstatp->sense_hdr.sense_key;
1737 if (cmdstatp->remainder_valid)
1738 undone = (int)cmdstatp->uremainder64;
1739 else if (STp->block_size == 0 &&
1740 scode == VOLUME_OVERFLOW)
1741 undone = transfer;
1742 else
1743 undone = 0;
1744 if (STp->block_size != 0)
1745 undone *= STp->block_size;
1746 if (undone <= do_count) {
1747 /* Only data from this write is not written */
1748 count += undone;
1749 b_point -= undone;
1750 do_count -= undone;
1751 if (STp->block_size)
1752 blks = (transfer - undone) / STp->block_size;
1753 STps->eof = ST_EOM_OK;
1754 /* Continue in fixed block mode if all written
1755 in this request but still something left to write
1756 (retval left to zero)
1757 */
1758 if (STp->block_size == 0 ||
1759 undone > 0 || count == 0)
1760 retval = (-ENOSPC); /* EOM within current request */
1761 DEBC(printk(ST_DEB_MSG
1762 "%s: EOM with %d bytes unwritten.\n",
1763 name, (int)count));
1764 } else {
1765 /* EOT within data buffered earlier (possible only
1766 in fixed block mode without direct i/o) */
1767 if (!retry_eot && !cmdstatp->deferred &&
1768 (scode == NO_SENSE || scode == RECOVERED_ERROR)) {
1769 move_buffer_data(STp->buffer, transfer - undone);
1770 retry_eot = 1;
1771 if (STps->drv_block >= 0) {
1772 STps->drv_block += (transfer - undone) /
1773 STp->block_size;
1774 }
1775 STps->eof = ST_EOM_OK;
1776 DEBC(printk(ST_DEB_MSG
1777 "%s: Retry write of %d bytes at EOM.\n",
1778 name, STp->buffer->buffer_bytes));
1779 goto retry_write;
1780 }
1781 else {
1782 /* Either error within data buffered by driver or
1783 failed retry */
1784 count -= do_count;
1785 blks = do_count = 0;
1786 STps->eof = ST_EOM_ERROR;
1787 STps->drv_block = (-1); /* Too cautious? */
1788 retval = (-EIO); /* EOM for old data */
1789 DEBC(printk(ST_DEB_MSG
1790 "%s: EOM with lost data.\n",
1791 name));
1792 }
1793 }
1794 } else {
1795 count += do_count;
1796 STps->drv_block = (-1); /* Too cautious? */
1797 retval = STbp->syscall_result;
1798 }
1799
1800 }
1801
1802 if (STps->drv_block >= 0) {
1803 if (STp->block_size == 0)
1804 STps->drv_block += (do_count > 0);
1805 else
1806 STps->drv_block += blks;
1807 }
1808
1809 STbp->buffer_bytes = 0;
1810 STp->dirty = 0;
1811
1812 if (retval || retry_eot) {
1813 if (count < total)
1814 retval = total - count;
1815 goto out;
1816 }
1817 }
1818
1819 if (STps->eof == ST_EOD_1)
1820 STps->eof = ST_EOM_OK;
1821 else if (STps->eof != ST_EOM_OK)
1822 STps->eof = ST_NOEOF;
1823 retval = total - count;
1824
1825 out:
1826 if (SRpnt != NULL)
1827 st_release_request(SRpnt);
1828 release_buffering(STp, 0);
1829 mutex_unlock(&STp->lock);
1830
1831 return retval;
1832 }
1833 \f
1834 /* Read data from the tape. Returns zero in the normal case, one if the
1835 eof status has changed, and the negative error code in case of a
1836 fatal error. Otherwise updates the buffer and the eof state.
1837
1838 Does release user buffer mapping if it is set.
1839 */
1840 static long read_tape(struct scsi_tape *STp, long count,
1841 struct st_request ** aSRpnt)
1842 {
1843 int transfer, blks, bytes;
1844 unsigned char cmd[MAX_COMMAND_SIZE];
1845 struct st_request *SRpnt;
1846 struct st_modedef *STm;
1847 struct st_partstat *STps;
1848 struct st_buffer *STbp;
1849 int retval = 0;
1850 char *name = tape_name(STp);
1851
1852 if (count == 0)
1853 return 0;
1854
1855 STm = &(STp->modes[STp->current_mode]);
1856 STps = &(STp->ps[STp->partition]);
1857 if (STps->eof == ST_FM_HIT)
1858 return 1;
1859 STbp = STp->buffer;
1860
1861 if (STp->block_size == 0)
1862 blks = bytes = count;
1863 else {
1864 if (!(STp->try_dio_now && try_rdio) && STm->do_read_ahead) {
1865 blks = (STp->buffer)->buffer_blocks;
1866 bytes = blks * STp->block_size;
1867 } else {
1868 bytes = count;
1869 if (!STbp->do_dio && bytes > (STp->buffer)->buffer_size)
1870 bytes = (STp->buffer)->buffer_size;
1871 blks = bytes / STp->block_size;
1872 bytes = blks * STp->block_size;
1873 }
1874 }
1875
1876 memset(cmd, 0, MAX_COMMAND_SIZE);
1877 cmd[0] = READ_6;
1878 cmd[1] = (STp->block_size != 0);
1879 if (!cmd[1] && STp->sili)
1880 cmd[1] |= 2;
1881 cmd[2] = blks >> 16;
1882 cmd[3] = blks >> 8;
1883 cmd[4] = blks;
1884
1885 SRpnt = *aSRpnt;
1886 SRpnt = st_do_scsi(SRpnt, STp, cmd, bytes, DMA_FROM_DEVICE,
1887 STp->device->request_queue->rq_timeout,
1888 MAX_RETRIES, 1);
1889 release_buffering(STp, 1);
1890 *aSRpnt = SRpnt;
1891 if (!SRpnt)
1892 return STbp->syscall_result;
1893
1894 STbp->read_pointer = 0;
1895 STps->at_sm = 0;
1896
1897 /* Something to check */
1898 if (STbp->syscall_result) {
1899 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
1900
1901 retval = 1;
1902 DEBC(printk(ST_DEB_MSG "%s: Sense: %2x %2x %2x %2x %2x %2x %2x %2x\n",
1903 name,
1904 SRpnt->sense[0], SRpnt->sense[1],
1905 SRpnt->sense[2], SRpnt->sense[3],
1906 SRpnt->sense[4], SRpnt->sense[5],
1907 SRpnt->sense[6], SRpnt->sense[7]));
1908 if (cmdstatp->have_sense) {
1909
1910 if (cmdstatp->sense_hdr.sense_key == BLANK_CHECK)
1911 cmdstatp->flags &= 0xcf; /* No need for EOM in this case */
1912
1913 if (cmdstatp->flags != 0) { /* EOF, EOM, or ILI */
1914 /* Compute the residual count */
1915 if (cmdstatp->remainder_valid)
1916 transfer = (int)cmdstatp->uremainder64;
1917 else
1918 transfer = 0;
1919 if (STp->block_size == 0 &&
1920 cmdstatp->sense_hdr.sense_key == MEDIUM_ERROR)
1921 transfer = bytes;
1922
1923 if (cmdstatp->flags & SENSE_ILI) { /* ILI */
1924 if (STp->block_size == 0) {
1925 if (transfer <= 0) {
1926 if (transfer < 0)
1927 printk(KERN_NOTICE
1928 "%s: Failed to read %d byte block with %d byte transfer.\n",
1929 name, bytes - transfer, bytes);
1930 if (STps->drv_block >= 0)
1931 STps->drv_block += 1;
1932 STbp->buffer_bytes = 0;
1933 return (-ENOMEM);
1934 }
1935 STbp->buffer_bytes = bytes - transfer;
1936 } else {
1937 st_release_request(SRpnt);
1938 SRpnt = *aSRpnt = NULL;
1939 if (transfer == blks) { /* We did not get anything, error */
1940 printk(KERN_NOTICE "%s: Incorrect block size.\n", name);
1941 if (STps->drv_block >= 0)
1942 STps->drv_block += blks - transfer + 1;
1943 st_int_ioctl(STp, MTBSR, 1);
1944 return (-EIO);
1945 }
1946 /* We have some data, deliver it */
1947 STbp->buffer_bytes = (blks - transfer) *
1948 STp->block_size;
1949 DEBC(printk(ST_DEB_MSG
1950 "%s: ILI but enough data received %ld %d.\n",
1951 name, count, STbp->buffer_bytes));
1952 if (STps->drv_block >= 0)
1953 STps->drv_block += 1;
1954 if (st_int_ioctl(STp, MTBSR, 1))
1955 return (-EIO);
1956 }
1957 } else if (cmdstatp->flags & SENSE_FMK) { /* FM overrides EOM */
1958 if (STps->eof != ST_FM_HIT)
1959 STps->eof = ST_FM_HIT;
1960 else
1961 STps->eof = ST_EOD_2;
1962 if (STp->block_size == 0)
1963 STbp->buffer_bytes = 0;
1964 else
1965 STbp->buffer_bytes =
1966 bytes - transfer * STp->block_size;
1967 DEBC(printk(ST_DEB_MSG
1968 "%s: EOF detected (%d bytes read).\n",
1969 name, STbp->buffer_bytes));
1970 } else if (cmdstatp->flags & SENSE_EOM) {
1971 if (STps->eof == ST_FM)
1972 STps->eof = ST_EOD_1;
1973 else
1974 STps->eof = ST_EOM_OK;
1975 if (STp->block_size == 0)
1976 STbp->buffer_bytes = bytes - transfer;
1977 else
1978 STbp->buffer_bytes =
1979 bytes - transfer * STp->block_size;
1980
1981 DEBC(printk(ST_DEB_MSG "%s: EOM detected (%d bytes read).\n",
1982 name, STbp->buffer_bytes));
1983 }
1984 }
1985 /* end of EOF, EOM, ILI test */
1986 else { /* nonzero sense key */
1987 DEBC(printk(ST_DEB_MSG
1988 "%s: Tape error while reading.\n", name));
1989 STps->drv_block = (-1);
1990 if (STps->eof == ST_FM &&
1991 cmdstatp->sense_hdr.sense_key == BLANK_CHECK) {
1992 DEBC(printk(ST_DEB_MSG
1993 "%s: Zero returned for first BLANK CHECK after EOF.\n",
1994 name));
1995 STps->eof = ST_EOD_2; /* First BLANK_CHECK after FM */
1996 } else /* Some other extended sense code */
1997 retval = (-EIO);
1998 }
1999
2000 if (STbp->buffer_bytes < 0) /* Caused by bogus sense data */
2001 STbp->buffer_bytes = 0;
2002 }
2003 /* End of extended sense test */
2004 else { /* Non-extended sense */
2005 retval = STbp->syscall_result;
2006 }
2007
2008 }
2009 /* End of error handling */
2010 else { /* Read successful */
2011 STbp->buffer_bytes = bytes;
2012 if (STp->sili) /* In fixed block mode residual is always zero here */
2013 STbp->buffer_bytes -= STp->buffer->cmdstat.residual;
2014 }
2015
2016 if (STps->drv_block >= 0) {
2017 if (STp->block_size == 0)
2018 STps->drv_block++;
2019 else
2020 STps->drv_block += STbp->buffer_bytes / STp->block_size;
2021 }
2022 return retval;
2023 }
2024 \f
2025
2026 /* Read command */
2027 static ssize_t
2028 st_read(struct file *filp, char __user *buf, size_t count, loff_t * ppos)
2029 {
2030 ssize_t total;
2031 ssize_t retval = 0;
2032 ssize_t i, transfer;
2033 int special, do_dio = 0;
2034 struct st_request *SRpnt = NULL;
2035 struct scsi_tape *STp = filp->private_data;
2036 struct st_modedef *STm;
2037 struct st_partstat *STps;
2038 struct st_buffer *STbp = STp->buffer;
2039 DEB( char *name = tape_name(STp); )
2040
2041 if (mutex_lock_interruptible(&STp->lock))
2042 return -ERESTARTSYS;
2043
2044 retval = rw_checks(STp, filp, count);
2045 if (retval || count == 0)
2046 goto out;
2047
2048 STm = &(STp->modes[STp->current_mode]);
2049 if (STp->block_size != 0 && (count % STp->block_size) != 0) {
2050 if (!STm->do_read_ahead) {
2051 retval = (-EINVAL); /* Read must be integral number of blocks */
2052 goto out;
2053 }
2054 STp->try_dio_now = 0; /* Direct i/o can't handle split blocks */
2055 }
2056
2057 STps = &(STp->ps[STp->partition]);
2058 if (STps->rw == ST_WRITING) {
2059 retval = flush_buffer(STp, 0);
2060 if (retval)
2061 goto out;
2062 STps->rw = ST_READING;
2063 }
2064 DEB(
2065 if (debugging && STps->eof != ST_NOEOF)
2066 printk(ST_DEB_MSG "%s: EOF/EOM flag up (%d). Bytes %d\n", name,
2067 STps->eof, STbp->buffer_bytes);
2068 ) /* end DEB */
2069
2070 retval = setup_buffering(STp, buf, count, 1);
2071 if (retval)
2072 goto out;
2073 do_dio = STbp->do_dio;
2074
2075 if (STbp->buffer_bytes == 0 &&
2076 STps->eof >= ST_EOD_1) {
2077 if (STps->eof < ST_EOD) {
2078 STps->eof += 1;
2079 retval = 0;
2080 goto out;
2081 }
2082 retval = (-EIO); /* EOM or Blank Check */
2083 goto out;
2084 }
2085
2086 if (do_dio) {
2087 /* Check the buffer writability before any tape movement. Don't alter
2088 buffer data. */
2089 if (copy_from_user(&i, buf, 1) != 0 ||
2090 copy_to_user(buf, &i, 1) != 0 ||
2091 copy_from_user(&i, buf + count - 1, 1) != 0 ||
2092 copy_to_user(buf + count - 1, &i, 1) != 0) {
2093 retval = (-EFAULT);
2094 goto out;
2095 }
2096 }
2097
2098 STps->rw = ST_READING;
2099
2100
2101 /* Loop until enough data in buffer or a special condition found */
2102 for (total = 0, special = 0; total < count && !special;) {
2103
2104 /* Get new data if the buffer is empty */
2105 if (STbp->buffer_bytes == 0) {
2106 special = read_tape(STp, count - total, &SRpnt);
2107 if (special < 0) { /* No need to continue read */
2108 retval = special;
2109 goto out;
2110 }
2111 }
2112
2113 /* Move the data from driver buffer to user buffer */
2114 if (STbp->buffer_bytes > 0) {
2115 DEB(
2116 if (debugging && STps->eof != ST_NOEOF)
2117 printk(ST_DEB_MSG
2118 "%s: EOF up (%d). Left %d, needed %d.\n", name,
2119 STps->eof, STbp->buffer_bytes,
2120 (int)(count - total));
2121 ) /* end DEB */
2122 transfer = STbp->buffer_bytes < count - total ?
2123 STbp->buffer_bytes : count - total;
2124 if (!do_dio) {
2125 i = from_buffer(STbp, buf, transfer);
2126 if (i) {
2127 retval = i;
2128 goto out;
2129 }
2130 }
2131 buf += transfer;
2132 total += transfer;
2133 }
2134
2135 if (STp->block_size == 0)
2136 break; /* Read only one variable length block */
2137
2138 } /* for (total = 0, special = 0;
2139 total < count && !special; ) */
2140
2141 /* Change the eof state if no data from tape or buffer */
2142 if (total == 0) {
2143 if (STps->eof == ST_FM_HIT) {
2144 STps->eof = ST_FM;
2145 STps->drv_block = 0;
2146 if (STps->drv_file >= 0)
2147 STps->drv_file++;
2148 } else if (STps->eof == ST_EOD_1) {
2149 STps->eof = ST_EOD_2;
2150 STps->drv_block = 0;
2151 if (STps->drv_file >= 0)
2152 STps->drv_file++;
2153 } else if (STps->eof == ST_EOD_2)
2154 STps->eof = ST_EOD;
2155 } else if (STps->eof == ST_FM)
2156 STps->eof = ST_NOEOF;
2157 retval = total;
2158
2159 out:
2160 if (SRpnt != NULL) {
2161 st_release_request(SRpnt);
2162 SRpnt = NULL;
2163 }
2164 if (do_dio) {
2165 release_buffering(STp, 1);
2166 STbp->buffer_bytes = 0;
2167 }
2168 mutex_unlock(&STp->lock);
2169
2170 return retval;
2171 }
2172 \f
2173
2174
2175 DEB(
2176 /* Set the driver options */
2177 static void st_log_options(struct scsi_tape * STp, struct st_modedef * STm, char *name)
2178 {
2179 if (debugging) {
2180 printk(KERN_INFO
2181 "%s: Mode %d options: buffer writes: %d, async writes: %d, read ahead: %d\n",
2182 name, STp->current_mode, STm->do_buffer_writes, STm->do_async_writes,
2183 STm->do_read_ahead);
2184 printk(KERN_INFO
2185 "%s: can bsr: %d, two FMs: %d, fast mteom: %d, auto lock: %d,\n",
2186 name, STp->can_bsr, STp->two_fm, STp->fast_mteom, STp->do_auto_lock);
2187 printk(KERN_INFO
2188 "%s: defs for wr: %d, no block limits: %d, partitions: %d, s2 log: %d\n",
2189 name, STm->defaults_for_writes, STp->omit_blklims, STp->can_partitions,
2190 STp->scsi2_logical);
2191 printk(KERN_INFO
2192 "%s: sysv: %d nowait: %d sili: %d nowait_filemark: %d\n",
2193 name, STm->sysv, STp->immediate, STp->sili,
2194 STp->immediate_filemark);
2195 printk(KERN_INFO "%s: debugging: %d\n",
2196 name, debugging);
2197 }
2198 }
2199 )
2200
2201
2202 static int st_set_options(struct scsi_tape *STp, long options)
2203 {
2204 int value;
2205 long code;
2206 struct st_modedef *STm;
2207 char *name = tape_name(STp);
2208 struct cdev *cd0, *cd1;
2209
2210 STm = &(STp->modes[STp->current_mode]);
2211 if (!STm->defined) {
2212 cd0 = STm->cdevs[0]; cd1 = STm->cdevs[1];
2213 memcpy(STm, &(STp->modes[0]), sizeof(struct st_modedef));
2214 STm->cdevs[0] = cd0; STm->cdevs[1] = cd1;
2215 modes_defined = 1;
2216 DEBC(printk(ST_DEB_MSG
2217 "%s: Initialized mode %d definition from mode 0\n",
2218 name, STp->current_mode));
2219 }
2220
2221 code = options & MT_ST_OPTIONS;
2222 if (code == MT_ST_BOOLEANS) {
2223 STm->do_buffer_writes = (options & MT_ST_BUFFER_WRITES) != 0;
2224 STm->do_async_writes = (options & MT_ST_ASYNC_WRITES) != 0;
2225 STm->defaults_for_writes = (options & MT_ST_DEF_WRITES) != 0;
2226 STm->do_read_ahead = (options & MT_ST_READ_AHEAD) != 0;
2227 STp->two_fm = (options & MT_ST_TWO_FM) != 0;
2228 STp->fast_mteom = (options & MT_ST_FAST_MTEOM) != 0;
2229 STp->do_auto_lock = (options & MT_ST_AUTO_LOCK) != 0;
2230 STp->can_bsr = (options & MT_ST_CAN_BSR) != 0;
2231 STp->omit_blklims = (options & MT_ST_NO_BLKLIMS) != 0;
2232 if ((STp->device)->scsi_level >= SCSI_2)
2233 STp->can_partitions = (options & MT_ST_CAN_PARTITIONS) != 0;
2234 STp->scsi2_logical = (options & MT_ST_SCSI2LOGICAL) != 0;
2235 STp->immediate = (options & MT_ST_NOWAIT) != 0;
2236 STp->immediate_filemark = (options & MT_ST_NOWAIT_EOF) != 0;
2237 STm->sysv = (options & MT_ST_SYSV) != 0;
2238 STp->sili = (options & MT_ST_SILI) != 0;
2239 DEB( debugging = (options & MT_ST_DEBUGGING) != 0;
2240 st_log_options(STp, STm, name); )
2241 } else if (code == MT_ST_SETBOOLEANS || code == MT_ST_CLEARBOOLEANS) {
2242 value = (code == MT_ST_SETBOOLEANS);
2243 if ((options & MT_ST_BUFFER_WRITES) != 0)
2244 STm->do_buffer_writes = value;
2245 if ((options & MT_ST_ASYNC_WRITES) != 0)
2246 STm->do_async_writes = value;
2247 if ((options & MT_ST_DEF_WRITES) != 0)
2248 STm->defaults_for_writes = value;
2249 if ((options & MT_ST_READ_AHEAD) != 0)
2250 STm->do_read_ahead = value;
2251 if ((options & MT_ST_TWO_FM) != 0)
2252 STp->two_fm = value;
2253 if ((options & MT_ST_FAST_MTEOM) != 0)
2254 STp->fast_mteom = value;
2255 if ((options & MT_ST_AUTO_LOCK) != 0)
2256 STp->do_auto_lock = value;
2257 if ((options & MT_ST_CAN_BSR) != 0)
2258 STp->can_bsr = value;
2259 if ((options & MT_ST_NO_BLKLIMS) != 0)
2260 STp->omit_blklims = value;
2261 if ((STp->device)->scsi_level >= SCSI_2 &&
2262 (options & MT_ST_CAN_PARTITIONS) != 0)
2263 STp->can_partitions = value;
2264 if ((options & MT_ST_SCSI2LOGICAL) != 0)
2265 STp->scsi2_logical = value;
2266 if ((options & MT_ST_NOWAIT) != 0)
2267 STp->immediate = value;
2268 if ((options & MT_ST_NOWAIT_EOF) != 0)
2269 STp->immediate_filemark = value;
2270 if ((options & MT_ST_SYSV) != 0)
2271 STm->sysv = value;
2272 if ((options & MT_ST_SILI) != 0)
2273 STp->sili = value;
2274 DEB(
2275 if ((options & MT_ST_DEBUGGING) != 0)
2276 debugging = value;
2277 st_log_options(STp, STm, name); )
2278 } else if (code == MT_ST_WRITE_THRESHOLD) {
2279 /* Retained for compatibility */
2280 } else if (code == MT_ST_DEF_BLKSIZE) {
2281 value = (options & ~MT_ST_OPTIONS);
2282 if (value == ~MT_ST_OPTIONS) {
2283 STm->default_blksize = (-1);
2284 DEBC( printk(KERN_INFO "%s: Default block size disabled.\n", name));
2285 } else {
2286 STm->default_blksize = value;
2287 DEBC( printk(KERN_INFO "%s: Default block size set to %d bytes.\n",
2288 name, STm->default_blksize));
2289 if (STp->ready == ST_READY) {
2290 STp->blksize_changed = 0;
2291 set_mode_densblk(STp, STm);
2292 }
2293 }
2294 } else if (code == MT_ST_TIMEOUTS) {
2295 value = (options & ~MT_ST_OPTIONS);
2296 if ((value & MT_ST_SET_LONG_TIMEOUT) != 0) {
2297 STp->long_timeout = (value & ~MT_ST_SET_LONG_TIMEOUT) * HZ;
2298 DEBC( printk(KERN_INFO "%s: Long timeout set to %d seconds.\n", name,
2299 (value & ~MT_ST_SET_LONG_TIMEOUT)));
2300 } else {
2301 blk_queue_rq_timeout(STp->device->request_queue,
2302 value * HZ);
2303 DEBC( printk(KERN_INFO "%s: Normal timeout set to %d seconds.\n",
2304 name, value) );
2305 }
2306 } else if (code == MT_ST_SET_CLN) {
2307 value = (options & ~MT_ST_OPTIONS) & 0xff;
2308 if (value != 0 &&
2309 (value < EXTENDED_SENSE_START ||
2310 value >= SCSI_SENSE_BUFFERSIZE))
2311 return (-EINVAL);
2312 STp->cln_mode = value;
2313 STp->cln_sense_mask = (options >> 8) & 0xff;
2314 STp->cln_sense_value = (options >> 16) & 0xff;
2315 printk(KERN_INFO
2316 "%s: Cleaning request mode %d, mask %02x, value %02x\n",
2317 name, value, STp->cln_sense_mask, STp->cln_sense_value);
2318 } else if (code == MT_ST_DEF_OPTIONS) {
2319 code = (options & ~MT_ST_CLEAR_DEFAULT);
2320 value = (options & MT_ST_CLEAR_DEFAULT);
2321 if (code == MT_ST_DEF_DENSITY) {
2322 if (value == MT_ST_CLEAR_DEFAULT) {
2323 STm->default_density = (-1);
2324 DEBC( printk(KERN_INFO "%s: Density default disabled.\n",
2325 name));
2326 } else {
2327 STm->default_density = value & 0xff;
2328 DEBC( printk(KERN_INFO "%s: Density default set to %x\n",
2329 name, STm->default_density));
2330 if (STp->ready == ST_READY) {
2331 STp->density_changed = 0;
2332 set_mode_densblk(STp, STm);
2333 }
2334 }
2335 } else if (code == MT_ST_DEF_DRVBUFFER) {
2336 if (value == MT_ST_CLEAR_DEFAULT) {
2337 STp->default_drvbuffer = 0xff;
2338 DEBC( printk(KERN_INFO
2339 "%s: Drive buffer default disabled.\n", name));
2340 } else {
2341 STp->default_drvbuffer = value & 7;
2342 DEBC( printk(KERN_INFO
2343 "%s: Drive buffer default set to %x\n",
2344 name, STp->default_drvbuffer));
2345 if (STp->ready == ST_READY)
2346 st_int_ioctl(STp, MTSETDRVBUFFER, STp->default_drvbuffer);
2347 }
2348 } else if (code == MT_ST_DEF_COMPRESSION) {
2349 if (value == MT_ST_CLEAR_DEFAULT) {
2350 STm->default_compression = ST_DONT_TOUCH;
2351 DEBC( printk(KERN_INFO
2352 "%s: Compression default disabled.\n", name));
2353 } else {
2354 if ((value & 0xff00) != 0) {
2355 STp->c_algo = (value & 0xff00) >> 8;
2356 DEBC( printk(KERN_INFO "%s: Compression algorithm set to 0x%x.\n",
2357 name, STp->c_algo));
2358 }
2359 if ((value & 0xff) != 0xff) {
2360 STm->default_compression = (value & 1 ? ST_YES : ST_NO);
2361 DEBC( printk(KERN_INFO "%s: Compression default set to %x\n",
2362 name, (value & 1)));
2363 if (STp->ready == ST_READY) {
2364 STp->compression_changed = 0;
2365 st_compression(STp, (STm->default_compression == ST_YES));
2366 }
2367 }
2368 }
2369 }
2370 } else
2371 return (-EIO);
2372
2373 return 0;
2374 }
2375 \f
2376 #define MODE_HEADER_LENGTH 4
2377
2378 /* Mode header and page byte offsets */
2379 #define MH_OFF_DATA_LENGTH 0
2380 #define MH_OFF_MEDIUM_TYPE 1
2381 #define MH_OFF_DEV_SPECIFIC 2
2382 #define MH_OFF_BDESCS_LENGTH 3
2383 #define MP_OFF_PAGE_NBR 0
2384 #define MP_OFF_PAGE_LENGTH 1
2385
2386 /* Mode header and page bit masks */
2387 #define MH_BIT_WP 0x80
2388 #define MP_MSK_PAGE_NBR 0x3f
2389
2390 /* Don't return block descriptors */
2391 #define MODE_SENSE_OMIT_BDESCS 0x08
2392
2393 #define MODE_SELECT_PAGE_FORMAT 0x10
2394
2395 /* Read a mode page into the tape buffer. The block descriptors are included
2396 if incl_block_descs is true. The page control is ored to the page number
2397 parameter, if necessary. */
2398 static int read_mode_page(struct scsi_tape *STp, int page, int omit_block_descs)
2399 {
2400 unsigned char cmd[MAX_COMMAND_SIZE];
2401 struct st_request *SRpnt;
2402
2403 memset(cmd, 0, MAX_COMMAND_SIZE);
2404 cmd[0] = MODE_SENSE;
2405 if (omit_block_descs)
2406 cmd[1] = MODE_SENSE_OMIT_BDESCS;
2407 cmd[2] = page;
2408 cmd[4] = 255;
2409
2410 SRpnt = st_do_scsi(NULL, STp, cmd, cmd[4], DMA_FROM_DEVICE,
2411 STp->device->request_queue->rq_timeout, 0, 1);
2412 if (SRpnt == NULL)
2413 return (STp->buffer)->syscall_result;
2414
2415 st_release_request(SRpnt);
2416
2417 return STp->buffer->syscall_result;
2418 }
2419
2420
2421 /* Send the mode page in the tape buffer to the drive. Assumes that the mode data
2422 in the buffer is correctly formatted. The long timeout is used if slow is non-zero. */
2423 static int write_mode_page(struct scsi_tape *STp, int page, int slow)
2424 {
2425 int pgo;
2426 unsigned char cmd[MAX_COMMAND_SIZE];
2427 struct st_request *SRpnt;
2428 int timeout;
2429
2430 memset(cmd, 0, MAX_COMMAND_SIZE);
2431 cmd[0] = MODE_SELECT;
2432 cmd[1] = MODE_SELECT_PAGE_FORMAT;
2433 pgo = MODE_HEADER_LENGTH + (STp->buffer)->b_data[MH_OFF_BDESCS_LENGTH];
2434 cmd[4] = pgo + (STp->buffer)->b_data[pgo + MP_OFF_PAGE_LENGTH] + 2;
2435
2436 /* Clear reserved fields */
2437 (STp->buffer)->b_data[MH_OFF_DATA_LENGTH] = 0;
2438 (STp->buffer)->b_data[MH_OFF_MEDIUM_TYPE] = 0;
2439 (STp->buffer)->b_data[MH_OFF_DEV_SPECIFIC] &= ~MH_BIT_WP;
2440 (STp->buffer)->b_data[pgo + MP_OFF_PAGE_NBR] &= MP_MSK_PAGE_NBR;
2441
2442 timeout = slow ?
2443 STp->long_timeout : STp->device->request_queue->rq_timeout;
2444 SRpnt = st_do_scsi(NULL, STp, cmd, cmd[4], DMA_TO_DEVICE,
2445 timeout, 0, 1);
2446 if (SRpnt == NULL)
2447 return (STp->buffer)->syscall_result;
2448
2449 st_release_request(SRpnt);
2450
2451 return STp->buffer->syscall_result;
2452 }
2453
2454
2455 #define COMPRESSION_PAGE 0x0f
2456 #define COMPRESSION_PAGE_LENGTH 16
2457
2458 #define CP_OFF_DCE_DCC 2
2459 #define CP_OFF_C_ALGO 7
2460
2461 #define DCE_MASK 0x80
2462 #define DCC_MASK 0x40
2463 #define RED_MASK 0x60
2464
2465
2466 /* Control the compression with mode page 15. Algorithm not changed if zero.
2467
2468 The block descriptors are read and written because Sony SDT-7000 does not
2469 work without this (suggestion from Michael Schaefer <Michael.Schaefer@dlr.de>).
2470 Including block descriptors should not cause any harm to other drives. */
2471
2472 static int st_compression(struct scsi_tape * STp, int state)
2473 {
2474 int retval;
2475 int mpoffs; /* Offset to mode page start */
2476 unsigned char *b_data = (STp->buffer)->b_data;
2477 DEB( char *name = tape_name(STp); )
2478
2479 if (STp->ready != ST_READY)
2480 return (-EIO);
2481
2482 /* Read the current page contents */
2483 retval = read_mode_page(STp, COMPRESSION_PAGE, 0);
2484 if (retval) {
2485 DEBC(printk(ST_DEB_MSG "%s: Compression mode page not supported.\n",
2486 name));
2487 return (-EIO);
2488 }
2489
2490 mpoffs = MODE_HEADER_LENGTH + b_data[MH_OFF_BDESCS_LENGTH];
2491 DEBC(printk(ST_DEB_MSG "%s: Compression state is %d.\n", name,
2492 (b_data[mpoffs + CP_OFF_DCE_DCC] & DCE_MASK ? 1 : 0)));
2493
2494 /* Check if compression can be changed */
2495 if ((b_data[mpoffs + CP_OFF_DCE_DCC] & DCC_MASK) == 0) {
2496 DEBC(printk(ST_DEB_MSG "%s: Compression not supported.\n", name));
2497 return (-EIO);
2498 }
2499
2500 /* Do the change */
2501 if (state) {
2502 b_data[mpoffs + CP_OFF_DCE_DCC] |= DCE_MASK;
2503 if (STp->c_algo != 0)
2504 b_data[mpoffs + CP_OFF_C_ALGO] = STp->c_algo;
2505 }
2506 else {
2507 b_data[mpoffs + CP_OFF_DCE_DCC] &= ~DCE_MASK;
2508 if (STp->c_algo != 0)
2509 b_data[mpoffs + CP_OFF_C_ALGO] = 0; /* no compression */
2510 }
2511
2512 retval = write_mode_page(STp, COMPRESSION_PAGE, 0);
2513 if (retval) {
2514 DEBC(printk(ST_DEB_MSG "%s: Compression change failed.\n", name));
2515 return (-EIO);
2516 }
2517 DEBC(printk(ST_DEB_MSG "%s: Compression state changed to %d.\n",
2518 name, state));
2519
2520 STp->compression_changed = 1;
2521 return 0;
2522 }
2523
2524
2525 /* Process the load and unload commands (does unload if the load code is zero) */
2526 static int do_load_unload(struct scsi_tape *STp, struct file *filp, int load_code)
2527 {
2528 int retval = (-EIO), timeout;
2529 DEB( char *name = tape_name(STp); )
2530 unsigned char cmd[MAX_COMMAND_SIZE];
2531 struct st_partstat *STps;
2532 struct st_request *SRpnt;
2533
2534 if (STp->ready != ST_READY && !load_code) {
2535 if (STp->ready == ST_NO_TAPE)
2536 return (-ENOMEDIUM);
2537 else
2538 return (-EIO);
2539 }
2540
2541 memset(cmd, 0, MAX_COMMAND_SIZE);
2542 cmd[0] = START_STOP;
2543 if (load_code)
2544 cmd[4] |= 1;
2545 /*
2546 * If arg >= 1 && arg <= 6 Enhanced load/unload in HP C1553A
2547 */
2548 if (load_code >= 1 + MT_ST_HPLOADER_OFFSET
2549 && load_code <= 6 + MT_ST_HPLOADER_OFFSET) {
2550 DEBC(printk(ST_DEB_MSG "%s: Enhanced %sload slot %2d.\n",
2551 name, (cmd[4]) ? "" : "un",
2552 load_code - MT_ST_HPLOADER_OFFSET));
2553 cmd[3] = load_code - MT_ST_HPLOADER_OFFSET; /* MediaID field of C1553A */
2554 }
2555 if (STp->immediate) {
2556 cmd[1] = 1; /* Don't wait for completion */
2557 timeout = STp->device->request_queue->rq_timeout;
2558 }
2559 else
2560 timeout = STp->long_timeout;
2561
2562 DEBC(
2563 if (!load_code)
2564 printk(ST_DEB_MSG "%s: Unloading tape.\n", name);
2565 else
2566 printk(ST_DEB_MSG "%s: Loading tape.\n", name);
2567 );
2568
2569 SRpnt = st_do_scsi(NULL, STp, cmd, 0, DMA_NONE,
2570 timeout, MAX_RETRIES, 1);
2571 if (!SRpnt)
2572 return (STp->buffer)->syscall_result;
2573
2574 retval = (STp->buffer)->syscall_result;
2575 st_release_request(SRpnt);
2576
2577 if (!retval) { /* SCSI command successful */
2578
2579 if (!load_code) {
2580 STp->rew_at_close = 0;
2581 STp->ready = ST_NO_TAPE;
2582 }
2583 else {
2584 STp->rew_at_close = STp->autorew_dev;
2585 retval = check_tape(STp, filp);
2586 if (retval > 0)
2587 retval = 0;
2588 }
2589 }
2590 else {
2591 STps = &(STp->ps[STp->partition]);
2592 STps->drv_file = STps->drv_block = (-1);
2593 }
2594
2595 return retval;
2596 }
2597 \f
2598 #if DEBUG
2599 #define ST_DEB_FORWARD 0
2600 #define ST_DEB_BACKWARD 1
2601 static void deb_space_print(char *name, int direction, char *units, unsigned char *cmd)
2602 {
2603 s32 sc;
2604
2605 sc = cmd[2] & 0x80 ? 0xff000000 : 0;
2606 sc |= (cmd[2] << 16) | (cmd[3] << 8) | cmd[4];
2607 if (direction)
2608 sc = -sc;
2609 printk(ST_DEB_MSG "%s: Spacing tape %s over %d %s.\n", name,
2610 direction ? "backward" : "forward", sc, units);
2611 }
2612 #endif
2613
2614
2615 /* Internal ioctl function */
2616 static int st_int_ioctl(struct scsi_tape *STp, unsigned int cmd_in, unsigned long arg)
2617 {
2618 int timeout;
2619 long ltmp;
2620 int ioctl_result;
2621 int chg_eof = 1;
2622 unsigned char cmd[MAX_COMMAND_SIZE];
2623 struct st_request *SRpnt;
2624 struct st_partstat *STps;
2625 int fileno, blkno, at_sm, undone;
2626 int datalen = 0, direction = DMA_NONE;
2627 char *name = tape_name(STp);
2628
2629 WARN_ON(STp->buffer->do_dio != 0);
2630 if (STp->ready != ST_READY) {
2631 if (STp->ready == ST_NO_TAPE)
2632 return (-ENOMEDIUM);
2633 else
2634 return (-EIO);
2635 }
2636 timeout = STp->long_timeout;
2637 STps = &(STp->ps[STp->partition]);
2638 fileno = STps->drv_file;
2639 blkno = STps->drv_block;
2640 at_sm = STps->at_sm;
2641
2642 memset(cmd, 0, MAX_COMMAND_SIZE);
2643 switch (cmd_in) {
2644 case MTFSFM:
2645 chg_eof = 0; /* Changed from the FSF after this */
2646 case MTFSF:
2647 cmd[0] = SPACE;
2648 cmd[1] = 0x01; /* Space FileMarks */
2649 cmd[2] = (arg >> 16);
2650 cmd[3] = (arg >> 8);
2651 cmd[4] = arg;
2652 DEBC(deb_space_print(name, ST_DEB_FORWARD, "filemarks", cmd);)
2653 if (fileno >= 0)
2654 fileno += arg;
2655 blkno = 0;
2656 at_sm &= (arg == 0);
2657 break;
2658 case MTBSFM:
2659 chg_eof = 0; /* Changed from the FSF after this */
2660 case MTBSF:
2661 cmd[0] = SPACE;
2662 cmd[1] = 0x01; /* Space FileMarks */
2663 ltmp = (-arg);
2664 cmd[2] = (ltmp >> 16);
2665 cmd[3] = (ltmp >> 8);
2666 cmd[4] = ltmp;
2667 DEBC(deb_space_print(name, ST_DEB_BACKWARD, "filemarks", cmd);)
2668 if (fileno >= 0)
2669 fileno -= arg;
2670 blkno = (-1); /* We can't know the block number */
2671 at_sm &= (arg == 0);
2672 break;
2673 case MTFSR:
2674 cmd[0] = SPACE;
2675 cmd[1] = 0x00; /* Space Blocks */
2676 cmd[2] = (arg >> 16);
2677 cmd[3] = (arg >> 8);
2678 cmd[4] = arg;
2679 DEBC(deb_space_print(name, ST_DEB_FORWARD, "blocks", cmd);)
2680 if (blkno >= 0)
2681 blkno += arg;
2682 at_sm &= (arg == 0);
2683 break;
2684 case MTBSR:
2685 cmd[0] = SPACE;
2686 cmd[1] = 0x00; /* Space Blocks */
2687 ltmp = (-arg);
2688 cmd[2] = (ltmp >> 16);
2689 cmd[3] = (ltmp >> 8);
2690 cmd[4] = ltmp;
2691 DEBC(deb_space_print(name, ST_DEB_BACKWARD, "blocks", cmd);)
2692 if (blkno >= 0)
2693 blkno -= arg;
2694 at_sm &= (arg == 0);
2695 break;
2696 case MTFSS:
2697 cmd[0] = SPACE;
2698 cmd[1] = 0x04; /* Space Setmarks */
2699 cmd[2] = (arg >> 16);
2700 cmd[3] = (arg >> 8);
2701 cmd[4] = arg;
2702 DEBC(deb_space_print(name, ST_DEB_FORWARD, "setmarks", cmd);)
2703 if (arg != 0) {
2704 blkno = fileno = (-1);
2705 at_sm = 1;
2706 }
2707 break;
2708 case MTBSS:
2709 cmd[0] = SPACE;
2710 cmd[1] = 0x04; /* Space Setmarks */
2711 ltmp = (-arg);
2712 cmd[2] = (ltmp >> 16);
2713 cmd[3] = (ltmp >> 8);
2714 cmd[4] = ltmp;
2715 DEBC(deb_space_print(name, ST_DEB_BACKWARD, "setmarks", cmd);)
2716 if (arg != 0) {
2717 blkno = fileno = (-1);
2718 at_sm = 1;
2719 }
2720 break;
2721 case MTWEOF:
2722 case MTWEOFI:
2723 case MTWSM:
2724 if (STp->write_prot)
2725 return (-EACCES);
2726 cmd[0] = WRITE_FILEMARKS;
2727 if (cmd_in == MTWSM)
2728 cmd[1] = 2;
2729 if (cmd_in == MTWEOFI ||
2730 (cmd_in == MTWEOF && STp->immediate_filemark))
2731 cmd[1] |= 1;
2732 cmd[2] = (arg >> 16);
2733 cmd[3] = (arg >> 8);
2734 cmd[4] = arg;
2735 timeout = STp->device->request_queue->rq_timeout;
2736 DEBC(
2737 if (cmd_in != MTWSM)
2738 printk(ST_DEB_MSG "%s: Writing %d filemarks.\n", name,
2739 cmd[2] * 65536 + cmd[3] * 256 + cmd[4]);
2740 else
2741 printk(ST_DEB_MSG "%s: Writing %d setmarks.\n", name,
2742 cmd[2] * 65536 + cmd[3] * 256 + cmd[4]);
2743 )
2744 if (fileno >= 0)
2745 fileno += arg;
2746 blkno = 0;
2747 at_sm = (cmd_in == MTWSM);
2748 break;
2749 case MTREW:
2750 cmd[0] = REZERO_UNIT;
2751 if (STp->immediate) {
2752 cmd[1] = 1; /* Don't wait for completion */
2753 timeout = STp->device->request_queue->rq_timeout;
2754 }
2755 DEBC(printk(ST_DEB_MSG "%s: Rewinding tape.\n", name));
2756 fileno = blkno = at_sm = 0;
2757 break;
2758 case MTNOP:
2759 DEBC(printk(ST_DEB_MSG "%s: No op on tape.\n", name));
2760 return 0; /* Should do something ? */
2761 break;
2762 case MTRETEN:
2763 cmd[0] = START_STOP;
2764 if (STp->immediate) {
2765 cmd[1] = 1; /* Don't wait for completion */
2766 timeout = STp->device->request_queue->rq_timeout;
2767 }
2768 cmd[4] = 3;
2769 DEBC(printk(ST_DEB_MSG "%s: Retensioning tape.\n", name));
2770 fileno = blkno = at_sm = 0;
2771 break;
2772 case MTEOM:
2773 if (!STp->fast_mteom) {
2774 /* space to the end of tape */
2775 ioctl_result = st_int_ioctl(STp, MTFSF, 0x7fffff);
2776 fileno = STps->drv_file;
2777 if (STps->eof >= ST_EOD_1)
2778 return 0;
2779 /* The next lines would hide the number of spaced FileMarks
2780 That's why I inserted the previous lines. I had no luck
2781 with detecting EOM with FSF, so we go now to EOM.
2782 Joerg Weule */
2783 } else
2784 fileno = (-1);
2785 cmd[0] = SPACE;
2786 cmd[1] = 3;
2787 DEBC(printk(ST_DEB_MSG "%s: Spacing to end of recorded medium.\n",
2788 name));
2789 blkno = -1;
2790 at_sm = 0;
2791 break;
2792 case MTERASE:
2793 if (STp->write_prot)
2794 return (-EACCES);
2795 cmd[0] = ERASE;
2796 cmd[1] = (arg ? 1 : 0); /* Long erase with non-zero argument */
2797 if (STp->immediate) {
2798 cmd[1] |= 2; /* Don't wait for completion */
2799 timeout = STp->device->request_queue->rq_timeout;
2800 }
2801 else
2802 timeout = STp->long_timeout * 8;
2803
2804 DEBC(printk(ST_DEB_MSG "%s: Erasing tape.\n", name));
2805 fileno = blkno = at_sm = 0;
2806 break;
2807 case MTSETBLK: /* Set block length */
2808 case MTSETDENSITY: /* Set tape density */
2809 case MTSETDRVBUFFER: /* Set drive buffering */
2810 case SET_DENS_AND_BLK: /* Set density and block size */
2811 chg_eof = 0;
2812 if (STp->dirty || (STp->buffer)->buffer_bytes != 0)
2813 return (-EIO); /* Not allowed if data in buffer */
2814 if ((cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) &&
2815 (arg & MT_ST_BLKSIZE_MASK) != 0 &&
2816 STp->max_block > 0 &&
2817 ((arg & MT_ST_BLKSIZE_MASK) < STp->min_block ||
2818 (arg & MT_ST_BLKSIZE_MASK) > STp->max_block)) {
2819 printk(KERN_WARNING "%s: Illegal block size.\n", name);
2820 return (-EINVAL);
2821 }
2822 cmd[0] = MODE_SELECT;
2823 if ((STp->use_pf & USE_PF))
2824 cmd[1] = MODE_SELECT_PAGE_FORMAT;
2825 cmd[4] = datalen = 12;
2826 direction = DMA_TO_DEVICE;
2827
2828 memset((STp->buffer)->b_data, 0, 12);
2829 if (cmd_in == MTSETDRVBUFFER)
2830 (STp->buffer)->b_data[2] = (arg & 7) << 4;
2831 else
2832 (STp->buffer)->b_data[2] =
2833 STp->drv_buffer << 4;
2834 (STp->buffer)->b_data[3] = 8; /* block descriptor length */
2835 if (cmd_in == MTSETDENSITY) {
2836 (STp->buffer)->b_data[4] = arg;
2837 STp->density_changed = 1; /* At least we tried ;-) */
2838 } else if (cmd_in == SET_DENS_AND_BLK)
2839 (STp->buffer)->b_data[4] = arg >> 24;
2840 else
2841 (STp->buffer)->b_data[4] = STp->density;
2842 if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) {
2843 ltmp = arg & MT_ST_BLKSIZE_MASK;
2844 if (cmd_in == MTSETBLK)
2845 STp->blksize_changed = 1; /* At least we tried ;-) */
2846 } else
2847 ltmp = STp->block_size;
2848 (STp->buffer)->b_data[9] = (ltmp >> 16);
2849 (STp->buffer)->b_data[10] = (ltmp >> 8);
2850 (STp->buffer)->b_data[11] = ltmp;
2851 timeout = STp->device->request_queue->rq_timeout;
2852 DEBC(
2853 if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK)
2854 printk(ST_DEB_MSG
2855 "%s: Setting block size to %d bytes.\n", name,
2856 (STp->buffer)->b_data[9] * 65536 +
2857 (STp->buffer)->b_data[10] * 256 +
2858 (STp->buffer)->b_data[11]);
2859 if (cmd_in == MTSETDENSITY || cmd_in == SET_DENS_AND_BLK)
2860 printk(ST_DEB_MSG
2861 "%s: Setting density code to %x.\n", name,
2862 (STp->buffer)->b_data[4]);
2863 if (cmd_in == MTSETDRVBUFFER)
2864 printk(ST_DEB_MSG
2865 "%s: Setting drive buffer code to %d.\n", name,
2866 ((STp->buffer)->b_data[2] >> 4) & 7);
2867 )
2868 break;
2869 default:
2870 return (-ENOSYS);
2871 }
2872
2873 SRpnt = st_do_scsi(NULL, STp, cmd, datalen, direction,
2874 timeout, MAX_RETRIES, 1);
2875 if (!SRpnt)
2876 return (STp->buffer)->syscall_result;
2877
2878 ioctl_result = (STp->buffer)->syscall_result;
2879
2880 if (!ioctl_result) { /* SCSI command successful */
2881 st_release_request(SRpnt);
2882 SRpnt = NULL;
2883 STps->drv_block = blkno;
2884 STps->drv_file = fileno;
2885 STps->at_sm = at_sm;
2886
2887 if (cmd_in == MTBSFM)
2888 ioctl_result = st_int_ioctl(STp, MTFSF, 1);
2889 else if (cmd_in == MTFSFM)
2890 ioctl_result = st_int_ioctl(STp, MTBSF, 1);
2891
2892 if (cmd_in == MTSETBLK || cmd_in == SET_DENS_AND_BLK) {
2893 STp->block_size = arg & MT_ST_BLKSIZE_MASK;
2894 if (STp->block_size != 0) {
2895 (STp->buffer)->buffer_blocks =
2896 (STp->buffer)->buffer_size / STp->block_size;
2897 }
2898 (STp->buffer)->buffer_bytes = (STp->buffer)->read_pointer = 0;
2899 if (cmd_in == SET_DENS_AND_BLK)
2900 STp->density = arg >> MT_ST_DENSITY_SHIFT;
2901 } else if (cmd_in == MTSETDRVBUFFER)
2902 STp->drv_buffer = (arg & 7);
2903 else if (cmd_in == MTSETDENSITY)
2904 STp->density = arg;
2905
2906 if (cmd_in == MTEOM)
2907 STps->eof = ST_EOD;
2908 else if (cmd_in == MTFSF)
2909 STps->eof = ST_FM;
2910 else if (chg_eof)
2911 STps->eof = ST_NOEOF;
2912
2913 if (cmd_in == MTWEOF || cmd_in == MTWEOFI)
2914 STps->rw = ST_IDLE; /* prevent automatic WEOF at close */
2915 } else { /* SCSI command was not completely successful. Don't return
2916 from this block without releasing the SCSI command block! */
2917 struct st_cmdstatus *cmdstatp = &STp->buffer->cmdstat;
2918
2919 if (cmdstatp->flags & SENSE_EOM) {
2920 if (cmd_in != MTBSF && cmd_in != MTBSFM &&
2921 cmd_in != MTBSR && cmd_in != MTBSS)
2922 STps->eof = ST_EOM_OK;
2923 STps->drv_block = 0;
2924 }
2925
2926 if (cmdstatp->remainder_valid)
2927 undone = (int)cmdstatp->uremainder64;
2928 else
2929 undone = 0;
2930
2931 if ((cmd_in == MTWEOF || cmd_in == MTWEOFI) &&
2932 cmdstatp->have_sense &&
2933 (cmdstatp->flags & SENSE_EOM)) {
2934 if (cmdstatp->sense_hdr.sense_key == NO_SENSE ||
2935 cmdstatp->sense_hdr.sense_key == RECOVERED_ERROR) {
2936 ioctl_result = 0; /* EOF(s) written successfully at EOM */
2937 STps->eof = ST_NOEOF;
2938 } else { /* Writing EOF(s) failed */
2939 if (fileno >= 0)
2940 fileno -= undone;
2941 if (undone < arg)
2942 STps->eof = ST_NOEOF;
2943 }
2944 STps->drv_file = fileno;
2945 } else if ((cmd_in == MTFSF) || (cmd_in == MTFSFM)) {
2946 if (fileno >= 0)
2947 STps->drv_file = fileno - undone;
2948 else
2949 STps->drv_file = fileno;
2950 STps->drv_block = -1;
2951 STps->eof = ST_NOEOF;
2952 } else if ((cmd_in == MTBSF) || (cmd_in == MTBSFM)) {
2953 if (arg > 0 && undone < 0) /* Some drives get this wrong */
2954 undone = (-undone);
2955 if (STps->drv_file >= 0)
2956 STps->drv_file = fileno + undone;
2957 STps->drv_block = 0;
2958 STps->eof = ST_NOEOF;
2959 } else if (cmd_in == MTFSR) {
2960 if (cmdstatp->flags & SENSE_FMK) { /* Hit filemark */
2961 if (STps->drv_file >= 0)
2962 STps->drv_file++;
2963 STps->drv_block = 0;
2964 STps->eof = ST_FM;
2965 } else {
2966 if (blkno >= undone)
2967 STps->drv_block = blkno - undone;
2968 else
2969 STps->drv_block = (-1);
2970 STps->eof = ST_NOEOF;
2971 }
2972 } else if (cmd_in == MTBSR) {
2973 if (cmdstatp->flags & SENSE_FMK) { /* Hit filemark */
2974 STps->drv_file--;
2975 STps->drv_block = (-1);
2976 } else {
2977 if (arg > 0 && undone < 0) /* Some drives get this wrong */
2978 undone = (-undone);
2979 if (STps->drv_block >= 0)
2980 STps->drv_block = blkno + undone;
2981 }
2982 STps->eof = ST_NOEOF;
2983 } else if (cmd_in == MTEOM) {
2984 STps->drv_file = (-1);
2985 STps->drv_block = (-1);
2986 STps->eof = ST_EOD;
2987 } else if (cmd_in == MTSETBLK ||
2988 cmd_in == MTSETDENSITY ||
2989 cmd_in == MTSETDRVBUFFER ||
2990 cmd_in == SET_DENS_AND_BLK) {
2991 if (cmdstatp->sense_hdr.sense_key == ILLEGAL_REQUEST &&
2992 !(STp->use_pf & PF_TESTED)) {
2993 /* Try the other possible state of Page Format if not
2994 already tried */
2995 STp->use_pf = (STp->use_pf ^ USE_PF) | PF_TESTED;
2996 st_release_request(SRpnt);
2997 SRpnt = NULL;
2998 return st_int_ioctl(STp, cmd_in, arg);
2999 }
3000 } else if (chg_eof)
3001 STps->eof = ST_NOEOF;
3002
3003 if (cmdstatp->sense_hdr.sense_key == BLANK_CHECK)
3004 STps->eof = ST_EOD;
3005
3006 st_release_request(SRpnt);
3007 SRpnt = NULL;
3008 }
3009
3010 return ioctl_result;
3011 }
3012 \f
3013
3014 /* Get the tape position. If bt == 2, arg points into a kernel space mt_loc
3015 structure. */
3016
3017 static int get_location(struct scsi_tape *STp, unsigned int *block, int *partition,
3018 int logical)
3019 {
3020 int result;
3021 unsigned char scmd[MAX_COMMAND_SIZE];
3022 struct st_request *SRpnt;
3023 DEB( char *name = tape_name(STp); )
3024
3025 if (STp->ready != ST_READY)
3026 return (-EIO);
3027
3028 memset(scmd, 0, MAX_COMMAND_SIZE);
3029 if ((STp->device)->scsi_level < SCSI_2) {
3030 scmd[0] = QFA_REQUEST_BLOCK;
3031 scmd[4] = 3;
3032 } else {
3033 scmd[0] = READ_POSITION;
3034 if (!logical && !STp->scsi2_logical)
3035 scmd[1] = 1;
3036 }
3037 SRpnt = st_do_scsi(NULL, STp, scmd, 20, DMA_FROM_DEVICE,
3038 STp->device->request_queue->rq_timeout,
3039 MAX_READY_RETRIES, 1);
3040 if (!SRpnt)
3041 return (STp->buffer)->syscall_result;
3042
3043 if ((STp->buffer)->syscall_result != 0 ||
3044 (STp->device->scsi_level >= SCSI_2 &&
3045 ((STp->buffer)->b_data[0] & 4) != 0)) {
3046 *block = *partition = 0;
3047 DEBC(printk(ST_DEB_MSG "%s: Can't read tape position.\n", name));
3048 result = (-EIO);
3049 } else {
3050 result = 0;
3051 if ((STp->device)->scsi_level < SCSI_2) {
3052 *block = ((STp->buffer)->b_data[0] << 16)
3053 + ((STp->buffer)->b_data[1] << 8)
3054 + (STp->buffer)->b_data[2];
3055 *partition = 0;
3056 } else {
3057 *block = ((STp->buffer)->b_data[4] << 24)
3058 + ((STp->buffer)->b_data[5] << 16)
3059 + ((STp->buffer)->b_data[6] << 8)
3060 + (STp->buffer)->b_data[7];
3061 *partition = (STp->buffer)->b_data[1];
3062 if (((STp->buffer)->b_data[0] & 0x80) &&
3063 (STp->buffer)->b_data[1] == 0) /* BOP of partition 0 */
3064 STp->ps[0].drv_block = STp->ps[0].drv_file = 0;
3065 }
3066 DEBC(printk(ST_DEB_MSG "%s: Got tape pos. blk %d part %d.\n", name,
3067 *block, *partition));
3068 }
3069 st_release_request(SRpnt);
3070 SRpnt = NULL;
3071
3072 return result;
3073 }
3074
3075
3076 /* Set the tape block and partition. Negative partition means that only the
3077 block should be set in vendor specific way. */
3078 static int set_location(struct scsi_tape *STp, unsigned int block, int partition,
3079 int logical)
3080 {
3081 struct st_partstat *STps;
3082 int result, p;
3083 unsigned int blk;
3084 int timeout;
3085 unsigned char scmd[MAX_COMMAND_SIZE];
3086 struct st_request *SRpnt;
3087 DEB( char *name = tape_name(STp); )
3088
3089 if (STp->ready != ST_READY)
3090 return (-EIO);
3091 timeout = STp->long_timeout;
3092 STps = &(STp->ps[STp->partition]);
3093
3094 DEBC(printk(ST_DEB_MSG "%s: Setting block to %d and partition to %d.\n",
3095 name, block, partition));
3096 DEB(if (partition < 0)
3097 return (-EIO); )
3098
3099 /* Update the location at the partition we are leaving */
3100 if ((!STp->can_partitions && partition != 0) ||
3101 partition >= ST_NBR_PARTITIONS)
3102 return (-EINVAL);
3103 if (partition != STp->partition) {
3104 if (get_location(STp, &blk, &p, 1))
3105 STps->last_block_valid = 0;
3106 else {
3107 STps->last_block_valid = 1;
3108 STps->last_block_visited = blk;
3109 DEBC(printk(ST_DEB_MSG
3110 "%s: Visited block %d for partition %d saved.\n",
3111 name, blk, STp->partition));
3112 }
3113 }
3114
3115 memset(scmd, 0, MAX_COMMAND_SIZE);
3116 if ((STp->device)->scsi_level < SCSI_2) {
3117 scmd[0] = QFA_SEEK_BLOCK;
3118 scmd[2] = (block >> 16);
3119 scmd[3] = (block >> 8);
3120 scmd[4] = block;
3121 scmd[5] = 0;
3122 } else {
3123 scmd[0] = SEEK_10;
3124 scmd[3] = (block >> 24);
3125 scmd[4] = (block >> 16);
3126 scmd[5] = (block >> 8);
3127 scmd[6] = block;
3128 if (!logical && !STp->scsi2_logical)
3129 scmd[1] = 4;
3130 if (STp->partition != partition) {
3131 scmd[1] |= 2;
3132 scmd[8] = partition;
3133 DEBC(printk(ST_DEB_MSG
3134 "%s: Trying to change partition from %d to %d\n",
3135 name, STp->partition, partition));
3136 }
3137 }
3138 if (STp->immediate) {
3139 scmd[1] |= 1; /* Don't wait for completion */
3140 timeout = STp->device->request_queue->rq_timeout;
3141 }
3142
3143 SRpnt = st_do_scsi(NULL, STp, scmd, 0, DMA_NONE,
3144 timeout, MAX_READY_RETRIES, 1);
3145 if (!SRpnt)
3146 return (STp->buffer)->syscall_result;
3147
3148 STps->drv_block = STps->drv_file = (-1);
3149 STps->eof = ST_NOEOF;
3150 if ((STp->buffer)->syscall_result != 0) {
3151 result = (-EIO);
3152 if (STp->can_partitions &&
3153 (STp->device)->scsi_level >= SCSI_2 &&
3154 (p = find_partition(STp)) >= 0)
3155 STp->partition = p;
3156 } else {
3157 if (STp->can_partitions) {
3158 STp->partition = partition;
3159 STps = &(STp->ps[partition]);
3160 if (!STps->last_block_valid ||
3161 STps->last_block_visited != block) {
3162 STps->at_sm = 0;
3163 STps->rw = ST_IDLE;
3164 }
3165 } else
3166 STps->at_sm = 0;
3167 if (block == 0)
3168 STps->drv_block = STps->drv_file = 0;
3169 result = 0;
3170 }
3171
3172 st_release_request(SRpnt);
3173 SRpnt = NULL;
3174
3175 return result;
3176 }
3177
3178
3179 /* Find the current partition number for the drive status. Called from open and
3180 returns either partition number of negative error code. */
3181 static int find_partition(struct scsi_tape *STp)
3182 {
3183 int i, partition;
3184 unsigned int block;
3185
3186 if ((i = get_location(STp, &block, &partition, 1)) < 0)
3187 return i;
3188 if (partition >= ST_NBR_PARTITIONS)
3189 return (-EIO);
3190 return partition;
3191 }
3192
3193
3194 /* Change the partition if necessary */
3195 static int switch_partition(struct scsi_tape *STp)
3196 {
3197 struct st_partstat *STps;
3198
3199 if (STp->partition == STp->new_partition)
3200 return 0;
3201 STps = &(STp->ps[STp->new_partition]);
3202 if (!STps->last_block_valid)
3203 STps->last_block_visited = 0;
3204 return set_location(STp, STps->last_block_visited, STp->new_partition, 1);
3205 }
3206 \f
3207 /* Functions for reading and writing the medium partition mode page. */
3208
3209 #define PART_PAGE 0x11
3210 #define PART_PAGE_FIXED_LENGTH 8
3211
3212 #define PP_OFF_MAX_ADD_PARTS 2
3213 #define PP_OFF_NBR_ADD_PARTS 3
3214 #define PP_OFF_FLAGS 4
3215 #define PP_OFF_PART_UNITS 6
3216 #define PP_OFF_RESERVED 7
3217
3218 #define PP_BIT_IDP 0x20
3219 #define PP_MSK_PSUM_MB 0x10
3220
3221 /* Get the number of partitions on the tape. As a side effect reads the
3222 mode page into the tape buffer. */
3223 static int nbr_partitions(struct scsi_tape *STp)
3224 {
3225 int result;
3226 DEB( char *name = tape_name(STp); )
3227
3228 if (STp->ready != ST_READY)
3229 return (-EIO);
3230
3231 result = read_mode_page(STp, PART_PAGE, 1);
3232
3233 if (result) {
3234 DEBC(printk(ST_DEB_MSG "%s: Can't read medium partition page.\n",
3235 name));
3236 result = (-EIO);
3237 } else {
3238 result = (STp->buffer)->b_data[MODE_HEADER_LENGTH +
3239 PP_OFF_NBR_ADD_PARTS] + 1;
3240 DEBC(printk(ST_DEB_MSG "%s: Number of partitions %d.\n", name, result));
3241 }
3242
3243 return result;
3244 }
3245
3246
3247 /* Partition the tape into two partitions if size > 0 or one partition if
3248 size == 0.
3249
3250 The block descriptors are read and written because Sony SDT-7000 does not
3251 work without this (suggestion from Michael Schaefer <Michael.Schaefer@dlr.de>).
3252
3253 My HP C1533A drive returns only one partition size field. This is used to
3254 set the size of partition 1. There is no size field for the default partition.
3255 Michael Schaefer's Sony SDT-7000 returns two descriptors and the second is
3256 used to set the size of partition 1 (this is what the SCSI-3 standard specifies).
3257 The following algorithm is used to accommodate both drives: if the number of
3258 partition size fields is greater than the maximum number of additional partitions
3259 in the mode page, the second field is used. Otherwise the first field is used.
3260
3261 For Seagate DDS drives the page length must be 8 when no partitions is defined
3262 and 10 when 1 partition is defined (information from Eric Lee Green). This is
3263 is acceptable also to some other old drives and enforced if the first partition
3264 size field is used for the first additional partition size.
3265 */
3266 static int partition_tape(struct scsi_tape *STp, int size)
3267 {
3268 char *name = tape_name(STp);
3269 int result;
3270 int pgo, psd_cnt, psdo;
3271 unsigned char *bp;
3272
3273 result = read_mode_page(STp, PART_PAGE, 0);
3274 if (result) {
3275 DEBC(printk(ST_DEB_MSG "%s: Can't read partition mode page.\n", name));
3276 return result;
3277 }
3278 /* The mode page is in the buffer. Let's modify it and write it. */
3279 bp = (STp->buffer)->b_data;
3280 pgo = MODE_HEADER_LENGTH + bp[MH_OFF_BDESCS_LENGTH];
3281 DEBC(printk(ST_DEB_MSG "%s: Partition page length is %d bytes.\n",
3282 name, bp[pgo + MP_OFF_PAGE_LENGTH] + 2));
3283
3284 psd_cnt = (bp[pgo + MP_OFF_PAGE_LENGTH] + 2 - PART_PAGE_FIXED_LENGTH) / 2;
3285 psdo = pgo + PART_PAGE_FIXED_LENGTH;
3286 if (psd_cnt > bp[pgo + PP_OFF_MAX_ADD_PARTS]) {
3287 bp[psdo] = bp[psdo + 1] = 0xff; /* Rest of the tape */
3288 psdo += 2;
3289 }
3290 memset(bp + psdo, 0, bp[pgo + PP_OFF_NBR_ADD_PARTS] * 2);
3291
3292 DEBC(printk("%s: psd_cnt %d, max.parts %d, nbr_parts %d\n", name,
3293 psd_cnt, bp[pgo + PP_OFF_MAX_ADD_PARTS],
3294 bp[pgo + PP_OFF_NBR_ADD_PARTS]));
3295
3296 if (size <= 0) {
3297 bp[pgo + PP_OFF_NBR_ADD_PARTS] = 0;
3298 if (psd_cnt <= bp[pgo + PP_OFF_MAX_ADD_PARTS])
3299 bp[pgo + MP_OFF_PAGE_LENGTH] = 6;
3300 DEBC(printk(ST_DEB_MSG "%s: Formatting tape with one partition.\n",
3301 name));
3302 } else {
3303 bp[psdo] = (size >> 8) & 0xff;
3304 bp[psdo + 1] = size & 0xff;
3305 bp[pgo + 3] = 1;
3306 if (bp[pgo + MP_OFF_PAGE_LENGTH] < 8)
3307 bp[pgo + MP_OFF_PAGE_LENGTH] = 8;
3308 DEBC(printk(ST_DEB_MSG
3309 "%s: Formatting tape with two partitions (1 = %d MB).\n",
3310 name, size));
3311 }
3312 bp[pgo + PP_OFF_PART_UNITS] = 0;
3313 bp[pgo + PP_OFF_RESERVED] = 0;
3314 bp[pgo + PP_OFF_FLAGS] = PP_BIT_IDP | PP_MSK_PSUM_MB;
3315
3316 result = write_mode_page(STp, PART_PAGE, 1);
3317 if (result) {
3318 printk(KERN_INFO "%s: Partitioning of tape failed.\n", name);
3319 result = (-EIO);
3320 }
3321
3322 return result;
3323 }
3324 \f
3325
3326
3327 /* The ioctl command */
3328 static long st_ioctl(struct file *file, unsigned int cmd_in, unsigned long arg)
3329 {
3330 int i, cmd_nr, cmd_type, bt;
3331 int retval = 0;
3332 unsigned int blk;
3333 struct scsi_tape *STp = file->private_data;
3334 struct st_modedef *STm;
3335 struct st_partstat *STps;
3336 char *name = tape_name(STp);
3337 void __user *p = (void __user *)arg;
3338
3339 if (mutex_lock_interruptible(&STp->lock))
3340 return -ERESTARTSYS;
3341
3342 DEB(
3343 if (debugging && !STp->in_use) {
3344 printk(ST_DEB_MSG "%s: Incorrect device.\n", name);
3345 retval = (-EIO);
3346 goto out;
3347 } ) /* end DEB */
3348
3349 STm = &(STp->modes[STp->current_mode]);
3350 STps = &(STp->ps[STp->partition]);
3351
3352 /*
3353 * If we are in the middle of error recovery, don't let anyone
3354 * else try and use this device. Also, if error recovery fails, it
3355 * may try and take the device offline, in which case all further
3356 * access to the device is prohibited.
3357 */
3358 retval = scsi_nonblockable_ioctl(STp->device, cmd_in, p,
3359 file->f_flags & O_NDELAY);
3360 if (!scsi_block_when_processing_errors(STp->device) || retval != -ENODEV)
3361 goto out;
3362 retval = 0;
3363
3364 cmd_type = _IOC_TYPE(cmd_in);
3365 cmd_nr = _IOC_NR(cmd_in);
3366
3367 if (cmd_type == _IOC_TYPE(MTIOCTOP) && cmd_nr == _IOC_NR(MTIOCTOP)) {
3368 struct mtop mtc;
3369
3370 if (_IOC_SIZE(cmd_in) != sizeof(mtc)) {
3371 retval = (-EINVAL);
3372 goto out;
3373 }
3374
3375 i = copy_from_user(&mtc, p, sizeof(struct mtop));
3376 if (i) {
3377 retval = (-EFAULT);
3378 goto out;
3379 }
3380
3381 if (mtc.mt_op == MTSETDRVBUFFER && !capable(CAP_SYS_ADMIN)) {
3382 printk(KERN_WARNING
3383 "%s: MTSETDRVBUFFER only allowed for root.\n", name);
3384 retval = (-EPERM);
3385 goto out;
3386 }
3387 if (!STm->defined &&
3388 (mtc.mt_op != MTSETDRVBUFFER &&
3389 (mtc.mt_count & MT_ST_OPTIONS) == 0)) {
3390 retval = (-ENXIO);
3391 goto out;
3392 }
3393
3394 if (!STp->pos_unknown) {
3395
3396 if (STps->eof == ST_FM_HIT) {
3397 if (mtc.mt_op == MTFSF || mtc.mt_op == MTFSFM ||
3398 mtc.mt_op == MTEOM) {
3399 mtc.mt_count -= 1;
3400 if (STps->drv_file >= 0)
3401 STps->drv_file += 1;
3402 } else if (mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM) {
3403 mtc.mt_count += 1;
3404 if (STps->drv_file >= 0)
3405 STps->drv_file += 1;
3406 }
3407 }
3408
3409 if (mtc.mt_op == MTSEEK) {
3410 /* Old position must be restored if partition will be
3411 changed */
3412 i = !STp->can_partitions ||
3413 (STp->new_partition != STp->partition);
3414 } else {
3415 i = mtc.mt_op == MTREW || mtc.mt_op == MTOFFL ||
3416 mtc.mt_op == MTRETEN || mtc.mt_op == MTEOM ||
3417 mtc.mt_op == MTLOCK || mtc.mt_op == MTLOAD ||
3418 mtc.mt_op == MTFSF || mtc.mt_op == MTFSFM ||
3419 mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM ||
3420 mtc.mt_op == MTCOMPRESSION;
3421 }
3422 i = flush_buffer(STp, i);
3423 if (i < 0) {
3424 retval = i;
3425 goto out;
3426 }
3427 if (STps->rw == ST_WRITING &&
3428 (mtc.mt_op == MTREW || mtc.mt_op == MTOFFL ||
3429 mtc.mt_op == MTSEEK ||
3430 mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM)) {
3431 i = st_int_ioctl(STp, MTWEOF, 1);
3432 if (i < 0) {
3433 retval = i;
3434 goto out;
3435 }
3436 if (mtc.mt_op == MTBSF || mtc.mt_op == MTBSFM)
3437 mtc.mt_count++;
3438 STps->rw = ST_IDLE;
3439 }
3440
3441 } else {
3442 /*
3443 * If there was a bus reset, block further access
3444 * to this device. If the user wants to rewind the tape,
3445 * then reset the flag and allow access again.
3446 */
3447 if (mtc.mt_op != MTREW &&
3448 mtc.mt_op != MTOFFL &&
3449 mtc.mt_op != MTRETEN &&
3450 mtc.mt_op != MTERASE &&
3451 mtc.mt_op != MTSEEK &&
3452 mtc.mt_op != MTEOM) {
3453 retval = (-EIO);
3454 goto out;
3455 }
3456 reset_state(STp);
3457 /* remove this when the midlevel properly clears was_reset */
3458 STp->device->was_reset = 0;
3459 }
3460
3461 if (mtc.mt_op != MTNOP && mtc.mt_op != MTSETBLK &&
3462 mtc.mt_op != MTSETDENSITY && mtc.mt_op != MTWSM &&
3463 mtc.mt_op != MTSETDRVBUFFER && mtc.mt_op != MTSETPART)
3464 STps->rw = ST_IDLE; /* Prevent automatic WEOF and fsf */
3465
3466 if (mtc.mt_op == MTOFFL && STp->door_locked != ST_UNLOCKED)
3467 do_door_lock(STp, 0); /* Ignore result! */
3468
3469 if (mtc.mt_op == MTSETDRVBUFFER &&
3470 (mtc.mt_count & MT_ST_OPTIONS) != 0) {
3471 retval = st_set_options(STp, mtc.mt_count);
3472 goto out;
3473 }
3474
3475 if (mtc.mt_op == MTSETPART) {
3476 if (!STp->can_partitions ||
3477 mtc.mt_count < 0 || mtc.mt_count >= ST_NBR_PARTITIONS) {
3478 retval = (-EINVAL);
3479 goto out;
3480 }
3481 if (mtc.mt_count >= STp->nbr_partitions &&
3482 (STp->nbr_partitions = nbr_partitions(STp)) < 0) {
3483 retval = (-EIO);
3484 goto out;
3485 }
3486 if (mtc.mt_count >= STp->nbr_partitions) {
3487 retval = (-EINVAL);
3488 goto out;
3489 }
3490 STp->new_partition = mtc.mt_count;
3491 retval = 0;
3492 goto out;
3493 }
3494
3495 if (mtc.mt_op == MTMKPART) {
3496 if (!STp->can_partitions) {
3497 retval = (-EINVAL);
3498 goto out;
3499 }
3500 if ((i = st_int_ioctl(STp, MTREW, 0)) < 0 ||
3501 (i = partition_tape(STp, mtc.mt_count)) < 0) {
3502 retval = i;
3503 goto out;
3504 }
3505 for (i = 0; i < ST_NBR_PARTITIONS; i++) {
3506 STp->ps[i].rw = ST_IDLE;
3507 STp->ps[i].at_sm = 0;
3508 STp->ps[i].last_block_valid = 0;
3509 }
3510 STp->partition = STp->new_partition = 0;
3511 STp->nbr_partitions = 1; /* Bad guess ?-) */
3512 STps->drv_block = STps->drv_file = 0;
3513 retval = 0;
3514 goto out;
3515 }
3516
3517 if (mtc.mt_op == MTSEEK) {
3518 i = set_location(STp, mtc.mt_count, STp->new_partition, 0);
3519 if (!STp->can_partitions)
3520 STp->ps[0].rw = ST_IDLE;
3521 retval = i;
3522 goto out;
3523 }
3524
3525 if (mtc.mt_op == MTUNLOAD || mtc.mt_op == MTOFFL) {
3526 retval = do_load_unload(STp, file, 0);
3527 goto out;
3528 }
3529
3530 if (mtc.mt_op == MTLOAD) {
3531 retval = do_load_unload(STp, file, max(1, mtc.mt_count));
3532 goto out;
3533 }
3534
3535 if (mtc.mt_op == MTLOCK || mtc.mt_op == MTUNLOCK) {
3536 retval = do_door_lock(STp, (mtc.mt_op == MTLOCK));
3537 goto out;
3538 }
3539
3540 if (STp->can_partitions && STp->ready == ST_READY &&
3541 (i = switch_partition(STp)) < 0) {
3542 retval = i;
3543 goto out;
3544 }
3545
3546 if (mtc.mt_op == MTCOMPRESSION)
3547 retval = st_compression(STp, (mtc.mt_count & 1));
3548 else
3549 retval = st_int_ioctl(STp, mtc.mt_op, mtc.mt_count);
3550 goto out;
3551 }
3552 if (!STm->defined) {
3553 retval = (-ENXIO);
3554 goto out;
3555 }
3556
3557 if ((i = flush_buffer(STp, 0)) < 0) {
3558 retval = i;
3559 goto out;
3560 }
3561 if (STp->can_partitions &&
3562 (i = switch_partition(STp)) < 0) {
3563 retval = i;
3564 goto out;
3565 }
3566
3567 if (cmd_type == _IOC_TYPE(MTIOCGET) && cmd_nr == _IOC_NR(MTIOCGET)) {
3568 struct mtget mt_status;
3569
3570 if (_IOC_SIZE(cmd_in) != sizeof(struct mtget)) {
3571 retval = (-EINVAL);
3572 goto out;
3573 }
3574
3575 mt_status.mt_type = STp->tape_type;
3576 mt_status.mt_dsreg =
3577 ((STp->block_size << MT_ST_BLKSIZE_SHIFT) & MT_ST_BLKSIZE_MASK) |
3578 ((STp->density << MT_ST_DENSITY_SHIFT) & MT_ST_DENSITY_MASK);
3579 mt_status.mt_blkno = STps->drv_block;
3580 mt_status.mt_fileno = STps->drv_file;
3581 if (STp->block_size != 0) {
3582 if (STps->rw == ST_WRITING)
3583 mt_status.mt_blkno +=
3584 (STp->buffer)->buffer_bytes / STp->block_size;
3585 else if (STps->rw == ST_READING)
3586 mt_status.mt_blkno -=
3587 ((STp->buffer)->buffer_bytes +
3588 STp->block_size - 1) / STp->block_size;
3589 }
3590
3591 mt_status.mt_gstat = 0;
3592 if (STp->drv_write_prot)
3593 mt_status.mt_gstat |= GMT_WR_PROT(0xffffffff);
3594 if (mt_status.mt_blkno == 0) {
3595 if (mt_status.mt_fileno == 0)
3596 mt_status.mt_gstat |= GMT_BOT(0xffffffff);
3597 else
3598 mt_status.mt_gstat |= GMT_EOF(0xffffffff);
3599 }
3600 mt_status.mt_erreg = (STp->recover_reg << MT_ST_SOFTERR_SHIFT);
3601 mt_status.mt_resid = STp->partition;
3602 if (STps->eof == ST_EOM_OK || STps->eof == ST_EOM_ERROR)
3603 mt_status.mt_gstat |= GMT_EOT(0xffffffff);
3604 else if (STps->eof >= ST_EOM_OK)
3605 mt_status.mt_gstat |= GMT_EOD(0xffffffff);
3606 if (STp->density == 1)
3607 mt_status.mt_gstat |= GMT_D_800(0xffffffff);
3608 else if (STp->density == 2)
3609 mt_status.mt_gstat |= GMT_D_1600(0xffffffff);
3610 else if (STp->density == 3)
3611 mt_status.mt_gstat |= GMT_D_6250(0xffffffff);
3612 if (STp->ready == ST_READY)
3613 mt_status.mt_gstat |= GMT_ONLINE(0xffffffff);
3614 if (STp->ready == ST_NO_TAPE)
3615 mt_status.mt_gstat |= GMT_DR_OPEN(0xffffffff);
3616 if (STps->at_sm)
3617 mt_status.mt_gstat |= GMT_SM(0xffffffff);
3618 if (STm->do_async_writes ||
3619 (STm->do_buffer_writes && STp->block_size != 0) ||
3620 STp->drv_buffer != 0)
3621 mt_status.mt_gstat |= GMT_IM_REP_EN(0xffffffff);
3622 if (STp->cleaning_req)
3623 mt_status.mt_gstat |= GMT_CLN(0xffffffff);
3624
3625 i = copy_to_user(p, &mt_status, sizeof(struct mtget));
3626 if (i) {
3627 retval = (-EFAULT);
3628 goto out;
3629 }
3630
3631 STp->recover_reg = 0; /* Clear after read */
3632 retval = 0;
3633 goto out;
3634 } /* End of MTIOCGET */
3635 if (cmd_type == _IOC_TYPE(MTIOCPOS) && cmd_nr == _IOC_NR(MTIOCPOS)) {
3636 struct mtpos mt_pos;
3637 if (_IOC_SIZE(cmd_in) != sizeof(struct mtpos)) {
3638 retval = (-EINVAL);
3639 goto out;
3640 }
3641 if ((i = get_location(STp, &blk, &bt, 0)) < 0) {
3642 retval = i;
3643 goto out;
3644 }
3645 mt_pos.mt_blkno = blk;
3646 i = copy_to_user(p, &mt_pos, sizeof(struct mtpos));
3647 if (i)
3648 retval = (-EFAULT);
3649 goto out;
3650 }
3651 mutex_unlock(&STp->lock);
3652 switch (cmd_in) {
3653 case SCSI_IOCTL_GET_IDLUN:
3654 case SCSI_IOCTL_GET_BUS_NUMBER:
3655 break;
3656 default:
3657 if ((cmd_in == SG_IO ||
3658 cmd_in == SCSI_IOCTL_SEND_COMMAND ||
3659 cmd_in == CDROM_SEND_PACKET) &&
3660 !capable(CAP_SYS_RAWIO))
3661 i = -EPERM;
3662 else
3663 i = scsi_cmd_ioctl(STp->disk->queue, STp->disk,
3664 file->f_mode, cmd_in, p);
3665 if (i != -ENOTTY)
3666 return i;
3667 break;
3668 }
3669 retval = scsi_ioctl(STp->device, cmd_in, p);
3670 if (!retval && cmd_in == SCSI_IOCTL_STOP_UNIT) { /* unload */
3671 STp->rew_at_close = 0;
3672 STp->ready = ST_NO_TAPE;
3673 }
3674 return retval;
3675
3676 out:
3677 mutex_unlock(&STp->lock);
3678 return retval;
3679 }
3680
3681 #ifdef CONFIG_COMPAT
3682 static long st_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
3683 {
3684 struct scsi_tape *STp = file->private_data;
3685 struct scsi_device *sdev = STp->device;
3686 int ret = -ENOIOCTLCMD;
3687 if (sdev->host->hostt->compat_ioctl) {
3688
3689 ret = sdev->host->hostt->compat_ioctl(sdev, cmd, (void __user *)arg);
3690
3691 }
3692 return ret;
3693 }
3694 #endif
3695
3696 \f
3697
3698 /* Try to allocate a new tape buffer. Calling function must not hold
3699 dev_arr_lock. */
3700 static struct st_buffer *new_tape_buffer(int need_dma, int max_sg)
3701 {
3702 struct st_buffer *tb;
3703
3704 tb = kzalloc(sizeof(struct st_buffer), GFP_ATOMIC);
3705 if (!tb) {
3706 printk(KERN_NOTICE "st: Can't allocate new tape buffer.\n");
3707 return NULL;
3708 }
3709 tb->frp_segs = 0;
3710 tb->use_sg = max_sg;
3711 tb->dma = need_dma;
3712 tb->buffer_size = 0;
3713
3714 tb->reserved_pages = kzalloc(max_sg * sizeof(struct page *),
3715 GFP_ATOMIC);
3716 if (!tb->reserved_pages) {
3717 kfree(tb);
3718 return NULL;
3719 }
3720
3721 return tb;
3722 }
3723
3724
3725 /* Try to allocate enough space in the tape buffer */
3726 #define ST_MAX_ORDER 6
3727
3728 static int enlarge_buffer(struct st_buffer * STbuffer, int new_size, int need_dma)
3729 {
3730 int segs, nbr, max_segs, b_size, order, got;
3731 gfp_t priority;
3732
3733 if (new_size <= STbuffer->buffer_size)
3734 return 1;
3735
3736 if (STbuffer->buffer_size <= PAGE_SIZE)
3737 normalize_buffer(STbuffer); /* Avoid extra segment */
3738
3739 max_segs = STbuffer->use_sg;
3740 nbr = max_segs - STbuffer->frp_segs;
3741 if (nbr <= 0)
3742 return 0;
3743
3744 priority = GFP_KERNEL | __GFP_NOWARN;
3745 if (need_dma)
3746 priority |= GFP_DMA;
3747
3748 if (STbuffer->cleared)
3749 priority |= __GFP_ZERO;
3750
3751 if (STbuffer->frp_segs) {
3752 order = STbuffer->reserved_page_order;
3753 b_size = PAGE_SIZE << order;
3754 } else {
3755 for (b_size = PAGE_SIZE, order = 0;
3756 order < ST_MAX_ORDER &&
3757 max_segs * (PAGE_SIZE << order) < new_size;
3758 order++, b_size *= 2)
3759 ; /* empty */
3760 STbuffer->reserved_page_order = order;
3761 }
3762 if (max_segs * (PAGE_SIZE << order) < new_size) {
3763 if (order == ST_MAX_ORDER)
3764 return 0;
3765 normalize_buffer(STbuffer);
3766 return enlarge_buffer(STbuffer, new_size, need_dma);
3767 }
3768
3769 for (segs = STbuffer->frp_segs, got = STbuffer->buffer_size;
3770 segs < max_segs && got < new_size;) {
3771 struct page *page;
3772
3773 page = alloc_pages(priority, order);
3774 if (!page) {
3775 DEB(STbuffer->buffer_size = got);
3776 normalize_buffer(STbuffer);
3777 return 0;
3778 }
3779
3780 STbuffer->frp_segs += 1;
3781 got += b_size;
3782 STbuffer->buffer_size = got;
3783 STbuffer->reserved_pages[segs] = page;
3784 segs++;
3785 }
3786 STbuffer->b_data = page_address(STbuffer->reserved_pages[0]);
3787
3788 return 1;
3789 }
3790
3791
3792 /* Make sure that no data from previous user is in the internal buffer */
3793 static void clear_buffer(struct st_buffer * st_bp)
3794 {
3795 int i;
3796
3797 for (i=0; i < st_bp->frp_segs; i++)
3798 memset(page_address(st_bp->reserved_pages[i]), 0,
3799 PAGE_SIZE << st_bp->reserved_page_order);
3800 st_bp->cleared = 1;
3801 }
3802
3803
3804 /* Release the extra buffer */
3805 static void normalize_buffer(struct st_buffer * STbuffer)
3806 {
3807 int i, order = STbuffer->reserved_page_order;
3808
3809 for (i = 0; i < STbuffer->frp_segs; i++) {
3810 __free_pages(STbuffer->reserved_pages[i], order);
3811 STbuffer->buffer_size -= (PAGE_SIZE << order);
3812 }
3813 STbuffer->frp_segs = 0;
3814 STbuffer->sg_segs = 0;
3815 STbuffer->reserved_page_order = 0;
3816 STbuffer->map_data.offset = 0;
3817 }
3818
3819
3820 /* Move data from the user buffer to the tape buffer. Returns zero (success) or
3821 negative error code. */
3822 static int append_to_buffer(const char __user *ubp, struct st_buffer * st_bp, int do_count)
3823 {
3824 int i, cnt, res, offset;
3825 int length = PAGE_SIZE << st_bp->reserved_page_order;
3826
3827 for (i = 0, offset = st_bp->buffer_bytes;
3828 i < st_bp->frp_segs && offset >= length; i++)
3829 offset -= length;
3830 if (i == st_bp->frp_segs) { /* Should never happen */
3831 printk(KERN_WARNING "st: append_to_buffer offset overflow.\n");
3832 return (-EIO);
3833 }
3834 for (; i < st_bp->frp_segs && do_count > 0; i++) {
3835 struct page *page = st_bp->reserved_pages[i];
3836 cnt = length - offset < do_count ? length - offset : do_count;
3837 res = copy_from_user(page_address(page) + offset, ubp, cnt);
3838 if (res)
3839 return (-EFAULT);
3840 do_count -= cnt;
3841 st_bp->buffer_bytes += cnt;
3842 ubp += cnt;
3843 offset = 0;
3844 }
3845 if (do_count) /* Should never happen */
3846 return (-EIO);
3847
3848 return 0;
3849 }
3850
3851
3852 /* Move data from the tape buffer to the user buffer. Returns zero (success) or
3853 negative error code. */
3854 static int from_buffer(struct st_buffer * st_bp, char __user *ubp, int do_count)
3855 {
3856 int i, cnt, res, offset;
3857 int length = PAGE_SIZE << st_bp->reserved_page_order;
3858
3859 for (i = 0, offset = st_bp->read_pointer;
3860 i < st_bp->frp_segs && offset >= length; i++)
3861 offset -= length;
3862 if (i == st_bp->frp_segs) { /* Should never happen */
3863 printk(KERN_WARNING "st: from_buffer offset overflow.\n");
3864 return (-EIO);
3865 }
3866 for (; i < st_bp->frp_segs && do_count > 0; i++) {
3867 struct page *page = st_bp->reserved_pages[i];
3868 cnt = length - offset < do_count ? length - offset : do_count;
3869 res = copy_to_user(ubp, page_address(page) + offset, cnt);
3870 if (res)
3871 return (-EFAULT);
3872 do_count -= cnt;
3873 st_bp->buffer_bytes -= cnt;
3874 st_bp->read_pointer += cnt;
3875 ubp += cnt;
3876 offset = 0;
3877 }
3878 if (do_count) /* Should never happen */
3879 return (-EIO);
3880
3881 return 0;
3882 }
3883
3884
3885 /* Move data towards start of buffer */
3886 static void move_buffer_data(struct st_buffer * st_bp, int offset)
3887 {
3888 int src_seg, dst_seg, src_offset = 0, dst_offset;
3889 int count, total;
3890 int length = PAGE_SIZE << st_bp->reserved_page_order;
3891
3892 if (offset == 0)
3893 return;
3894
3895 total=st_bp->buffer_bytes - offset;
3896 for (src_seg=0; src_seg < st_bp->frp_segs; src_seg++) {
3897 src_offset = offset;
3898 if (src_offset < length)
3899 break;
3900 offset -= length;
3901 }
3902
3903 st_bp->buffer_bytes = st_bp->read_pointer = total;
3904 for (dst_seg=dst_offset=0; total > 0; ) {
3905 struct page *dpage = st_bp->reserved_pages[dst_seg];
3906 struct page *spage = st_bp->reserved_pages[src_seg];
3907
3908 count = min(length - dst_offset, length - src_offset);
3909 memmove(page_address(dpage) + dst_offset,
3910 page_address(spage) + src_offset, count);
3911 src_offset += count;
3912 if (src_offset >= length) {
3913 src_seg++;
3914 src_offset = 0;
3915 }
3916 dst_offset += count;
3917 if (dst_offset >= length) {
3918 dst_seg++;
3919 dst_offset = 0;
3920 }
3921 total -= count;
3922 }
3923 }
3924
3925 /* Validate the options from command line or module parameters */
3926 static void validate_options(void)
3927 {
3928 if (buffer_kbs > 0)
3929 st_fixed_buffer_size = buffer_kbs * ST_KILOBYTE;
3930 if (max_sg_segs >= ST_FIRST_SG)
3931 st_max_sg_segs = max_sg_segs;
3932 }
3933
3934 #ifndef MODULE
3935 /* Set the boot options. Syntax is defined in Documenation/scsi/st.txt.
3936 */
3937 static int __init st_setup(char *str)
3938 {
3939 int i, len, ints[5];
3940 char *stp;
3941
3942 stp = get_options(str, ARRAY_SIZE(ints), ints);
3943
3944 if (ints[0] > 0) {
3945 for (i = 0; i < ints[0] && i < ARRAY_SIZE(parms); i++)
3946 if (parms[i].val)
3947 *parms[i].val = ints[i + 1];
3948 } else {
3949 while (stp != NULL) {
3950 for (i = 0; i < ARRAY_SIZE(parms); i++) {
3951 len = strlen(parms[i].name);
3952 if (!strncmp(stp, parms[i].name, len) &&
3953 (*(stp + len) == ':' || *(stp + len) == '=')) {
3954 if (parms[i].val)
3955 *parms[i].val =
3956 simple_strtoul(stp + len + 1, NULL, 0);
3957 else
3958 printk(KERN_WARNING "st: Obsolete parameter %s\n",
3959 parms[i].name);
3960 break;
3961 }
3962 }
3963 if (i >= ARRAY_SIZE(parms))
3964 printk(KERN_WARNING "st: invalid parameter in '%s'\n",
3965 stp);
3966 stp = strchr(stp, ',');
3967 if (stp)
3968 stp++;
3969 }
3970 }
3971
3972 validate_options();
3973
3974 return 1;
3975 }
3976
3977 __setup("st=", st_setup);
3978
3979 #endif
3980
3981 static const struct file_operations st_fops =
3982 {
3983 .owner = THIS_MODULE,
3984 .read = st_read,
3985 .write = st_write,
3986 .unlocked_ioctl = st_ioctl,
3987 #ifdef CONFIG_COMPAT
3988 .compat_ioctl = st_compat_ioctl,
3989 #endif
3990 .open = st_open,
3991 .flush = st_flush,
3992 .release = st_release,
3993 .llseek = noop_llseek,
3994 };
3995
3996 static int st_probe(struct device *dev)
3997 {
3998 struct scsi_device *SDp = to_scsi_device(dev);
3999 struct gendisk *disk = NULL;
4000 struct cdev *cdev = NULL;
4001 struct scsi_tape *tpnt = NULL;
4002 struct st_modedef *STm;
4003 struct st_partstat *STps;
4004 struct st_buffer *buffer;
4005 int i, j, mode, dev_num, error;
4006 char *stp;
4007
4008 if (SDp->type != TYPE_TAPE)
4009 return -ENODEV;
4010 if ((stp = st_incompatible(SDp))) {
4011 sdev_printk(KERN_INFO, SDp, "Found incompatible tape\n");
4012 printk(KERN_INFO "st: The suggested driver is %s.\n", stp);
4013 return -ENODEV;
4014 }
4015
4016 i = queue_max_segments(SDp->request_queue);
4017 if (st_max_sg_segs < i)
4018 i = st_max_sg_segs;
4019 buffer = new_tape_buffer((SDp->host)->unchecked_isa_dma, i);
4020 if (buffer == NULL) {
4021 printk(KERN_ERR
4022 "st: Can't allocate new tape buffer. Device not attached.\n");
4023 goto out;
4024 }
4025
4026 disk = alloc_disk(1);
4027 if (!disk) {
4028 printk(KERN_ERR "st: out of memory. Device not attached.\n");
4029 goto out_buffer_free;
4030 }
4031
4032 write_lock(&st_dev_arr_lock);
4033 if (st_nr_dev >= st_dev_max) {
4034 struct scsi_tape **tmp_da;
4035 int tmp_dev_max;
4036
4037 tmp_dev_max = max(st_nr_dev * 2, 8);
4038 if (tmp_dev_max > ST_MAX_TAPES)
4039 tmp_dev_max = ST_MAX_TAPES;
4040 if (tmp_dev_max <= st_nr_dev) {
4041 write_unlock(&st_dev_arr_lock);
4042 printk(KERN_ERR "st: Too many tape devices (max. %d).\n",
4043 ST_MAX_TAPES);
4044 goto out_put_disk;
4045 }
4046
4047 tmp_da = kzalloc(tmp_dev_max * sizeof(struct scsi_tape *), GFP_ATOMIC);
4048 if (tmp_da == NULL) {
4049 write_unlock(&st_dev_arr_lock);
4050 printk(KERN_ERR "st: Can't extend device array.\n");
4051 goto out_put_disk;
4052 }
4053
4054 if (scsi_tapes != NULL) {
4055 memcpy(tmp_da, scsi_tapes,
4056 st_dev_max * sizeof(struct scsi_tape *));
4057 kfree(scsi_tapes);
4058 }
4059 scsi_tapes = tmp_da;
4060
4061 st_dev_max = tmp_dev_max;
4062 }
4063
4064 for (i = 0; i < st_dev_max; i++)
4065 if (scsi_tapes[i] == NULL)
4066 break;
4067 if (i >= st_dev_max)
4068 panic("scsi_devices corrupt (st)");
4069
4070 tpnt = kzalloc(sizeof(struct scsi_tape), GFP_ATOMIC);
4071 if (tpnt == NULL) {
4072 write_unlock(&st_dev_arr_lock);
4073 printk(KERN_ERR "st: Can't allocate device descriptor.\n");
4074 goto out_put_disk;
4075 }
4076 kref_init(&tpnt->kref);
4077 tpnt->disk = disk;
4078 sprintf(disk->disk_name, "st%d", i);
4079 disk->private_data = &tpnt->driver;
4080 disk->queue = SDp->request_queue;
4081 tpnt->driver = &st_template;
4082 scsi_tapes[i] = tpnt;
4083 dev_num = i;
4084
4085 tpnt->device = SDp;
4086 if (SDp->scsi_level <= 2)
4087 tpnt->tape_type = MT_ISSCSI1;
4088 else
4089 tpnt->tape_type = MT_ISSCSI2;
4090
4091 tpnt->buffer = buffer;
4092 tpnt->buffer->last_SRpnt = NULL;
4093
4094 tpnt->inited = 0;
4095 tpnt->dirty = 0;
4096 tpnt->in_use = 0;
4097 tpnt->drv_buffer = 1; /* Try buffering if no mode sense */
4098 tpnt->restr_dma = (SDp->host)->unchecked_isa_dma;
4099 tpnt->use_pf = (SDp->scsi_level >= SCSI_2);
4100 tpnt->density = 0;
4101 tpnt->do_auto_lock = ST_AUTO_LOCK;
4102 tpnt->can_bsr = (SDp->scsi_level > 2 ? 1 : ST_IN_FILE_POS); /* BSR mandatory in SCSI3 */
4103 tpnt->can_partitions = 0;
4104 tpnt->two_fm = ST_TWO_FM;
4105 tpnt->fast_mteom = ST_FAST_MTEOM;
4106 tpnt->scsi2_logical = ST_SCSI2LOGICAL;
4107 tpnt->sili = ST_SILI;
4108 tpnt->immediate = ST_NOWAIT;
4109 tpnt->immediate_filemark = 0;
4110 tpnt->default_drvbuffer = 0xff; /* No forced buffering */
4111 tpnt->partition = 0;
4112 tpnt->new_partition = 0;
4113 tpnt->nbr_partitions = 0;
4114 blk_queue_rq_timeout(tpnt->device->request_queue, ST_TIMEOUT);
4115 tpnt->long_timeout = ST_LONG_TIMEOUT;
4116 tpnt->try_dio = try_direct_io && !SDp->host->unchecked_isa_dma;
4117
4118 for (i = 0; i < ST_NBR_MODES; i++) {
4119 STm = &(tpnt->modes[i]);
4120 STm->defined = 0;
4121 STm->sysv = ST_SYSV;
4122 STm->defaults_for_writes = 0;
4123 STm->do_async_writes = ST_ASYNC_WRITES;
4124 STm->do_buffer_writes = ST_BUFFER_WRITES;
4125 STm->do_read_ahead = ST_READ_AHEAD;
4126 STm->default_compression = ST_DONT_TOUCH;
4127 STm->default_blksize = (-1); /* No forced size */
4128 STm->default_density = (-1); /* No forced density */
4129 }
4130
4131 for (i = 0; i < ST_NBR_PARTITIONS; i++) {
4132 STps = &(tpnt->ps[i]);
4133 STps->rw = ST_IDLE;
4134 STps->eof = ST_NOEOF;
4135 STps->at_sm = 0;
4136 STps->last_block_valid = 0;
4137 STps->drv_block = (-1);
4138 STps->drv_file = (-1);
4139 }
4140
4141 tpnt->current_mode = 0;
4142 tpnt->modes[0].defined = 1;
4143
4144 tpnt->density_changed = tpnt->compression_changed =
4145 tpnt->blksize_changed = 0;
4146 mutex_init(&tpnt->lock);
4147
4148 st_nr_dev++;
4149 write_unlock(&st_dev_arr_lock);
4150
4151 for (mode = 0; mode < ST_NBR_MODES; ++mode) {
4152 STm = &(tpnt->modes[mode]);
4153 for (j=0; j < 2; j++) {
4154 cdev = cdev_alloc();
4155 if (!cdev) {
4156 printk(KERN_ERR
4157 "st%d: out of memory. Device not attached.\n",
4158 dev_num);
4159 cdev_del(cdev);
4160 goto out_free_tape;
4161 }
4162 cdev->owner = THIS_MODULE;
4163 cdev->ops = &st_fops;
4164
4165 error = cdev_add(cdev,
4166 MKDEV(SCSI_TAPE_MAJOR, TAPE_MINOR(dev_num, mode, j)),
4167 1);
4168 if (error) {
4169 printk(KERN_ERR "st%d: Can't add %s-rewind mode %d\n",
4170 dev_num, j ? "non" : "auto", mode);
4171 printk(KERN_ERR "st%d: Device not attached.\n", dev_num);
4172 goto out_free_tape;
4173 }
4174 STm->cdevs[j] = cdev;
4175
4176 }
4177 error = do_create_class_files(tpnt, dev_num, mode);
4178 if (error)
4179 goto out_free_tape;
4180 }
4181 scsi_autopm_put_device(SDp);
4182
4183 sdev_printk(KERN_NOTICE, SDp,
4184 "Attached scsi tape %s\n", tape_name(tpnt));
4185 sdev_printk(KERN_INFO, SDp, "%s: try direct i/o: %s (alignment %d B)\n",
4186 tape_name(tpnt), tpnt->try_dio ? "yes" : "no",
4187 queue_dma_alignment(SDp->request_queue) + 1);
4188
4189 return 0;
4190
4191 out_free_tape:
4192 for (mode=0; mode < ST_NBR_MODES; mode++) {
4193 STm = &(tpnt->modes[mode]);
4194 sysfs_remove_link(&tpnt->device->sdev_gendev.kobj,
4195 "tape");
4196 for (j=0; j < 2; j++) {
4197 if (STm->cdevs[j]) {
4198 device_destroy(&st_sysfs_class,
4199 MKDEV(SCSI_TAPE_MAJOR,
4200 TAPE_MINOR(i, mode, j)));
4201 cdev_del(STm->cdevs[j]);
4202 }
4203 }
4204 }
4205 write_lock(&st_dev_arr_lock);
4206 scsi_tapes[dev_num] = NULL;
4207 st_nr_dev--;
4208 write_unlock(&st_dev_arr_lock);
4209 out_put_disk:
4210 put_disk(disk);
4211 kfree(tpnt);
4212 out_buffer_free:
4213 kfree(buffer);
4214 out:
4215 return -ENODEV;
4216 };
4217
4218
4219 static int st_remove(struct device *dev)
4220 {
4221 struct scsi_device *SDp = to_scsi_device(dev);
4222 struct scsi_tape *tpnt;
4223 int i, j, mode;
4224
4225 scsi_autopm_get_device(SDp);
4226 write_lock(&st_dev_arr_lock);
4227 for (i = 0; i < st_dev_max; i++) {
4228 tpnt = scsi_tapes[i];
4229 if (tpnt != NULL && tpnt->device == SDp) {
4230 scsi_tapes[i] = NULL;
4231 st_nr_dev--;
4232 write_unlock(&st_dev_arr_lock);
4233 sysfs_remove_link(&tpnt->device->sdev_gendev.kobj,
4234 "tape");
4235 for (mode = 0; mode < ST_NBR_MODES; ++mode) {
4236 for (j=0; j < 2; j++) {
4237 device_destroy(&st_sysfs_class,
4238 MKDEV(SCSI_TAPE_MAJOR,
4239 TAPE_MINOR(i, mode, j)));
4240 cdev_del(tpnt->modes[mode].cdevs[j]);
4241 tpnt->modes[mode].cdevs[j] = NULL;
4242 }
4243 }
4244
4245 mutex_lock(&st_ref_mutex);
4246 kref_put(&tpnt->kref, scsi_tape_release);
4247 mutex_unlock(&st_ref_mutex);
4248 return 0;
4249 }
4250 }
4251
4252 write_unlock(&st_dev_arr_lock);
4253 return 0;
4254 }
4255
4256 /**
4257 * scsi_tape_release - Called to free the Scsi_Tape structure
4258 * @kref: pointer to embedded kref
4259 *
4260 * st_ref_mutex must be held entering this routine. Because it is
4261 * called on last put, you should always use the scsi_tape_get()
4262 * scsi_tape_put() helpers which manipulate the semaphore directly
4263 * and never do a direct kref_put().
4264 **/
4265 static void scsi_tape_release(struct kref *kref)
4266 {
4267 struct scsi_tape *tpnt = to_scsi_tape(kref);
4268 struct gendisk *disk = tpnt->disk;
4269
4270 tpnt->device = NULL;
4271
4272 if (tpnt->buffer) {
4273 normalize_buffer(tpnt->buffer);
4274 kfree(tpnt->buffer->reserved_pages);
4275 kfree(tpnt->buffer);
4276 }
4277
4278 disk->private_data = NULL;
4279 put_disk(disk);
4280 kfree(tpnt);
4281 return;
4282 }
4283
4284 static struct class st_sysfs_class = {
4285 .name = "scsi_tape",
4286 .dev_attrs = st_dev_attrs,
4287 };
4288
4289 static int __init init_st(void)
4290 {
4291 int err;
4292
4293 validate_options();
4294
4295 printk(KERN_INFO "st: Version %s, fixed bufsize %d, s/g segs %d\n",
4296 verstr, st_fixed_buffer_size, st_max_sg_segs);
4297
4298 err = class_register(&st_sysfs_class);
4299 if (err) {
4300 pr_err("Unable register sysfs class for SCSI tapes\n");
4301 return err;
4302 }
4303
4304 err = register_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0),
4305 ST_MAX_TAPE_ENTRIES, "st");
4306 if (err) {
4307 printk(KERN_ERR "Unable to get major %d for SCSI tapes\n",
4308 SCSI_TAPE_MAJOR);
4309 goto err_class;
4310 }
4311
4312 err = scsi_register_driver(&st_template.gendrv);
4313 if (err)
4314 goto err_chrdev;
4315
4316 err = do_create_sysfs_files();
4317 if (err)
4318 goto err_scsidrv;
4319
4320 return 0;
4321
4322 err_scsidrv:
4323 scsi_unregister_driver(&st_template.gendrv);
4324 err_chrdev:
4325 unregister_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0),
4326 ST_MAX_TAPE_ENTRIES);
4327 err_class:
4328 class_unregister(&st_sysfs_class);
4329 return err;
4330 }
4331
4332 static void __exit exit_st(void)
4333 {
4334 do_remove_sysfs_files();
4335 scsi_unregister_driver(&st_template.gendrv);
4336 unregister_chrdev_region(MKDEV(SCSI_TAPE_MAJOR, 0),
4337 ST_MAX_TAPE_ENTRIES);
4338 class_unregister(&st_sysfs_class);
4339 kfree(scsi_tapes);
4340 printk(KERN_INFO "st: Unloaded.\n");
4341 }
4342
4343 module_init(init_st);
4344 module_exit(exit_st);
4345
4346
4347 /* The sysfs driver interface. Read-only at the moment */
4348 static ssize_t st_try_direct_io_show(struct device_driver *ddp, char *buf)
4349 {
4350 return snprintf(buf, PAGE_SIZE, "%d\n", try_direct_io);
4351 }
4352 static DRIVER_ATTR(try_direct_io, S_IRUGO, st_try_direct_io_show, NULL);
4353
4354 static ssize_t st_fixed_buffer_size_show(struct device_driver *ddp, char *buf)
4355 {
4356 return snprintf(buf, PAGE_SIZE, "%d\n", st_fixed_buffer_size);
4357 }
4358 static DRIVER_ATTR(fixed_buffer_size, S_IRUGO, st_fixed_buffer_size_show, NULL);
4359
4360 static ssize_t st_max_sg_segs_show(struct device_driver *ddp, char *buf)
4361 {
4362 return snprintf(buf, PAGE_SIZE, "%d\n", st_max_sg_segs);
4363 }
4364 static DRIVER_ATTR(max_sg_segs, S_IRUGO, st_max_sg_segs_show, NULL);
4365
4366 static ssize_t st_version_show(struct device_driver *ddd, char *buf)
4367 {
4368 return snprintf(buf, PAGE_SIZE, "[%s]\n", verstr);
4369 }
4370 static DRIVER_ATTR(version, S_IRUGO, st_version_show, NULL);
4371
4372 static int do_create_sysfs_files(void)
4373 {
4374 struct device_driver *sysfs = &st_template.gendrv;
4375 int err;
4376
4377 err = driver_create_file(sysfs, &driver_attr_try_direct_io);
4378 if (err)
4379 return err;
4380 err = driver_create_file(sysfs, &driver_attr_fixed_buffer_size);
4381 if (err)
4382 goto err_try_direct_io;
4383 err = driver_create_file(sysfs, &driver_attr_max_sg_segs);
4384 if (err)
4385 goto err_attr_fixed_buf;
4386 err = driver_create_file(sysfs, &driver_attr_version);
4387 if (err)
4388 goto err_attr_max_sg;
4389
4390 return 0;
4391
4392 err_attr_max_sg:
4393 driver_remove_file(sysfs, &driver_attr_max_sg_segs);
4394 err_attr_fixed_buf:
4395 driver_remove_file(sysfs, &driver_attr_fixed_buffer_size);
4396 err_try_direct_io:
4397 driver_remove_file(sysfs, &driver_attr_try_direct_io);
4398 return err;
4399 }
4400
4401 static void do_remove_sysfs_files(void)
4402 {
4403 struct device_driver *sysfs = &st_template.gendrv;
4404
4405 driver_remove_file(sysfs, &driver_attr_version);
4406 driver_remove_file(sysfs, &driver_attr_max_sg_segs);
4407 driver_remove_file(sysfs, &driver_attr_fixed_buffer_size);
4408 driver_remove_file(sysfs, &driver_attr_try_direct_io);
4409 }
4410
4411 /* The sysfs simple class interface */
4412 static ssize_t
4413 defined_show(struct device *dev, struct device_attribute *attr, char *buf)
4414 {
4415 struct st_modedef *STm = dev_get_drvdata(dev);
4416 ssize_t l = 0;
4417
4418 l = snprintf(buf, PAGE_SIZE, "%d\n", STm->defined);
4419 return l;
4420 }
4421
4422 static ssize_t
4423 default_blksize_show(struct device *dev, struct device_attribute *attr,
4424 char *buf)
4425 {
4426 struct st_modedef *STm = dev_get_drvdata(dev);
4427 ssize_t l = 0;
4428
4429 l = snprintf(buf, PAGE_SIZE, "%d\n", STm->default_blksize);
4430 return l;
4431 }
4432
4433
4434 static ssize_t
4435 default_density_show(struct device *dev, struct device_attribute *attr,
4436 char *buf)
4437 {
4438 struct st_modedef *STm = dev_get_drvdata(dev);
4439 ssize_t l = 0;
4440 char *fmt;
4441
4442 fmt = STm->default_density >= 0 ? "0x%02x\n" : "%d\n";
4443 l = snprintf(buf, PAGE_SIZE, fmt, STm->default_density);
4444 return l;
4445 }
4446
4447 static ssize_t
4448 default_compression_show(struct device *dev, struct device_attribute *attr,
4449 char *buf)
4450 {
4451 struct st_modedef *STm = dev_get_drvdata(dev);
4452 ssize_t l = 0;
4453
4454 l = snprintf(buf, PAGE_SIZE, "%d\n", STm->default_compression - 1);
4455 return l;
4456 }
4457
4458 static ssize_t
4459 options_show(struct device *dev, struct device_attribute *attr, char *buf)
4460 {
4461 struct st_modedef *STm = dev_get_drvdata(dev);
4462 struct scsi_tape *STp;
4463 int i, j, options;
4464 ssize_t l = 0;
4465
4466 for (i=0; i < st_dev_max; i++) {
4467 for (j=0; j < ST_NBR_MODES; j++)
4468 if (&scsi_tapes[i]->modes[j] == STm)
4469 break;
4470 if (j < ST_NBR_MODES)
4471 break;
4472 }
4473 if (i == st_dev_max)
4474 return 0; /* should never happen */
4475
4476 STp = scsi_tapes[i];
4477
4478 options = STm->do_buffer_writes ? MT_ST_BUFFER_WRITES : 0;
4479 options |= STm->do_async_writes ? MT_ST_ASYNC_WRITES : 0;
4480 options |= STm->do_read_ahead ? MT_ST_READ_AHEAD : 0;
4481 DEB( options |= debugging ? MT_ST_DEBUGGING : 0 );
4482 options |= STp->two_fm ? MT_ST_TWO_FM : 0;
4483 options |= STp->fast_mteom ? MT_ST_FAST_MTEOM : 0;
4484 options |= STm->defaults_for_writes ? MT_ST_DEF_WRITES : 0;
4485 options |= STp->can_bsr ? MT_ST_CAN_BSR : 0;
4486 options |= STp->omit_blklims ? MT_ST_NO_BLKLIMS : 0;
4487 options |= STp->can_partitions ? MT_ST_CAN_PARTITIONS : 0;
4488 options |= STp->scsi2_logical ? MT_ST_SCSI2LOGICAL : 0;
4489 options |= STm->sysv ? MT_ST_SYSV : 0;
4490 options |= STp->immediate ? MT_ST_NOWAIT : 0;
4491 options |= STp->immediate_filemark ? MT_ST_NOWAIT_EOF : 0;
4492 options |= STp->sili ? MT_ST_SILI : 0;
4493
4494 l = snprintf(buf, PAGE_SIZE, "0x%08x\n", options);
4495 return l;
4496 }
4497
4498 static struct device_attribute st_dev_attrs[] = {
4499 __ATTR_RO(defined),
4500 __ATTR_RO(default_blksize),
4501 __ATTR_RO(default_density),
4502 __ATTR_RO(default_compression),
4503 __ATTR_RO(options),
4504 __ATTR_NULL,
4505 };
4506
4507 static int do_create_class_files(struct scsi_tape *STp, int dev_num, int mode)
4508 {
4509 int i, rew, error;
4510 char name[10];
4511 struct device *st_class_member;
4512
4513 for (rew=0; rew < 2; rew++) {
4514 /* Make sure that the minor numbers corresponding to the four
4515 first modes always get the same names */
4516 i = mode << (4 - ST_NBR_MODE_BITS);
4517 snprintf(name, 10, "%s%s%s", rew ? "n" : "",
4518 STp->disk->disk_name, st_formats[i]);
4519 st_class_member =
4520 device_create(&st_sysfs_class,
4521 &STp->device->sdev_gendev,
4522 MKDEV(SCSI_TAPE_MAJOR,
4523 TAPE_MINOR(dev_num, mode, rew)),
4524 &STp->modes[mode], "%s", name);
4525 if (IS_ERR(st_class_member)) {
4526 printk(KERN_WARNING "st%d: device_create failed\n",
4527 dev_num);
4528 error = PTR_ERR(st_class_member);
4529 goto out;
4530 }
4531
4532 if (mode == 0 && rew == 0) {
4533 error = sysfs_create_link(&STp->device->sdev_gendev.kobj,
4534 &st_class_member->kobj,
4535 "tape");
4536 if (error) {
4537 printk(KERN_ERR
4538 "st%d: Can't create sysfs link from SCSI device.\n",
4539 dev_num);
4540 goto out;
4541 }
4542 }
4543 }
4544
4545 return 0;
4546
4547 out:
4548 return error;
4549 }
4550
4551 /* The following functions may be useful for a larger audience. */
4552 static int sgl_map_user_pages(struct st_buffer *STbp,
4553 const unsigned int max_pages, unsigned long uaddr,
4554 size_t count, int rw)
4555 {
4556 unsigned long end = (uaddr + count + PAGE_SIZE - 1) >> PAGE_SHIFT;
4557 unsigned long start = uaddr >> PAGE_SHIFT;
4558 const int nr_pages = end - start;
4559 int res, i, j;
4560 struct page **pages;
4561 struct rq_map_data *mdata = &STbp->map_data;
4562
4563 /* User attempted Overflow! */
4564 if ((uaddr + count) < uaddr)
4565 return -EINVAL;
4566
4567 /* Too big */
4568 if (nr_pages > max_pages)
4569 return -ENOMEM;
4570
4571 /* Hmm? */
4572 if (count == 0)
4573 return 0;
4574
4575 if ((pages = kmalloc(max_pages * sizeof(*pages), GFP_KERNEL)) == NULL)
4576 return -ENOMEM;
4577
4578 /* Try to fault in all of the necessary pages */
4579 down_read(&current->mm->mmap_sem);
4580 /* rw==READ means read from drive, write into memory area */
4581 res = get_user_pages(
4582 current,
4583 current->mm,
4584 uaddr,
4585 nr_pages,
4586 rw == READ,
4587 0, /* don't force */
4588 pages,
4589 NULL);
4590 up_read(&current->mm->mmap_sem);
4591
4592 /* Errors and no page mapped should return here */
4593 if (res < nr_pages)
4594 goto out_unmap;
4595
4596 for (i=0; i < nr_pages; i++) {
4597 /* FIXME: flush superflous for rw==READ,
4598 * probably wrong function for rw==WRITE
4599 */
4600 flush_dcache_page(pages[i]);
4601 }
4602
4603 mdata->offset = uaddr & ~PAGE_MASK;
4604 STbp->mapped_pages = pages;
4605
4606 return nr_pages;
4607 out_unmap:
4608 if (res > 0) {
4609 for (j=0; j < res; j++)
4610 page_cache_release(pages[j]);
4611 res = 0;
4612 }
4613 kfree(pages);
4614 return res;
4615 }
4616
4617
4618 /* And unmap them... */
4619 static int sgl_unmap_user_pages(struct st_buffer *STbp,
4620 const unsigned int nr_pages, int dirtied)
4621 {
4622 int i;
4623
4624 for (i=0; i < nr_pages; i++) {
4625 struct page *page = STbp->mapped_pages[i];
4626
4627 if (dirtied)
4628 SetPageDirty(page);
4629 /* FIXME: cache flush missing for rw==READ
4630 * FIXME: call the correct reference counting function
4631 */
4632 page_cache_release(page);
4633 }
4634 kfree(STbp->mapped_pages);
4635 STbp->mapped_pages = NULL;
4636
4637 return 0;
4638 }
Linux kernel - Deliverables
This page took 0.204687 seconds and 6 git commands to generate.