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