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