[linux.git] / block / scsi_ioctl.c

/*
 * Copyright (C) 2001 Jens Axboe <[email protected]>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 *
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public Licens
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-
 *
 */
#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/string.h>
#include <linux/module.h>
#include <linux/blkdev.h>
#include <linux/capability.h>
#include <linux/completion.h>
#include <linux/cdrom.h>
#include <linux/slab.h>
#include <linux/times.h>
#include <asm/uaccess.h>

#include <scsi/scsi.h>
#include <scsi/scsi_ioctl.h>
#include <scsi/scsi_cmnd.h>

/* Command group 3 is reserved and should never be used.  */
const unsigned char scsi_command_size_tbl[8] =
{
	6, 10, 10, 12,
	16, 12, 10, 10
};
EXPORT_SYMBOL(scsi_command_size_tbl);

#include <scsi/sg.h>

static int sg_get_version(int __user *p)
{
	static const int sg_version_num = 30527;
	return put_user(sg_version_num, p);
}

static int scsi_get_idlun(struct request_queue *q, int __user *p)
{
	return put_user(0, p);
}

static int scsi_get_bus(struct request_queue *q, int __user *p)
{
	return put_user(0, p);
}

static int sg_get_timeout(struct request_queue *q)
{
	return jiffies_to_clock_t(q->sg_timeout);
}

static int sg_set_timeout(struct request_queue *q, int __user *p)
{
	int timeout, err = get_user(timeout, p);

	if (!err)
		q->sg_timeout = clock_t_to_jiffies(timeout);

	return err;
}

static int sg_get_reserved_size(struct request_queue *q, int __user *p)
{
	unsigned val = min(q->sg_reserved_size, queue_max_sectors(q) << 9);

	return put_user(val, p);
}

static int sg_set_reserved_size(struct request_queue *q, int __user *p)
{
	int size, err = get_user(size, p);

	if (err)
		return err;

	if (size < 0)
		return -EINVAL;
	if (size > (queue_max_sectors(q) << 9))
		size = queue_max_sectors(q) << 9;

	q->sg_reserved_size = size;
	return 0;
}

/*
 * will always return that we are ATAPI even for a real SCSI drive, I'm not
 * so sure this is worth doing anything about (why would you care??)
 */
static int sg_emulated_host(struct request_queue *q, int __user *p)
{
	return put_user(1, p);
}

void blk_set_cmd_filter_defaults(struct blk_cmd_filter *filter)
{
	/* Basic read-only commands */
	__set_bit(TEST_UNIT_READY, filter->read_ok);
	__set_bit(REQUEST_SENSE, filter->read_ok);
	__set_bit(READ_6, filter->read_ok);
	__set_bit(READ_10, filter->read_ok);
	__set_bit(READ_12, filter->read_ok);
	__set_bit(READ_16, filter->read_ok);
	__set_bit(READ_BUFFER, filter->read_ok);
	__set_bit(READ_DEFECT_DATA, filter->read_ok);
	__set_bit(READ_CAPACITY, filter->read_ok);
	__set_bit(READ_LONG, filter->read_ok);
	__set_bit(INQUIRY, filter->read_ok);
	__set_bit(MODE_SENSE, filter->read_ok);
	__set_bit(MODE_SENSE_10, filter->read_ok);
	__set_bit(LOG_SENSE, filter->read_ok);
	__set_bit(START_STOP, filter->read_ok);
	__set_bit(GPCMD_VERIFY_10, filter->read_ok);
	__set_bit(VERIFY_16, filter->read_ok);
	__set_bit(REPORT_LUNS, filter->read_ok);
	__set_bit(SERVICE_ACTION_IN, filter->read_ok);
	__set_bit(RECEIVE_DIAGNOSTIC, filter->read_ok);
	__set_bit(MAINTENANCE_IN, filter->read_ok);
	__set_bit(GPCMD_READ_BUFFER_CAPACITY, filter->read_ok);

	/* Audio CD commands */
	__set_bit(GPCMD_PLAY_CD, filter->read_ok);
	__set_bit(GPCMD_PLAY_AUDIO_10, filter->read_ok);
	__set_bit(GPCMD_PLAY_AUDIO_MSF, filter->read_ok);
	__set_bit(GPCMD_PLAY_AUDIO_TI, filter->read_ok);
	__set_bit(GPCMD_PAUSE_RESUME, filter->read_ok);

	/* CD/DVD data reading */
	__set_bit(GPCMD_READ_CD, filter->read_ok);
	__set_bit(GPCMD_READ_CD_MSF, filter->read_ok);
	__set_bit(GPCMD_READ_DISC_INFO, filter->read_ok);
	__set_bit(GPCMD_READ_CDVD_CAPACITY, filter->read_ok);
	__set_bit(GPCMD_READ_DVD_STRUCTURE, filter->read_ok);
	__set_bit(GPCMD_READ_HEADER, filter->read_ok);
	__set_bit(GPCMD_READ_TRACK_RZONE_INFO, filter->read_ok);
	__set_bit(GPCMD_READ_SUBCHANNEL, filter->read_ok);
	__set_bit(GPCMD_READ_TOC_PMA_ATIP, filter->read_ok);
	__set_bit(GPCMD_REPORT_KEY, filter->read_ok);
	__set_bit(GPCMD_SCAN, filter->read_ok);
	__set_bit(GPCMD_GET_CONFIGURATION, filter->read_ok);
	__set_bit(GPCMD_READ_FORMAT_CAPACITIES, filter->read_ok);
	__set_bit(GPCMD_GET_EVENT_STATUS_NOTIFICATION, filter->read_ok);
	__set_bit(GPCMD_GET_PERFORMANCE, filter->read_ok);
	__set_bit(GPCMD_SEEK, filter->read_ok);
	__set_bit(GPCMD_STOP_PLAY_SCAN, filter->read_ok);

	/* Basic writing commands */
	__set_bit(WRITE_6, filter->write_ok);
	__set_bit(WRITE_10, filter->write_ok);
	__set_bit(WRITE_VERIFY, filter->write_ok);
	__set_bit(WRITE_12, filter->write_ok);
	__set_bit(WRITE_VERIFY_12, filter->write_ok);
	__set_bit(WRITE_16, filter->write_ok);
	__set_bit(WRITE_LONG, filter->write_ok);
	__set_bit(WRITE_LONG_2, filter->write_ok);
	__set_bit(ERASE, filter->write_ok);
	__set_bit(GPCMD_MODE_SELECT_10, filter->write_ok);
	__set_bit(MODE_SELECT, filter->write_ok);
	__set_bit(LOG_SELECT, filter->write_ok);
	__set_bit(GPCMD_BLANK, filter->write_ok);
	__set_bit(GPCMD_CLOSE_TRACK, filter->write_ok);
	__set_bit(GPCMD_FLUSH_CACHE, filter->write_ok);
	__set_bit(GPCMD_FORMAT_UNIT, filter->write_ok);
	__set_bit(GPCMD_REPAIR_RZONE_TRACK, filter->write_ok);
	__set_bit(GPCMD_RESERVE_RZONE_TRACK, filter->write_ok);
	__set_bit(GPCMD_SEND_DVD_STRUCTURE, filter->write_ok);
	__set_bit(GPCMD_SEND_EVENT, filter->write_ok);
	__set_bit(GPCMD_SEND_KEY, filter->write_ok);
	__set_bit(GPCMD_SEND_OPC, filter->write_ok);
	__set_bit(GPCMD_SEND_CUE_SHEET, filter->write_ok);
	__set_bit(GPCMD_SET_SPEED, filter->write_ok);
	__set_bit(GPCMD_PREVENT_ALLOW_MEDIUM_REMOVAL, filter->write_ok);
	__set_bit(GPCMD_LOAD_UNLOAD, filter->write_ok);
	__set_bit(GPCMD_SET_STREAMING, filter->write_ok);
	__set_bit(GPCMD_SET_READ_AHEAD, filter->write_ok);
}
EXPORT_SYMBOL_GPL(blk_set_cmd_filter_defaults);

static int blk_fill_sghdr_rq(struct request_queue *q, struct request *rq,
			     struct sg_io_hdr *hdr, fmode_t mode)
{
	if (copy_from_user(rq->cmd, hdr->cmdp, hdr->cmd_len))
		return -EFAULT;
	if (blk_verify_command(&q->cmd_filter, rq->cmd, mode & FMODE_WRITE))
		return -EPERM;

	/*
	 * fill in request structure
	 */
	rq->cmd_len = hdr->cmd_len;
	rq->cmd_type = REQ_TYPE_BLOCK_PC;

	rq->timeout = msecs_to_jiffies(hdr->timeout);
	if (!rq->timeout)
		rq->timeout = q->sg_timeout;
	if (!rq->timeout)
		rq->timeout = BLK_DEFAULT_SG_TIMEOUT;
	if (rq->timeout < BLK_MIN_SG_TIMEOUT)
		rq->timeout = BLK_MIN_SG_TIMEOUT;

	return 0;
}

static int blk_complete_sghdr_rq(struct request *rq, struct sg_io_hdr *hdr,
				 struct bio *bio)
{
	int r, ret = 0;

	/*
	 * fill in all the output members
	 */
	hdr->status = rq->errors & 0xff;
	hdr->masked_status = status_byte(rq->errors);
	hdr->msg_status = msg_byte(rq->errors);
	hdr->host_status = host_byte(rq->errors);
	hdr->driver_status = driver_byte(rq->errors);
	hdr->info = 0;
	if (hdr->masked_status || hdr->host_status || hdr->driver_status)
		hdr->info |= SG_INFO_CHECK;
	hdr->resid = rq->resid_len;
	hdr->sb_len_wr = 0;

	if (rq->sense_len && hdr->sbp) {
		int len = min((unsigned int) hdr->mx_sb_len, rq->sense_len);

		if (!copy_to_user(hdr->sbp, rq->sense, len))
			hdr->sb_len_wr = len;
		else
			ret = -EFAULT;
	}

	r = blk_rq_unmap_user(bio);
	if (!ret)
		ret = r;
	blk_put_request(rq);

	return ret;
}

static int sg_io(struct request_queue *q, struct gendisk *bd_disk,
		struct sg_io_hdr *hdr, fmode_t mode)
{
	unsigned long start_time;
	int writing = 0, ret = 0;
	struct request *rq;
	char sense[SCSI_SENSE_BUFFERSIZE];
	struct bio *bio;

	if (hdr->interface_id != 'S')
		return -EINVAL;
	if (hdr->cmd_len > BLK_MAX_CDB)
		return -EINVAL;

	if (hdr->dxfer_len > (queue_max_hw_sectors(q) << 9))
		return -EIO;

	if (hdr->dxfer_len)
		switch (hdr->dxfer_direction) {
		default:
			return -EINVAL;
		case SG_DXFER_TO_DEV:
			writing = 1;
			break;
		case SG_DXFER_TO_FROM_DEV:
		case SG_DXFER_FROM_DEV:
			break;
		}

	rq = blk_get_request(q, writing ? WRITE : READ, GFP_KERNEL);
	if (!rq)
		return -ENOMEM;

	if (blk_fill_sghdr_rq(q, rq, hdr, mode)) {
		blk_put_request(rq);
		return -EFAULT;
	}

	if (hdr->iovec_count) {
		const int size = sizeof(struct sg_iovec) * hdr->iovec_count;
		size_t iov_data_len;
		struct sg_iovec *iov;

		iov = kmalloc(size, GFP_KERNEL);
		if (!iov) {
			ret = -ENOMEM;
			goto out;
		}

		if (copy_from_user(iov, hdr->dxferp, size)) {
			kfree(iov);
			ret = -EFAULT;
			goto out;
		}

		/* SG_IO howto says that the shorter of the two wins */
		iov_data_len = iov_length((struct iovec *)iov,
					  hdr->iovec_count);
		if (hdr->dxfer_len < iov_data_len) {
			hdr->iovec_count = iov_shorten((struct iovec *)iov,
						       hdr->iovec_count,
						       hdr->dxfer_len);
			iov_data_len = hdr->dxfer_len;
		}

		ret = blk_rq_map_user_iov(q, rq, NULL, iov, hdr->iovec_count,
					  iov_data_len, GFP_KERNEL);
		kfree(iov);
	} else if (hdr->dxfer_len)
		ret = blk_rq_map_user(q, rq, NULL, hdr->dxferp, hdr->dxfer_len,
				      GFP_KERNEL);

	if (ret)
		goto out;

	bio = rq->bio;
	memset(sense, 0, sizeof(sense));
	rq->sense = sense;
	rq->sense_len = 0;
	rq->retries = 0;

	start_time = jiffies;

	/* ignore return value. All information is passed back to caller
	 * (if he doesn't check that is his problem).
	 * N.B. a non-zero SCSI status is _not_ necessarily an error.
	 */
	blk_execute_rq(q, bd_disk, rq, 0);

	hdr->duration = jiffies_to_msecs(jiffies - start_time);

	return blk_complete_sghdr_rq(rq, hdr, bio);
out:
	blk_put_request(rq);
	return ret;
}

/**
 * sg_scsi_ioctl  --  handle deprecated SCSI_IOCTL_SEND_COMMAND ioctl
 * @file:	file this ioctl operates on (optional)
 * @q:		request queue to send scsi commands down
 * @disk:	gendisk to operate on (option)
 * @sic:	userspace structure describing the command to perform
 *
 * Send down the scsi command described by @sic to the device below
 * the request queue @q.  If @file is non-NULL it's used to perform
 * fine-grained permission checks that allow users to send down
 * non-destructive SCSI commands.  If the caller has a struct gendisk
 * available it should be passed in as @disk to allow the low level
 * driver to use the information contained in it.  A non-NULL @disk
 * is only allowed if the caller knows that the low level driver doesn't
 * need it (e.g. in the scsi subsystem).
 *
 * Notes:
 *   -  This interface is deprecated - users should use the SG_IO
 *      interface instead, as this is a more flexible approach to
 *      performing SCSI commands on a device.
 *   -  The SCSI command length is determined by examining the 1st byte
 *      of the given command. There is no way to override this.
 *   -  Data transfers are limited to PAGE_SIZE
 *   -  The length (x + y) must be at least OMAX_SB_LEN bytes long to
 *      accommodate the sense buffer when an error occurs.
 *      The sense buffer is truncated to OMAX_SB_LEN (16) bytes so that
 *      old code will not be surprised.
 *   -  If a Unix error occurs (e.g. ENOMEM) then the user will receive
 *      a negative return and the Unix error code in 'errno'.
 *      If the SCSI command succeeds then 0 is returned.
 *      Positive numbers returned are the compacted SCSI error codes (4
 *      bytes in one int) where the lowest byte is the SCSI status.
 */
#define OMAX_SB_LEN 16          /* For backward compatibility */
int sg_scsi_ioctl(struct request_queue *q, struct gendisk *disk, fmode_t mode,
		struct scsi_ioctl_command __user *sic)
{
	struct request *rq;
	int err;
	unsigned int in_len, out_len, bytes, opcode, cmdlen;
	char *buffer = NULL, sense[SCSI_SENSE_BUFFERSIZE];

	if (!sic)
		return -EINVAL;

	/*
	 * get in an out lengths, verify they don't exceed a page worth of data
	 */
	if (get_user(in_len, &sic->inlen))
		return -EFAULT;
	if (get_user(out_len, &sic->outlen))
		return -EFAULT;
	if (in_len > PAGE_SIZE || out_len > PAGE_SIZE)
		return -EINVAL;
	if (get_user(opcode, sic->data))
		return -EFAULT;

	bytes = max(in_len, out_len);
	if (bytes) {
		buffer = kzalloc(bytes, q->bounce_gfp | GFP_USER| __GFP_NOWARN);
		if (!buffer)
			return -ENOMEM;

	}

	rq = blk_get_request(q, in_len ? WRITE : READ, __GFP_WAIT);

	cmdlen = COMMAND_SIZE(opcode);

	/*
	 * get command and data to send to device, if any
	 */
	err = -EFAULT;
	rq->cmd_len = cmdlen;
	if (copy_from_user(rq->cmd, sic->data, cmdlen))
		goto error;

	if (in_len && copy_from_user(buffer, sic->data + cmdlen, in_len))
		goto error;

	err = blk_verify_command(&q->cmd_filter, rq->cmd, mode & FMODE_WRITE);
	if (err)
		goto error;

	/* default.  possible overriden later */
	rq->retries = 5;

	switch (opcode) {
	case SEND_DIAGNOSTIC:
	case FORMAT_UNIT:
		rq->timeout = FORMAT_UNIT_TIMEOUT;
		rq->retries = 1;
		break;
	case START_STOP:
		rq->timeout = START_STOP_TIMEOUT;
		break;
	case MOVE_MEDIUM:
		rq->timeout = MOVE_MEDIUM_TIMEOUT;
		break;
	case READ_ELEMENT_STATUS:
		rq->timeout = READ_ELEMENT_STATUS_TIMEOUT;
		break;
	case READ_DEFECT_DATA:
		rq->timeout = READ_DEFECT_DATA_TIMEOUT;
		rq->retries = 1;
		break;
	default:
		rq->timeout = BLK_DEFAULT_SG_TIMEOUT;
		break;
	}

	if (bytes && blk_rq_map_kern(q, rq, buffer, bytes, __GFP_WAIT)) {
		err = DRIVER_ERROR << 24;
		goto out;
	}

	memset(sense, 0, sizeof(sense));
	rq->sense = sense;
	rq->sense_len = 0;
	rq->cmd_type = REQ_TYPE_BLOCK_PC;

	blk_execute_rq(q, disk, rq, 0);

out:
	err = rq->errors & 0xff;	/* only 8 bit SCSI status */
	if (err) {
		if (rq->sense_len && rq->sense) {
			bytes = (OMAX_SB_LEN > rq->sense_len) ?
				rq->sense_len : OMAX_SB_LEN;
			if (copy_to_user(sic->data, rq->sense, bytes))
				err = -EFAULT;
		}
	} else {
		if (copy_to_user(sic->data, buffer, out_len))
			err = -EFAULT;
	}
	
error:
	kfree(buffer);
	blk_put_request(rq);
	return err;
}
EXPORT_SYMBOL_GPL(sg_scsi_ioctl);

/* Send basic block requests */
static int __blk_send_generic(struct request_queue *q, struct gendisk *bd_disk,
			      int cmd, int data)
{
	struct request *rq;
	int err;

	rq = blk_get_request(q, WRITE, __GFP_WAIT);
	rq->cmd_type = REQ_TYPE_BLOCK_PC;
	rq->timeout = BLK_DEFAULT_SG_TIMEOUT;
	rq->cmd[0] = cmd;
	rq->cmd[4] = data;
	rq->cmd_len = 6;
	err = blk_execute_rq(q, bd_disk, rq, 0);
	blk_put_request(rq);

	return err;
}

static inline int blk_send_start_stop(struct request_queue *q,
				      struct gendisk *bd_disk, int data)
{
	return __blk_send_generic(q, bd_disk, GPCMD_START_STOP_UNIT, data);
}

int scsi_cmd_ioctl(struct request_queue *q, struct gendisk *bd_disk, fmode_t mode,
		   unsigned int cmd, void __user *arg)
{
	int err;

	if (!q || blk_get_queue(q))
		return -ENXIO;

	switch (cmd) {
		/*
		 * new sgv3 interface
		 */
		case SG_GET_VERSION_NUM:
			err = sg_get_version(arg);
			break;
		case SCSI_IOCTL_GET_IDLUN:
			err = scsi_get_idlun(q, arg);
			break;
		case SCSI_IOCTL_GET_BUS_NUMBER:
			err = scsi_get_bus(q, arg);
			break;
		case SG_SET_TIMEOUT:
			err = sg_set_timeout(q, arg);
			break;
		case SG_GET_TIMEOUT:
			err = sg_get_timeout(q);
			break;
		case SG_GET_RESERVED_SIZE:
			err = sg_get_reserved_size(q, arg);
			break;
		case SG_SET_RESERVED_SIZE:
			err = sg_set_reserved_size(q, arg);
			break;
		case SG_EMULATED_HOST:
			err = sg_emulated_host(q, arg);
			break;
		case SG_IO: {
			struct sg_io_hdr hdr;

			err = -EFAULT;
			if (copy_from_user(&hdr, arg, sizeof(hdr)))
				break;
			err = sg_io(q, bd_disk, &hdr, mode);
			if (err == -EFAULT)
				break;

			if (copy_to_user(arg, &hdr, sizeof(hdr)))
				err = -EFAULT;
			break;
		}
		case CDROM_SEND_PACKET: {
			struct cdrom_generic_command cgc;
			struct sg_io_hdr hdr;

			err = -EFAULT;
			if (copy_from_user(&cgc, arg, sizeof(cgc)))
				break;
			cgc.timeout = clock_t_to_jiffies(cgc.timeout);
			memset(&hdr, 0, sizeof(hdr));
			hdr.interface_id = 'S';
			hdr.cmd_len = sizeof(cgc.cmd);
			hdr.dxfer_len = cgc.buflen;
			err = 0;
			switch (cgc.data_direction) {
				case CGC_DATA_UNKNOWN:
					hdr.dxfer_direction = SG_DXFER_UNKNOWN;
					break;
				case CGC_DATA_WRITE:
					hdr.dxfer_direction = SG_DXFER_TO_DEV;
					break;
				case CGC_DATA_READ:
					hdr.dxfer_direction = SG_DXFER_FROM_DEV;
					break;
				case CGC_DATA_NONE:
					hdr.dxfer_direction = SG_DXFER_NONE;
					break;
				default:
					err = -EINVAL;
			}
			if (err)
				break;

			hdr.dxferp = cgc.buffer;
			hdr.sbp = cgc.sense;
			if (hdr.sbp)
				hdr.mx_sb_len = sizeof(struct request_sense);
			hdr.timeout = jiffies_to_msecs(cgc.timeout);
			hdr.cmdp = ((struct cdrom_generic_command __user*) arg)->cmd;
			hdr.cmd_len = sizeof(cgc.cmd);

			err = sg_io(q, bd_disk, &hdr, mode);
			if (err == -EFAULT)
				break;

			if (hdr.status)
				err = -EIO;

			cgc.stat = err;
			cgc.buflen = hdr.resid;
			if (copy_to_user(arg, &cgc, sizeof(cgc)))
				err = -EFAULT;

			break;
		}

		/*
		 * old junk scsi send command ioctl
		 */
		case SCSI_IOCTL_SEND_COMMAND:
			printk(KERN_WARNING "program %s is using a deprecated SCSI ioctl, please convert it to SG_IO\n", current->comm);
			err = -EINVAL;
			if (!arg)
				break;

			err = sg_scsi_ioctl(q, bd_disk, mode, arg);
			break;
		case CDROMCLOSETRAY:
			err = blk_send_start_stop(q, bd_disk, 0x03);
			break;
		case CDROMEJECT:
			err = blk_send_start_stop(q, bd_disk, 0x02);
			break;
		default:
			err = -ENOTTY;
	}

	blk_put_queue(q);
	return err;
}

EXPORT_SYMBOL(scsi_cmd_ioctl);
Commit	Line	Data
1da177e4 LT	1	/*
	2	* Copyright (C) 2001 Jens Axboe <[email protected]>
	3	*
	4	* This program is free software; you can redistribute it and/or modify
	5	* it under the terms of the GNU General Public License version 2 as
	6	* published by the Free Software Foundation.
	7	*
	8	* This program is distributed in the hope that it will be useful,
	9	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	10	*
	11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	* GNU General Public License for more details.
	13	*
	14	* You should have received a copy of the GNU General Public Licens
	15	* along with this program; if not, write to the Free Software
	16	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-
	17	*
	18	*/
	19	#include <linux/kernel.h>
	20	#include <linux/errno.h>
	21	#include <linux/string.h>
	22	#include <linux/module.h>
	23	#include <linux/blkdev.h>
c59ede7b	24	#include <linux/capability.h>
1da177e4 LT	25	#include <linux/completion.h>
	26	#include <linux/cdrom.h>
	27	#include <linux/slab.h>
	28	#include <linux/times.h>
	29	#include <asm/uaccess.h>
	30
	31	#include <scsi/scsi.h>
	32	#include <scsi/scsi_ioctl.h>
	33	#include <scsi/scsi_cmnd.h>
	34
	35	/* Command group 3 is reserved and should never be used. */
db4742dd	36	const unsigned char scsi_command_size_tbl[8] =
1da177e4 LT	37	{
	38	6, 10, 10, 12,
	39	16, 12, 10, 10
	40	};
db4742dd	41	EXPORT_SYMBOL(scsi_command_size_tbl);
1da177e4	42
1da177e4 LT	43	#include <scsi/sg.h>
	44
	45	static int sg_get_version(int __user *p)
	46	{
64100099	47	static const int sg_version_num = 30527;
1da177e4 LT	48	return put_user(sg_version_num, p);
	49	}
	50
165125e1	51	static int scsi_get_idlun(struct request_queue q, int __user p)
1da177e4 LT	52	{
	53	return put_user(0, p);
	54	}
	55
165125e1	56	static int scsi_get_bus(struct request_queue q, int __user p)
1da177e4 LT	57	{
	58	return put_user(0, p);
	59	}
	60
165125e1	61	static int sg_get_timeout(struct request_queue *q)
1da177e4	62	{
2b91bafc	63	return jiffies_to_clock_t(q->sg_timeout);
1da177e4 LT	64	}
1da177e4 LT	65
165125e1	66	static int sg_set_timeout(struct request_queue q, int __user p)
1da177e4 LT	67	{
	68	int timeout, err = get_user(timeout, p);
	69
	70	if (!err)
2b91bafc	71	q->sg_timeout = clock_t_to_jiffies(timeout);
1da177e4 LT	72
	73	return err;
	74	}
	75
165125e1	76	static int sg_get_reserved_size(struct request_queue q, int __user p)
1da177e4	77	{
ae03bf63	78	unsigned val = min(q->sg_reserved_size, queue_max_sectors(q) << 9);
44ec9542 AS	79
44ec9542 AS	80	return put_user(val, p);
1da177e4 LT	81	}
1da177e4 LT	82
165125e1	83	static int sg_set_reserved_size(struct request_queue q, int __user p)
1da177e4 LT	84	{
	85	int size, err = get_user(size, p);
	86
	87	if (err)
	88	return err;
	89
	90	if (size < 0)
	91	return -EINVAL;
ae03bf63 MP	92	if (size > (queue_max_sectors(q) << 9))
ae03bf63 MP	93	size = queue_max_sectors(q) << 9;
1da177e4 LT	94
	95	q->sg_reserved_size = size;
	96	return 0;
	97	}
	98
	99	/*
	100	* will always return that we are ATAPI even for a real SCSI drive, I'm not
	101	* so sure this is worth doing anything about (why would you care??)
	102	*/
165125e1	103	static int sg_emulated_host(struct request_queue q, int __user p)
1da177e4 LT	104	{
	105	return put_user(1, p);
	106	}
	107
4beab5c6	108	void blk_set_cmd_filter_defaults(struct blk_cmd_filter *filter)
abf54393 FT	109	{
	110	/* Basic read-only commands */
	111	__set_bit(TEST_UNIT_READY, filter->read_ok);
	112	__set_bit(REQUEST_SENSE, filter->read_ok);
	113	__set_bit(READ_6, filter->read_ok);
	114	__set_bit(READ_10, filter->read_ok);
	115	__set_bit(READ_12, filter->read_ok);
	116	__set_bit(READ_16, filter->read_ok);
	117	__set_bit(READ_BUFFER, filter->read_ok);
	118	__set_bit(READ_DEFECT_DATA, filter->read_ok);
	119	__set_bit(READ_CAPACITY, filter->read_ok);
	120	__set_bit(READ_LONG, filter->read_ok);
	121	__set_bit(INQUIRY, filter->read_ok);
	122	__set_bit(MODE_SENSE, filter->read_ok);
	123	__set_bit(MODE_SENSE_10, filter->read_ok);
	124	__set_bit(LOG_SENSE, filter->read_ok);
	125	__set_bit(START_STOP, filter->read_ok);
	126	__set_bit(GPCMD_VERIFY_10, filter->read_ok);
	127	__set_bit(VERIFY_16, filter->read_ok);
	128	__set_bit(REPORT_LUNS, filter->read_ok);
	129	__set_bit(SERVICE_ACTION_IN, filter->read_ok);
	130	__set_bit(RECEIVE_DIAGNOSTIC, filter->read_ok);
	131	__set_bit(MAINTENANCE_IN, filter->read_ok);
	132	__set_bit(GPCMD_READ_BUFFER_CAPACITY, filter->read_ok);
	133
	134	/* Audio CD commands */
	135	__set_bit(GPCMD_PLAY_CD, filter->read_ok);
	136	__set_bit(GPCMD_PLAY_AUDIO_10, filter->read_ok);
	137	__set_bit(GPCMD_PLAY_AUDIO_MSF, filter->read_ok);
	138	__set_bit(GPCMD_PLAY_AUDIO_TI, filter->read_ok);
	139	__set_bit(GPCMD_PAUSE_RESUME, filter->read_ok);
	140
	141	/* CD/DVD data reading */
	142	__set_bit(GPCMD_READ_CD, filter->read_ok);
	143	__set_bit(GPCMD_READ_CD_MSF, filter->read_ok);
	144	__set_bit(GPCMD_READ_DISC_INFO, filter->read_ok);
	145	__set_bit(GPCMD_READ_CDVD_CAPACITY, filter->read_ok);
	146	__set_bit(GPCMD_READ_DVD_STRUCTURE, filter->read_ok);
	147	__set_bit(GPCMD_READ_HEADER, filter->read_ok);
	148	__set_bit(GPCMD_READ_TRACK_RZONE_INFO, filter->read_ok);
	149	__set_bit(GPCMD_READ_SUBCHANNEL, filter->read_ok);
	150	__set_bit(GPCMD_READ_TOC_PMA_ATIP, filter->read_ok);
	151	__set_bit(GPCMD_REPORT_KEY, filter->read_ok);
	152	__set_bit(GPCMD_SCAN, filter->read_ok);
	153	__set_bit(GPCMD_GET_CONFIGURATION, filter->read_ok);
	154	__set_bit(GPCMD_READ_FORMAT_CAPACITIES, filter->read_ok);
	155	__set_bit(GPCMD_GET_EVENT_STATUS_NOTIFICATION, filter->read_ok);
	156	__set_bit(GPCMD_GET_PERFORMANCE, filter->read_ok);
	157	__set_bit(GPCMD_SEEK, filter->read_ok);
	158	__set_bit(GPCMD_STOP_PLAY_SCAN, filter->read_ok);
	159
	160	/* Basic writing commands */
	161	__set_bit(WRITE_6, filter->write_ok);
	162	__set_bit(WRITE_10, filter->write_ok);
	163	__set_bit(WRITE_VERIFY, filter->write_ok);
	164	__set_bit(WRITE_12, filter->write_ok);
	165	__set_bit(WRITE_VERIFY_12, filter->write_ok);
	166	__set_bit(WRITE_16, filter->write_ok);
	167	__set_bit(WRITE_LONG, filter->write_ok);
	168	__set_bit(WRITE_LONG_2, filter->write_ok);
	169	__set_bit(ERASE, filter->write_ok);
	170	__set_bit(GPCMD_MODE_SELECT_10, filter->write_ok);
	171	__set_bit(MODE_SELECT, filter->write_ok);
	172	__set_bit(LOG_SELECT, filter->write_ok);
173	__set_bit(GPCMD_BLANK, filter->write_ok);
174	__set_bit(GPCMD_CLOSE_TRACK, filter->write_ok);
175	__set_bit(GPCMD_FLUSH_CACHE, filter->write_ok);
176	__set_bit(GPCMD_FORMAT_UNIT, filter->write_ok);
177	__set_bit(GPCMD_REPAIR_RZONE_TRACK, filter->write_ok);
178	__set_bit(GPCMD_RESERVE_RZONE_TRACK, filter->write_ok);
179	__set_bit(GPCMD_SEND_DVD_STRUCTURE, filter->write_ok);
180	__set_bit(GPCMD_SEND_EVENT, filter->write_ok);
181	__set_bit(GPCMD_SEND_KEY, filter->write_ok);
182	__set_bit(GPCMD_SEND_OPC, filter->write_ok);
183	__set_bit(GPCMD_SEND_CUE_SHEET, filter->write_ok);
184	__set_bit(GPCMD_SET_SPEED, filter->write_ok);
185	__set_bit(GPCMD_PREVENT_ALLOW_MEDIUM_REMOVAL, filter->write_ok);
186	__set_bit(GPCMD_LOAD_UNLOAD, filter->write_ok);
187	__set_bit(GPCMD_SET_STREAMING, filter->write_ok);
35e396cd	188	__set_bit(GPCMD_SET_READ_AHEAD, filter->write_ok);
abf54393 FT	189	}
	190	EXPORT_SYMBOL_GPL(blk_set_cmd_filter_defaults);
	191
165125e1	192	static int blk_fill_sghdr_rq(struct request_queue q, struct request rq,
5842e51f	193	struct sg_io_hdr *hdr, fmode_t mode)
3d6392cf	194	{
3d6392cf JA	195	if (copy_from_user(rq->cmd, hdr->cmdp, hdr->cmd_len))
3d6392cf JA	196	return -EFAULT;
5842e51f	197	if (blk_verify_command(&q->cmd_filter, rq->cmd, mode & FMODE_WRITE))
3d6392cf JA	198	return -EPERM;
	199
	200	/*
	201	* fill in request structure
	202	*/
	203	rq->cmd_len = hdr->cmd_len;
	204	rq->cmd_type = REQ_TYPE_BLOCK_PC;
	205
24bb8fb9	206	rq->timeout = msecs_to_jiffies(hdr->timeout);
3d6392cf JA	207	if (!rq->timeout)
	208	rq->timeout = q->sg_timeout;
	209	if (!rq->timeout)
	210	rq->timeout = BLK_DEFAULT_SG_TIMEOUT;
f2f1fa78 LT	211	if (rq->timeout < BLK_MIN_SG_TIMEOUT)
f2f1fa78 LT	212	rq->timeout = BLK_MIN_SG_TIMEOUT;
3d6392cf JA	213
	214	return 0;
	215	}
3d6392cf	216
41e1703b FT	217	static int blk_complete_sghdr_rq(struct request rq, struct sg_io_hdr hdr,
41e1703b FT	218	struct bio *bio)
3d6392cf	219	{
91e463c8	220	int r, ret = 0;
3d6392cf JA	221
	222	/*
	223	* fill in all the output members
	224	*/
	225	hdr->status = rq->errors & 0xff;
	226	hdr->masked_status = status_byte(rq->errors);
	227	hdr->msg_status = msg_byte(rq->errors);
	228	hdr->host_status = host_byte(rq->errors);
	229	hdr->driver_status = driver_byte(rq->errors);
	230	hdr->info = 0;
	231	if (hdr->masked_status \|\| hdr->host_status \|\| hdr->driver_status)
	232	hdr->info \|= SG_INFO_CHECK;
c3a4d78c	233	hdr->resid = rq->resid_len;
3d6392cf JA	234	hdr->sb_len_wr = 0;
	235
	236	if (rq->sense_len && hdr->sbp) {
	237	int len = min((unsigned int) hdr->mx_sb_len, rq->sense_len);
	238
	239	if (!copy_to_user(hdr->sbp, rq->sense, len))
	240	hdr->sb_len_wr = len;
	241	else
	242	ret = -EFAULT;
	243	}
	244
91e463c8 FT	245	r = blk_rq_unmap_user(bio);
	246	if (!ret)
	247	ret = r;
1cd96c24	248	blk_put_request(rq);
3d6392cf	249
1cd96c24	250	return ret;
3d6392cf	251	}
3d6392cf	252
5842e51f AV	253	static int sg_io(struct request_queue q, struct gendisk bd_disk,
5842e51f AV	254	struct sg_io_hdr *hdr, fmode_t mode)
1da177e4	255	{
3d6392cf	256	unsigned long start_time;
0b07de85	257	int writing = 0, ret = 0;
1da177e4	258	struct request *rq;
1da177e4	259	char sense[SCSI_SENSE_BUFFERSIZE];
77d172ce	260	struct bio *bio;
1da177e4 LT	261
	262	if (hdr->interface_id != 'S')
	263	return -EINVAL;
	264	if (hdr->cmd_len > BLK_MAX_CDB)
	265	return -EINVAL;
1da177e4	266
ae03bf63	267	if (hdr->dxfer_len > (queue_max_hw_sectors(q) << 9))
1da177e4 LT	268	return -EIO;
1da177e4 LT	269
f1970baf	270	if (hdr->dxfer_len)
1da177e4 LT	271	switch (hdr->dxfer_direction) {
	272	default:
	273	return -EINVAL;
1da177e4 LT	274	case SG_DXFER_TO_DEV:
	275	writing = 1;
	276	break;
616e8a09	277	case SG_DXFER_TO_FROM_DEV:
1da177e4	278	case SG_DXFER_FROM_DEV:
1da177e4 LT	279	break;
	280	}
	281
dd1cab95 JA	282	rq = blk_get_request(q, writing ? WRITE : READ, GFP_KERNEL);
	283	if (!rq)
	284	return -ENOMEM;
1da177e4	285
5842e51f	286	if (blk_fill_sghdr_rq(q, rq, hdr, mode)) {
3d6392cf JA	287	blk_put_request(rq);
	288	return -EFAULT;
	289	}
1da177e4	290
0e75f906 MC	291	if (hdr->iovec_count) {
0e75f906 MC	292	const int size = sizeof(struct sg_iovec) * hdr->iovec_count;
25636e28	293	size_t iov_data_len;
0e75f906 MC	294	struct sg_iovec *iov;
	295
	296	iov = kmalloc(size, GFP_KERNEL);
	297	if (!iov) {
	298	ret = -ENOMEM;
	299	goto out;
	300	}
	301
	302	if (copy_from_user(iov, hdr->dxferp, size)) {
	303	kfree(iov);
	304	ret = -EFAULT;
	305	goto out;
	306	}
	307
25636e28 TH	308	/* SG_IO howto says that the shorter of the two wins */
	309	iov_data_len = iov_length((struct iovec *)iov,
	310	hdr->iovec_count);
	311	if (hdr->dxfer_len < iov_data_len) {
	312	hdr->iovec_count = iov_shorten((struct iovec *)iov,
	313	hdr->iovec_count,
	314	hdr->dxfer_len);
	315	iov_data_len = hdr->dxfer_len;
	316	}
	317
152e283f	318	ret = blk_rq_map_user_iov(q, rq, NULL, iov, hdr->iovec_count,
25636e28	319	iov_data_len, GFP_KERNEL);
0e75f906 MC	320	kfree(iov);
0e75f906 MC	321	} else if (hdr->dxfer_len)
152e283f	322	ret = blk_rq_map_user(q, rq, NULL, hdr->dxferp, hdr->dxfer_len,
a3bce90e	323	GFP_KERNEL);
0e75f906 MC	324
	325	if (ret)
	326	goto out;
	327
77d172ce	328	bio = rq->bio;
3d6392cf JA	329	memset(sense, 0, sizeof(sense));
	330	rq->sense = sense;
	331	rq->sense_len = 0;
01840f9c JA	332	rq->retries = 0;
01840f9c JA	333
1da177e4 LT	334	start_time = jiffies;
	335
	336	/* ignore return value. All information is passed back to caller
	337	* (if he doesn't check that is his problem).
	338	* N.B. a non-zero SCSI status is _not_ necessarily an error.
	339	*/
994ca9a1	340	blk_execute_rq(q, bd_disk, rq, 0);
1da177e4	341
24bb8fb9	342	hdr->duration = jiffies_to_msecs(jiffies - start_time);
1da177e4	343
3d6392cf	344	return blk_complete_sghdr_rq(rq, hdr, bio);
dd1cab95 JA	345	out:
	346	blk_put_request(rq);
	347	return ret;
1da177e4 LT	348	}
1da177e4 LT	349
21b2f0c8 CH	350	/**
	351	* sg_scsi_ioctl -- handle deprecated SCSI_IOCTL_SEND_COMMAND ioctl
	352	* @file: file this ioctl operates on (optional)
	353	* @q: request queue to send scsi commands down
	354	* @disk: gendisk to operate on (option)
	355	* @sic: userspace structure describing the command to perform
	356	*
	357	* Send down the scsi command described by @sic to the device below
	358	* the request queue @q. If @file is non-NULL it's used to perform
	359	* fine-grained permission checks that allow users to send down
	360	* non-destructive SCSI commands. If the caller has a struct gendisk
	361	* available it should be passed in as @disk to allow the low level
	362	* driver to use the information contained in it. A non-NULL @disk
	363	* is only allowed if the caller knows that the low level driver doesn't
	364	* need it (e.g. in the scsi subsystem).
	365	*
	366	* Notes:
	367	* - This interface is deprecated - users should use the SG_IO
	368	* interface instead, as this is a more flexible approach to
	369	* performing SCSI commands on a device.
	370	* - The SCSI command length is determined by examining the 1st byte
	371	* of the given command. There is no way to override this.
	372	* - Data transfers are limited to PAGE_SIZE
	373	* - The length (x + y) must be at least OMAX_SB_LEN bytes long to
	374	* accommodate the sense buffer when an error occurs.
	375	* The sense buffer is truncated to OMAX_SB_LEN (16) bytes so that
	376	* old code will not be surprised.
	377	* - If a Unix error occurs (e.g. ENOMEM) then the user will receive
	378	* a negative return and the Unix error code in 'errno'.
	379	* If the SCSI command succeeds then 0 is returned.
	380	* Positive numbers returned are the compacted SCSI error codes (4
	381	* bytes in one int) where the lowest byte is the SCSI status.
	382	*/
1da177e4	383	#define OMAX_SB_LEN 16 /* For backward compatibility */
e915e872 AV	384	int sg_scsi_ioctl(struct request_queue q, struct gendisk disk, fmode_t mode,
e915e872 AV	385	struct scsi_ioctl_command __user *sic)
1da177e4 LT	386	{
1da177e4 LT	387	struct request *rq;
aeb5d727	388	int err;
1da177e4 LT	389	unsigned int in_len, out_len, bytes, opcode, cmdlen;
	390	char *buffer = NULL, sense[SCSI_SENSE_BUFFERSIZE];
	391
21b2f0c8 CH	392	if (!sic)
	393	return -EINVAL;
	394
1da177e4 LT	395	/*
	396	* get in an out lengths, verify they don't exceed a page worth of data
	397	*/
	398	if (get_user(in_len, &sic->inlen))
	399	return -EFAULT;
	400	if (get_user(out_len, &sic->outlen))
	401	return -EFAULT;
	402	if (in_len > PAGE_SIZE \|\| out_len > PAGE_SIZE)
	403	return -EINVAL;
	404	if (get_user(opcode, sic->data))
	405	return -EFAULT;
	406
	407	bytes = max(in_len, out_len);
	408	if (bytes) {
dd00cc48	409	buffer = kzalloc(bytes, q->bounce_gfp \| GFP_USER\| __GFP_NOWARN);
1da177e4 LT	410	if (!buffer)
	411	return -ENOMEM;
	412
1da177e4 LT	413	}
	414
	415	rq = blk_get_request(q, in_len ? WRITE : READ, __GFP_WAIT);
	416
	417	cmdlen = COMMAND_SIZE(opcode);
	418
	419	/*
	420	* get command and data to send to device, if any
	421	*/
	422	err = -EFAULT;
	423	rq->cmd_len = cmdlen;
	424	if (copy_from_user(rq->cmd, sic->data, cmdlen))
	425	goto error;
	426
21b2f0c8	427	if (in_len && copy_from_user(buffer, sic->data + cmdlen, in_len))
1da177e4 LT	428	goto error;
1da177e4 LT	429
e915e872	430	err = blk_verify_command(&q->cmd_filter, rq->cmd, mode & FMODE_WRITE);
1da177e4 LT	431	if (err)
	432	goto error;
	433
21b2f0c8 CH	434	/* default. possible overriden later */
	435	rq->retries = 5;
	436
1da177e4	437	switch (opcode) {
21b2f0c8 CH	438	case SEND_DIAGNOSTIC:
	439	case FORMAT_UNIT:
	440	rq->timeout = FORMAT_UNIT_TIMEOUT;
	441	rq->retries = 1;
	442	break;
	443	case START_STOP:
	444	rq->timeout = START_STOP_TIMEOUT;
	445	break;
	446	case MOVE_MEDIUM:
	447	rq->timeout = MOVE_MEDIUM_TIMEOUT;
	448	break;
	449	case READ_ELEMENT_STATUS:
	450	rq->timeout = READ_ELEMENT_STATUS_TIMEOUT;
	451	break;
	452	case READ_DEFECT_DATA:
	453	rq->timeout = READ_DEFECT_DATA_TIMEOUT;
	454	rq->retries = 1;
	455	break;
	456	default:
3d6392cf	457	rq->timeout = BLK_DEFAULT_SG_TIMEOUT;
21b2f0c8 CH	458	break;
	459	}
	460
	461	if (bytes && blk_rq_map_kern(q, rq, buffer, bytes, __GFP_WAIT)) {
	462	err = DRIVER_ERROR << 24;
	463	goto out;
1da177e4 LT	464	}
	465
	466	memset(sense, 0, sizeof(sense));
	467	rq->sense = sense;
	468	rq->sense_len = 0;
4aff5e23	469	rq->cmd_type = REQ_TYPE_BLOCK_PC;
1da177e4	470
21b2f0c8 CH	471	blk_execute_rq(q, disk, rq, 0);
	472
	473	out:
1da177e4 LT	474	err = rq->errors & 0xff; /* only 8 bit SCSI status */
	475	if (err) {
	476	if (rq->sense_len && rq->sense) {
	477	bytes = (OMAX_SB_LEN > rq->sense_len) ?
	478	rq->sense_len : OMAX_SB_LEN;
	479	if (copy_to_user(sic->data, rq->sense, bytes))
	480	err = -EFAULT;
	481	}
	482	} else {
	483	if (copy_to_user(sic->data, buffer, out_len))
	484	err = -EFAULT;
	485	}
	486
	487	error:
	488	kfree(buffer);
	489	blk_put_request(rq);
	490	return err;
	491	}
21b2f0c8	492	EXPORT_SYMBOL_GPL(sg_scsi_ioctl);
f98d2dfd BC	493
f98d2dfd BC	494	/* Send basic block requests */
165125e1 JA	495	static int __blk_send_generic(struct request_queue q, struct gendisk bd_disk,
165125e1 JA	496	int cmd, int data)
f98d2dfd BC	497	{
	498	struct request *rq;
	499	int err;
	500
	501	rq = blk_get_request(q, WRITE, __GFP_WAIT);
4aff5e23	502	rq->cmd_type = REQ_TYPE_BLOCK_PC;
3d6392cf	503	rq->timeout = BLK_DEFAULT_SG_TIMEOUT;
f98d2dfd BC	504	rq->cmd[0] = cmd;
	505	rq->cmd[4] = data;
	506	rq->cmd_len = 6;
	507	err = blk_execute_rq(q, bd_disk, rq, 0);
	508	blk_put_request(rq);
	509
	510	return err;
	511	}
	512
165125e1 JA	513	static inline int blk_send_start_stop(struct request_queue *q,
165125e1 JA	514	struct gendisk *bd_disk, int data)
f98d2dfd BC	515	{
	516	return __blk_send_generic(q, bd_disk, GPCMD_START_STOP_UNIT, data);
	517	}
	518
74f3c8af AV	519	int scsi_cmd_ioctl(struct request_queue q, struct gendisk bd_disk, fmode_t mode,
74f3c8af AV	520	unsigned int cmd, void __user *arg)
1da177e4	521	{
f98d2dfd	522	int err;
1da177e4	523
45e79a3a	524	if (!q \|\| blk_get_queue(q))
1da177e4 LT	525	return -ENXIO;
	526
	527	switch (cmd) {
	528	/*
	529	* new sgv3 interface
	530	*/
	531	case SG_GET_VERSION_NUM:
	532	err = sg_get_version(arg);
	533	break;
	534	case SCSI_IOCTL_GET_IDLUN:
	535	err = scsi_get_idlun(q, arg);
	536	break;
	537	case SCSI_IOCTL_GET_BUS_NUMBER:
	538	err = scsi_get_bus(q, arg);
	539	break;
	540	case SG_SET_TIMEOUT:
	541	err = sg_set_timeout(q, arg);
	542	break;
	543	case SG_GET_TIMEOUT:
	544	err = sg_get_timeout(q);
	545	break;
	546	case SG_GET_RESERVED_SIZE:
	547	err = sg_get_reserved_size(q, arg);
	548	break;
	549	case SG_SET_RESERVED_SIZE:
	550	err = sg_set_reserved_size(q, arg);
	551	break;
	552	case SG_EMULATED_HOST:
	553	err = sg_emulated_host(q, arg);
	554	break;
	555	case SG_IO: {
	556	struct sg_io_hdr hdr;
	557
	558	err = -EFAULT;
	559	if (copy_from_user(&hdr, arg, sizeof(hdr)))
	560	break;
74f3c8af	561	err = sg_io(q, bd_disk, &hdr, mode);
1da177e4 LT	562	if (err == -EFAULT)
	563	break;
	564
	565	if (copy_to_user(arg, &hdr, sizeof(hdr)))
	566	err = -EFAULT;
	567	break;
	568	}
	569	case CDROM_SEND_PACKET: {
	570	struct cdrom_generic_command cgc;
	571	struct sg_io_hdr hdr;
	572
	573	err = -EFAULT;
	574	if (copy_from_user(&cgc, arg, sizeof(cgc)))
	575	break;
	576	cgc.timeout = clock_t_to_jiffies(cgc.timeout);
	577	memset(&hdr, 0, sizeof(hdr));
	578	hdr.interface_id = 'S';
	579	hdr.cmd_len = sizeof(cgc.cmd);
	580	hdr.dxfer_len = cgc.buflen;
	581	err = 0;
	582	switch (cgc.data_direction) {
	583	case CGC_DATA_UNKNOWN:
	584	hdr.dxfer_direction = SG_DXFER_UNKNOWN;
	585	break;
	586	case CGC_DATA_WRITE:
	587	hdr.dxfer_direction = SG_DXFER_TO_DEV;
	588	break;
	589	case CGC_DATA_READ:
	590	hdr.dxfer_direction = SG_DXFER_FROM_DEV;
	591	break;
	592	case CGC_DATA_NONE:
	593	hdr.dxfer_direction = SG_DXFER_NONE;
	594	break;
	595	default:
	596	err = -EINVAL;
	597	}
	598	if (err)
	599	break;
	600
	601	hdr.dxferp = cgc.buffer;
	602	hdr.sbp = cgc.sense;
	603	if (hdr.sbp)
	604	hdr.mx_sb_len = sizeof(struct request_sense);
ad337591	605	hdr.timeout = jiffies_to_msecs(cgc.timeout);
1da177e4 LT	606	hdr.cmdp = ((struct cdrom_generic_command __user*) arg)->cmd;
	607	hdr.cmd_len = sizeof(cgc.cmd);
	608
74f3c8af	609	err = sg_io(q, bd_disk, &hdr, mode);
1da177e4 LT	610	if (err == -EFAULT)
	611	break;
	612
	613	if (hdr.status)
	614	err = -EIO;
	615
	616	cgc.stat = err;
	617	cgc.buflen = hdr.resid;
	618	if (copy_to_user(arg, &cgc, sizeof(cgc)))
	619	err = -EFAULT;
	620
	621	break;
	622	}
	623
	624	/*
	625	* old junk scsi send command ioctl
	626	*/
	627	case SCSI_IOCTL_SEND_COMMAND:
	628	printk(KERN_WARNING "program %s is using a deprecated SCSI ioctl, please convert it to SG_IO\n", current->comm);
	629	err = -EINVAL;
	630	if (!arg)
	631	break;
	632
74f3c8af	633	err = sg_scsi_ioctl(q, bd_disk, mode, arg);
1da177e4 LT	634	break;
1da177e4 LT	635	case CDROMCLOSETRAY:
f98d2dfd BC	636	err = blk_send_start_stop(q, bd_disk, 0x03);
f98d2dfd BC	637	break;
1da177e4	638	case CDROMEJECT:
f98d2dfd	639	err = blk_send_start_stop(q, bd_disk, 0x02);
1da177e4 LT	640	break;
	641	default:
	642	err = -ENOTTY;
	643	}
	644
	645	blk_put_queue(q);
	646	return err;
	647	}
	648
	649	EXPORT_SYMBOL(scsi_cmd_ioctl);