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