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