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