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