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