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