brintos / linux-shallow public Read only

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