scsi_ioctl.c 19.6 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
/*
 * Copyright (C) 2001 Jens Axboe <axboe@suse.de>
 *
 * 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>
24
#include <linux/capability.h>
Linus Torvalds's avatar
Linus Torvalds committed
25 26
#include <linux/completion.h>
#include <linux/cdrom.h>
27
#include <linux/ratelimit.h>
Linus Torvalds's avatar
Linus Torvalds committed
28 29
#include <linux/slab.h>
#include <linux/times.h>
30
#include <linux/uio.h>
Linus Torvalds's avatar
Linus Torvalds committed
31 32 33 34 35 36
#include <asm/uaccess.h>

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

37 38 39
struct blk_cmd_filter {
	unsigned long read_ok[BLK_SCSI_CMD_PER_LONG];
	unsigned long write_ok[BLK_SCSI_CMD_PER_LONG];
40 41 42
};

static struct blk_cmd_filter blk_default_cmd_filter;
43

Linus Torvalds's avatar
Linus Torvalds committed
44
/* Command group 3 is reserved and should never be used.  */
45
const unsigned char scsi_command_size_tbl[8] =
Linus Torvalds's avatar
Linus Torvalds committed
46 47 48 49
{
	6, 10, 10, 12,
	16, 12, 10, 10
};
50
EXPORT_SYMBOL(scsi_command_size_tbl);
Linus Torvalds's avatar
Linus Torvalds committed
51 52 53 54 55

#include <scsi/sg.h>

static int sg_get_version(int __user *p)
{
56
	static const int sg_version_num = 30527;
Linus Torvalds's avatar
Linus Torvalds committed
57 58 59
	return put_user(sg_version_num, p);
}

60
static int scsi_get_idlun(struct request_queue *q, int __user *p)
Linus Torvalds's avatar
Linus Torvalds committed
61 62 63 64
{
	return put_user(0, p);
}

65
static int scsi_get_bus(struct request_queue *q, int __user *p)
Linus Torvalds's avatar
Linus Torvalds committed
66 67 68 69
{
	return put_user(0, p);
}

70
static int sg_get_timeout(struct request_queue *q)
Linus Torvalds's avatar
Linus Torvalds committed
71
{
72
	return jiffies_to_clock_t(q->sg_timeout);
Linus Torvalds's avatar
Linus Torvalds committed
73 74
}

75
static int sg_set_timeout(struct request_queue *q, int __user *p)
Linus Torvalds's avatar
Linus Torvalds committed
76 77 78 79
{
	int timeout, err = get_user(timeout, p);

	if (!err)
80
		q->sg_timeout = clock_t_to_jiffies(timeout);
Linus Torvalds's avatar
Linus Torvalds committed
81 82 83 84

	return err;
}

85 86 87 88 89 90 91 92 93
static int max_sectors_bytes(struct request_queue *q)
{
	unsigned int max_sectors = queue_max_sectors(q);

	max_sectors = min_t(unsigned int, max_sectors, INT_MAX >> 9);

	return max_sectors << 9;
}

94
static int sg_get_reserved_size(struct request_queue *q, int __user *p)
Linus Torvalds's avatar
Linus Torvalds committed
95
{
96
	int val = min_t(int, q->sg_reserved_size, max_sectors_bytes(q));
97 98

	return put_user(val, p);
Linus Torvalds's avatar
Linus Torvalds committed
99 100
}

101
static int sg_set_reserved_size(struct request_queue *q, int __user *p)
Linus Torvalds's avatar
Linus Torvalds committed
102 103 104 105 106 107 108 109 110
{
	int size, err = get_user(size, p);

	if (err)
		return err;

	if (size < 0)
		return -EINVAL;

111
	q->sg_reserved_size = min(size, max_sectors_bytes(q));
Linus Torvalds's avatar
Linus Torvalds committed
112 113 114 115 116 117 118
	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??)
 */
119
static int sg_emulated_host(struct request_queue *q, int __user *p)
Linus Torvalds's avatar
Linus Torvalds committed
120 121 122 123
{
	return put_user(1, p);
}

124
static void blk_set_cmd_filter_defaults(struct blk_cmd_filter *filter)
125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144
{
	/* 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);
145
	__set_bit(SERVICE_ACTION_IN_16, filter->read_ok);
146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203
	__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);
204
	__set_bit(GPCMD_SET_READ_AHEAD, filter->write_ok);
205
}
206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225

int blk_verify_command(unsigned char *cmd, fmode_t has_write_perm)
{
	struct blk_cmd_filter *filter = &blk_default_cmd_filter;

	/* root can do any command. */
	if (capable(CAP_SYS_RAWIO))
		return 0;

	/* Anybody who can open the device can do a read-safe command */
	if (test_bit(cmd[0], filter->read_ok))
		return 0;

	/* Write-safe commands require a writable open */
	if (test_bit(cmd[0], filter->write_ok) && has_write_perm)
		return 0;

	return -EPERM;
}
EXPORT_SYMBOL(blk_verify_command);
226

227
static int blk_fill_sghdr_rq(struct request_queue *q, struct request *rq,
228
			     struct sg_io_hdr *hdr, fmode_t mode)
229 230 231
{
	if (copy_from_user(rq->cmd, hdr->cmdp, hdr->cmd_len))
		return -EFAULT;
232
	if (blk_verify_command(rq->cmd, mode & FMODE_WRITE))
233 234 235 236 237 238 239
		return -EPERM;

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

240
	rq->timeout = msecs_to_jiffies(hdr->timeout);
241 242 243 244
	if (!rq->timeout)
		rq->timeout = q->sg_timeout;
	if (!rq->timeout)
		rq->timeout = BLK_DEFAULT_SG_TIMEOUT;
245 246
	if (rq->timeout < BLK_MIN_SG_TIMEOUT)
		rq->timeout = BLK_MIN_SG_TIMEOUT;
247 248 249 250

	return 0;
}

251 252
static int blk_complete_sghdr_rq(struct request *rq, struct sg_io_hdr *hdr,
				 struct bio *bio)
253
{
254
	int r, ret = 0;
255 256 257 258 259 260 261 262 263 264 265 266

	/*
	 * 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;
Tejun Heo's avatar
Tejun Heo committed
267
	hdr->resid = rq->resid_len;
268 269 270 271 272 273 274 275 276 277 278
	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;
	}

279 280 281
	r = blk_rq_unmap_user(bio);
	if (!ret)
		ret = r;
282

283
	return ret;
284 285
}

286 287
static int sg_io(struct request_queue *q, struct gendisk *bd_disk,
		struct sg_io_hdr *hdr, fmode_t mode)
Linus Torvalds's avatar
Linus Torvalds committed
288
{
289
	unsigned long start_time;
290 291
	ssize_t ret = 0;
	int writing = 0;
292
	int at_head = 0;
Linus Torvalds's avatar
Linus Torvalds committed
293 294
	struct request *rq;
	char sense[SCSI_SENSE_BUFFERSIZE];
FUJITA Tomonori's avatar
FUJITA Tomonori committed
295
	struct bio *bio;
Linus Torvalds's avatar
Linus Torvalds committed
296 297 298 299

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

300
	if (hdr->dxfer_len > (queue_max_hw_sectors(q) << 9))
Linus Torvalds's avatar
Linus Torvalds committed
301 302
		return -EIO;

303
	if (hdr->dxfer_len)
Linus Torvalds's avatar
Linus Torvalds committed
304 305 306 307 308 309
		switch (hdr->dxfer_direction) {
		default:
			return -EINVAL;
		case SG_DXFER_TO_DEV:
			writing = 1;
			break;
310
		case SG_DXFER_TO_FROM_DEV:
Linus Torvalds's avatar
Linus Torvalds committed
311 312 313
		case SG_DXFER_FROM_DEV:
			break;
		}
314 315
	if (hdr->flags & SG_FLAG_Q_AT_HEAD)
		at_head = 1;
Linus Torvalds's avatar
Linus Torvalds committed
316

317
	ret = -ENOMEM;
318
	rq = blk_get_request(q, writing ? WRITE : READ, GFP_KERNEL);
319 320
	if (IS_ERR(rq))
		return PTR_ERR(rq);
321
	blk_rq_set_block_pc(rq);
Linus Torvalds's avatar
Linus Torvalds committed
322

323 324 325 326
	if (hdr->cmd_len > BLK_MAX_CDB) {
		rq->cmd = kzalloc(hdr->cmd_len, GFP_KERNEL);
		if (!rq->cmd)
			goto out_put_request;
327
	}
Linus Torvalds's avatar
Linus Torvalds committed
328

329 330
	ret = -EFAULT;
	if (blk_fill_sghdr_rq(q, rq, hdr, mode))
331
		goto out_free_cdb;
Linus Torvalds's avatar
Linus Torvalds committed
332

333
	ret = 0;
334
	if (hdr->iovec_count) {
335
		size_t iov_data_len;
336
		struct iovec *iov = NULL;
337

338 339
		ret = rw_copy_check_uvector(-1, hdr->dxferp, hdr->iovec_count,
					    0, NULL, &iov);
340 341
		if (ret < 0) {
			kfree(iov);
342
			goto out_free_cdb;
343
		}
344

345 346
		iov_data_len = ret;
		ret = 0;
347

348 349
		/* SG_IO howto says that the shorter of the two wins */
		if (hdr->dxfer_len < iov_data_len) {
350
			hdr->iovec_count = iov_shorten(iov,
351 352 353 354 355
						       hdr->iovec_count,
						       hdr->dxfer_len);
			iov_data_len = hdr->dxfer_len;
		}

356 357
		ret = blk_rq_map_user_iov(q, rq, NULL, (struct sg_iovec *) iov,
					  hdr->iovec_count,
358
					  iov_data_len, GFP_KERNEL);
359
		kfree(iov);
360
	} else if (hdr->dxfer_len)
361
		ret = blk_rq_map_user(q, rq, NULL, hdr->dxferp, hdr->dxfer_len,
362
				      GFP_KERNEL);
363 364

	if (ret)
365
		goto out_free_cdb;
366

FUJITA Tomonori's avatar
FUJITA Tomonori committed
367
	bio = rq->bio;
368 369 370
	memset(sense, 0, sizeof(sense));
	rq->sense = sense;
	rq->sense_len = 0;
371 372
	rq->retries = 0;

Linus Torvalds's avatar
Linus Torvalds committed
373 374 375 376 377 378
	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.
	 */
379
	blk_execute_rq(q, bd_disk, rq, at_head);
Linus Torvalds's avatar
Linus Torvalds committed
380

381
	hdr->duration = jiffies_to_msecs(jiffies - start_time);
Linus Torvalds's avatar
Linus Torvalds committed
382

383
	ret = blk_complete_sghdr_rq(rq, hdr, bio);
384 385 386 387 388

out_free_cdb:
	if (rq->cmd != rq->__cmd)
		kfree(rq->cmd);
out_put_request:
389 390
	blk_put_request(rq);
	return ret;
Linus Torvalds's avatar
Linus Torvalds committed
391 392
}

393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425
/**
 * 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.
 */
Linus Torvalds's avatar
Linus Torvalds committed
426
#define OMAX_SB_LEN 16          /* For backward compatibility */
427 428
int sg_scsi_ioctl(struct request_queue *q, struct gendisk *disk, fmode_t mode,
		struct scsi_ioctl_command __user *sic)
Linus Torvalds's avatar
Linus Torvalds committed
429 430
{
	struct request *rq;
431
	int err;
Linus Torvalds's avatar
Linus Torvalds committed
432 433 434
	unsigned int in_len, out_len, bytes, opcode, cmdlen;
	char *buffer = NULL, sense[SCSI_SENSE_BUFFERSIZE];

435 436 437
	if (!sic)
		return -EINVAL;

Linus Torvalds's avatar
Linus Torvalds committed
438 439 440 441 442 443 444 445 446 447 448 449 450 451
	/*
	 * 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) {
452
		buffer = kzalloc(bytes, q->bounce_gfp | GFP_USER| __GFP_NOWARN);
Linus Torvalds's avatar
Linus Torvalds committed
453 454 455 456 457 458
		if (!buffer)
			return -ENOMEM;

	}

	rq = blk_get_request(q, in_len ? WRITE : READ, __GFP_WAIT);
459 460
	if (IS_ERR(rq)) {
		err = PTR_ERR(rq);
461
		goto error_free_buffer;
462
	}
463
	blk_rq_set_block_pc(rq);
Linus Torvalds's avatar
Linus Torvalds committed
464 465 466 467 468 469 470 471 472 473 474

	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;

475
	if (in_len && copy_from_user(buffer, sic->data + cmdlen, in_len))
Linus Torvalds's avatar
Linus Torvalds committed
476 477
		goto error;

478
	err = blk_verify_command(rq->cmd, mode & FMODE_WRITE);
Linus Torvalds's avatar
Linus Torvalds committed
479 480 481
	if (err)
		goto error;

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

Linus Torvalds's avatar
Linus Torvalds committed
485
	switch (opcode) {
486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504
	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:
505
		rq->timeout = BLK_DEFAULT_SG_TIMEOUT;
506 507 508 509 510
		break;
	}

	if (bytes && blk_rq_map_kern(q, rq, buffer, bytes, __GFP_WAIT)) {
		err = DRIVER_ERROR << 24;
511
		goto error;
Linus Torvalds's avatar
Linus Torvalds committed
512 513 514 515 516 517
	}

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

518 519
	blk_execute_rq(q, disk, rq, 0);

Linus Torvalds's avatar
Linus Torvalds committed
520 521 522 523 524 525 526 527 528 529 530 531 532 533
	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:
534 535 536
	blk_put_request(rq);

error_free_buffer:
537
	kfree(buffer);
538

Linus Torvalds's avatar
Linus Torvalds committed
539 540
	return err;
}
541
EXPORT_SYMBOL_GPL(sg_scsi_ioctl);
542 543

/* Send basic block requests */
544 545
static int __blk_send_generic(struct request_queue *q, struct gendisk *bd_disk,
			      int cmd, int data)
546 547 548 549 550
{
	struct request *rq;
	int err;

	rq = blk_get_request(q, WRITE, __GFP_WAIT);
551 552
	if (IS_ERR(rq))
		return PTR_ERR(rq);
553
	blk_rq_set_block_pc(rq);
554
	rq->timeout = BLK_DEFAULT_SG_TIMEOUT;
555 556 557 558 559 560 561 562 563
	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;
}

564 565
static inline int blk_send_start_stop(struct request_queue *q,
				      struct gendisk *bd_disk, int data)
566 567 568 569
{
	return __blk_send_generic(q, bd_disk, GPCMD_START_STOP_UNIT, data);
}

570 571
int scsi_cmd_ioctl(struct request_queue *q, struct gendisk *bd_disk, fmode_t mode,
		   unsigned int cmd, void __user *arg)
Linus Torvalds's avatar
Linus Torvalds committed
572
{
573
	int err;
Linus Torvalds's avatar
Linus Torvalds committed
574

575
	if (!q)
Linus Torvalds's avatar
Linus Torvalds committed
576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611
		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;
612
			err = sg_io(q, bd_disk, &hdr, mode);
Linus Torvalds's avatar
Linus Torvalds committed
613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655
			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);
656
			hdr.timeout = jiffies_to_msecs(cgc.timeout);
Linus Torvalds's avatar
Linus Torvalds committed
657 658 659
			hdr.cmdp = ((struct cdrom_generic_command __user*) arg)->cmd;
			hdr.cmd_len = sizeof(cgc.cmd);

660
			err = sg_io(q, bd_disk, &hdr, mode);
Linus Torvalds's avatar
Linus Torvalds committed
661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683
			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;

684
			err = sg_scsi_ioctl(q, bd_disk, mode, arg);
Linus Torvalds's avatar
Linus Torvalds committed
685 686
			break;
		case CDROMCLOSETRAY:
687 688
			err = blk_send_start_stop(q, bd_disk, 0x03);
			break;
Linus Torvalds's avatar
Linus Torvalds committed
689
		case CDROMEJECT:
690
			err = blk_send_start_stop(q, bd_disk, 0x02);
Linus Torvalds's avatar
Linus Torvalds committed
691 692 693 694 695 696 697 698
			break;
		default:
			err = -ENOTTY;
	}

	return err;
}
EXPORT_SYMBOL(scsi_cmd_ioctl);
699

700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729
int scsi_verify_blk_ioctl(struct block_device *bd, unsigned int cmd)
{
	if (bd && bd == bd->bd_contains)
		return 0;

	/* Actually none of these is particularly useful on a partition,
	 * but they are safe.
	 */
	switch (cmd) {
	case SCSI_IOCTL_GET_IDLUN:
	case SCSI_IOCTL_GET_BUS_NUMBER:
	case SCSI_IOCTL_GET_PCI:
	case SCSI_IOCTL_PROBE_HOST:
	case SG_GET_VERSION_NUM:
	case SG_SET_TIMEOUT:
	case SG_GET_TIMEOUT:
	case SG_GET_RESERVED_SIZE:
	case SG_SET_RESERVED_SIZE:
	case SG_EMULATED_HOST:
		return 0;
	case CDROM_GET_CAPABILITY:
		/* Keep this until we remove the printk below.  udev sends it
		 * and we do not want to spam dmesg about it.   CD-ROMs do
		 * not have partitions, so we get here only for disks.
		 */
		return -ENOIOCTLCMD;
	default:
		break;
	}

730 731 732
	if (capable(CAP_SYS_RAWIO))
		return 0;

733 734 735 736
	/* In particular, rule out all resets and host-specific ioctls.  */
	printk_ratelimited(KERN_WARNING
			   "%s: sending ioctl %x to a partition!\n", current->comm, cmd);

737
	return -ENOIOCTLCMD;
738 739 740
}
EXPORT_SYMBOL(scsi_verify_blk_ioctl);

741 742 743
int scsi_cmd_blk_ioctl(struct block_device *bd, fmode_t mode,
		       unsigned int cmd, void __user *arg)
{
744 745 746 747 748 749
	int ret;

	ret = scsi_verify_blk_ioctl(bd, cmd);
	if (ret < 0)
		return ret;

750 751 752 753
	return scsi_cmd_ioctl(bd->bd_disk->queue, bd->bd_disk, mode, cmd, arg);
}
EXPORT_SYMBOL(scsi_cmd_blk_ioctl);

754
static int __init blk_scsi_ioctl_init(void)
755 756 757 758
{
	blk_set_cmd_filter_defaults(&blk_default_cmd_filter);
	return 0;
}
759
fs_initcall(blk_scsi_ioctl_init);