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