scsi_ioctl.c 19.1 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>
31
#include <linux/uaccess.h>
Linus Torvalds's avatar
Linus Torvalds committed
32 33 34 35 36

#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
	__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);
185 186 187
	__set_bit(WRITE_SAME, filter->write_ok);
	__set_bit(WRITE_SAME_16, filter->write_ok);
	__set_bit(WRITE_SAME_32, filter->write_ok);
188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206
	__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);
207
	__set_bit(GPCMD_SET_READ_AHEAD, filter->write_ok);
208
}
209

210
int blk_verify_command(unsigned char *cmd, fmode_t mode)
211 212 213 214 215 216 217 218 219 220 221 222
{
	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 */
223
	if (test_bit(cmd[0], filter->write_ok) && (mode & FMODE_WRITE))
224 225 226 227 228
		return 0;

	return -EPERM;
}
EXPORT_SYMBOL(blk_verify_command);
229

230
static int blk_fill_sghdr_rq(struct request_queue *q, struct request *rq,
231
			     struct sg_io_hdr *hdr, fmode_t mode)
232
{
233 234 235
	struct scsi_request *req = scsi_req(rq);

	if (copy_from_user(req->cmd, hdr->cmdp, hdr->cmd_len))
236
		return -EFAULT;
237
	if (blk_verify_command(req->cmd, mode))
238 239 240 241 242
		return -EPERM;

	/*
	 * fill in request structure
	 */
243
	req->cmd_len = hdr->cmd_len;
244

245
	rq->timeout = msecs_to_jiffies(hdr->timeout);
246 247 248 249
	if (!rq->timeout)
		rq->timeout = q->sg_timeout;
	if (!rq->timeout)
		rq->timeout = BLK_DEFAULT_SG_TIMEOUT;
250 251
	if (rq->timeout < BLK_MIN_SG_TIMEOUT)
		rq->timeout = BLK_MIN_SG_TIMEOUT;
252 253 254 255

	return 0;
}

256 257
static int blk_complete_sghdr_rq(struct request *rq, struct sg_io_hdr *hdr,
				 struct bio *bio)
258
{
259
	struct scsi_request *req = scsi_req(rq);
260
	int r, ret = 0;
261 262 263 264

	/*
	 * fill in all the output members
	 */
265 266 267 268 269
	hdr->status = req->result & 0xff;
	hdr->masked_status = status_byte(req->result);
	hdr->msg_status = msg_byte(req->result);
	hdr->host_status = host_byte(req->result);
	hdr->driver_status = driver_byte(req->result);
270 271 272
	hdr->info = 0;
	if (hdr->masked_status || hdr->host_status || hdr->driver_status)
		hdr->info |= SG_INFO_CHECK;
273
	hdr->resid = req->resid_len;
274 275
	hdr->sb_len_wr = 0;

276 277
	if (req->sense_len && hdr->sbp) {
		int len = min((unsigned int) hdr->mx_sb_len, req->sense_len);
278

279
		if (!copy_to_user(hdr->sbp, req->sense, len))
280 281 282 283 284
			hdr->sb_len_wr = len;
		else
			ret = -EFAULT;
	}

285 286 287
	r = blk_rq_unmap_user(bio);
	if (!ret)
		ret = r;
288

289
	return ret;
290 291
}

292 293
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
294
{
295
	unsigned long start_time;
296 297
	ssize_t ret = 0;
	int writing = 0;
298
	int at_head = 0;
Linus Torvalds's avatar
Linus Torvalds committed
299
	struct request *rq;
300
	struct scsi_request *req;
301
	struct bio *bio;
Linus Torvalds's avatar
Linus Torvalds committed
302 303 304 305

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

306
	if (hdr->dxfer_len > (queue_max_hw_sectors(q) << 9))
Linus Torvalds's avatar
Linus Torvalds committed
307 308
		return -EIO;

309
	if (hdr->dxfer_len)
Linus Torvalds's avatar
Linus Torvalds committed
310 311 312 313 314 315
		switch (hdr->dxfer_direction) {
		default:
			return -EINVAL;
		case SG_DXFER_TO_DEV:
			writing = 1;
			break;
316
		case SG_DXFER_TO_FROM_DEV:
Linus Torvalds's avatar
Linus Torvalds committed
317 318 319
		case SG_DXFER_FROM_DEV:
			break;
		}
320 321
	if (hdr->flags & SG_FLAG_Q_AT_HEAD)
		at_head = 1;
Linus Torvalds's avatar
Linus Torvalds committed
322

323
	ret = -ENOMEM;
324
	rq = blk_get_request(q, writing ? REQ_OP_SCSI_OUT : REQ_OP_SCSI_IN, 0);
325 326
	if (IS_ERR(rq))
		return PTR_ERR(rq);
327
	req = scsi_req(rq);
Linus Torvalds's avatar
Linus Torvalds committed
328

329
	if (hdr->cmd_len > BLK_MAX_CDB) {
330 331
		req->cmd = kzalloc(hdr->cmd_len, GFP_KERNEL);
		if (!req->cmd)
332
			goto out_put_request;
333
	}
Linus Torvalds's avatar
Linus Torvalds committed
334

335 336
	ret = blk_fill_sghdr_rq(q, rq, hdr, mode);
	if (ret < 0)
337
		goto out_free_cdb;
Linus Torvalds's avatar
Linus Torvalds committed
338

339
	ret = 0;
340
	if (hdr->iovec_count) {
341
		struct iov_iter i;
342
		struct iovec *iov = NULL;
343

Al Viro's avatar
Al Viro committed
344 345 346 347
		ret = import_iovec(rq_data_dir(rq),
				   hdr->dxferp, hdr->iovec_count,
				   0, &iov, &i);
		if (ret < 0)
348
			goto out_free_cdb;
349

350
		/* SG_IO howto says that the shorter of the two wins */
Al Viro's avatar
Al Viro committed
351
		iov_iter_truncate(&i, hdr->dxfer_len);
352

353
		ret = blk_rq_map_user_iov(q, rq, NULL, &i, GFP_KERNEL);
354
		kfree(iov);
355
	} else if (hdr->dxfer_len)
356
		ret = blk_rq_map_user(q, rq, NULL, hdr->dxferp, hdr->dxfer_len,
357
				      GFP_KERNEL);
358 359

	if (ret)
360
		goto out_free_cdb;
361

362
	bio = rq->bio;
363
	req->retries = 0;
364

Linus Torvalds's avatar
Linus Torvalds committed
365 366 367 368 369 370
	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.
	 */
371
	blk_execute_rq(q, bd_disk, rq, at_head);
Linus Torvalds's avatar
Linus Torvalds committed
372

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

375
	ret = blk_complete_sghdr_rq(rq, hdr, bio);
376 377

out_free_cdb:
378
	scsi_req_free_cmd(req);
379
out_put_request:
380 381
	blk_put_request(rq);
	return ret;
Linus Torvalds's avatar
Linus Torvalds committed
382 383
}

384 385 386 387
/**
 * sg_scsi_ioctl  --  handle deprecated SCSI_IOCTL_SEND_COMMAND ioctl
 * @q:		request queue to send scsi commands down
 * @disk:	gendisk to operate on (option)
388 389
 * @mode:	mode used to open the file through which the ioctl has been
 *		submitted
390 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
 * @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.
 */
418 419
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
420
{
421
	enum { OMAX_SB_LEN = 16 };	/* For backward compatibility */
Linus Torvalds's avatar
Linus Torvalds committed
422
	struct request *rq;
423
	struct scsi_request *req;
424
	int err;
Linus Torvalds's avatar
Linus Torvalds committed
425
	unsigned int in_len, out_len, bytes, opcode, cmdlen;
426
	char *buffer = NULL;
Linus Torvalds's avatar
Linus Torvalds committed
427

428 429 430
	if (!sic)
		return -EINVAL;

Linus Torvalds's avatar
Linus Torvalds committed
431 432 433 434 435 436 437 438 439 440 441 442 443 444
	/*
	 * 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) {
445
		buffer = kzalloc(bytes, q->bounce_gfp | GFP_USER| __GFP_NOWARN);
Linus Torvalds's avatar
Linus Torvalds committed
446 447 448 449 450
		if (!buffer)
			return -ENOMEM;

	}

451
	rq = blk_get_request(q, in_len ? REQ_OP_SCSI_OUT : REQ_OP_SCSI_IN, 0);
452 453
	if (IS_ERR(rq)) {
		err = PTR_ERR(rq);
454
		goto error_free_buffer;
455
	}
456
	req = scsi_req(rq);
Linus Torvalds's avatar
Linus Torvalds committed
457 458 459 460 461 462 463

	cmdlen = COMMAND_SIZE(opcode);

	/*
	 * get command and data to send to device, if any
	 */
	err = -EFAULT;
464 465
	req->cmd_len = cmdlen;
	if (copy_from_user(req->cmd, sic->data, cmdlen))
Linus Torvalds's avatar
Linus Torvalds committed
466 467
		goto error;

468
	if (in_len && copy_from_user(buffer, sic->data + cmdlen, in_len))
Linus Torvalds's avatar
Linus Torvalds committed
469 470
		goto error;

471
	err = blk_verify_command(req->cmd, mode);
Linus Torvalds's avatar
Linus Torvalds committed
472 473 474
	if (err)
		goto error;

475
	/* default.  possible overriden later */
476
	req->retries = 5;
477

Linus Torvalds's avatar
Linus Torvalds committed
478
	switch (opcode) {
479 480 481
	case SEND_DIAGNOSTIC:
	case FORMAT_UNIT:
		rq->timeout = FORMAT_UNIT_TIMEOUT;
482
		req->retries = 1;
483 484 485 486 487 488 489 490 491 492 493 494
		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;
495
		req->retries = 1;
496 497
		break;
	default:
498
		rq->timeout = BLK_DEFAULT_SG_TIMEOUT;
499 500 501
		break;
	}

502
	if (bytes && blk_rq_map_kern(q, rq, buffer, bytes, GFP_NOIO)) {
503
		err = DRIVER_ERROR << 24;
504
		goto error;
Linus Torvalds's avatar
Linus Torvalds committed
505 506
	}

507 508
	blk_execute_rq(q, disk, rq, 0);

509
	err = req->result & 0xff;	/* only 8 bit SCSI status */
Linus Torvalds's avatar
Linus Torvalds committed
510
	if (err) {
511 512 513 514
		if (req->sense_len && req->sense) {
			bytes = (OMAX_SB_LEN > req->sense_len) ?
				req->sense_len : OMAX_SB_LEN;
			if (copy_to_user(sic->data, req->sense, bytes))
Linus Torvalds's avatar
Linus Torvalds committed
515 516 517 518 519 520 521 522
				err = -EFAULT;
		}
	} else {
		if (copy_to_user(sic->data, buffer, out_len))
			err = -EFAULT;
	}
	
error:
523 524 525
	blk_put_request(rq);

error_free_buffer:
526
	kfree(buffer);
527

Linus Torvalds's avatar
Linus Torvalds committed
528 529
	return err;
}
530
EXPORT_SYMBOL_GPL(sg_scsi_ioctl);
531 532

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

539
	rq = blk_get_request(q, REQ_OP_SCSI_OUT, 0);
540 541
	if (IS_ERR(rq))
		return PTR_ERR(rq);
542
	rq->timeout = BLK_DEFAULT_SG_TIMEOUT;
543 544 545
	scsi_req(rq)->cmd[0] = cmd;
	scsi_req(rq)->cmd[4] = data;
	scsi_req(rq)->cmd_len = 6;
546
	blk_execute_rq(q, bd_disk, rq, 0);
547
	err = scsi_req(rq)->result ? -EIO : 0;
548 549 550 551 552
	blk_put_request(rq);

	return err;
}

553 554
static inline int blk_send_start_stop(struct request_queue *q,
				      struct gendisk *bd_disk, int data)
555 556 557 558
{
	return __blk_send_generic(q, bd_disk, GPCMD_START_STOP_UNIT, data);
}

559 560
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
561
{
562
	int err;
Linus Torvalds's avatar
Linus Torvalds committed
563

564
	if (!q)
Linus Torvalds's avatar
Linus Torvalds committed
565 566 567 568 569 570 571 572 573 574 575 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
		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;
601
			err = sg_io(q, bd_disk, &hdr, mode);
Linus Torvalds's avatar
Linus Torvalds committed
602 603 604 605 606 607 608 609 610 611 612 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
			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);
645
			hdr.timeout = jiffies_to_msecs(cgc.timeout);
Linus Torvalds's avatar
Linus Torvalds committed
646 647 648
			hdr.cmdp = ((struct cdrom_generic_command __user*) arg)->cmd;
			hdr.cmd_len = sizeof(cgc.cmd);

649
			err = sg_io(q, bd_disk, &hdr, mode);
Linus Torvalds's avatar
Linus Torvalds committed
650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672
			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;

673
			err = sg_scsi_ioctl(q, bd_disk, mode, arg);
Linus Torvalds's avatar
Linus Torvalds committed
674 675
			break;
		case CDROMCLOSETRAY:
676 677
			err = blk_send_start_stop(q, bd_disk, 0x03);
			break;
Linus Torvalds's avatar
Linus Torvalds committed
678
		case CDROMEJECT:
679
			err = blk_send_start_stop(q, bd_disk, 0x02);
Linus Torvalds's avatar
Linus Torvalds committed
680 681 682 683 684 685 686 687
			break;
		default:
			err = -ENOTTY;
	}

	return err;
}
EXPORT_SYMBOL(scsi_cmd_ioctl);
688

689 690 691 692 693
int scsi_verify_blk_ioctl(struct block_device *bd, unsigned int cmd)
{
	if (bd && bd == bd->bd_contains)
		return 0;

694 695 696 697
	if (capable(CAP_SYS_RAWIO))
		return 0;

	return -ENOIOCTLCMD;
698 699 700
}
EXPORT_SYMBOL(scsi_verify_blk_ioctl);

701 702 703
int scsi_cmd_blk_ioctl(struct block_device *bd, fmode_t mode,
		       unsigned int cmd, void __user *arg)
{
704 705 706 707 708 709
	int ret;

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

710 711 712 713
	return scsi_cmd_ioctl(bd->bd_disk->queue, bd->bd_disk, mode, cmd, arg);
}
EXPORT_SYMBOL(scsi_cmd_blk_ioctl);

714 715 716 717 718 719 720
/**
 * scsi_req_init - initialize certain fields of a scsi_request structure
 * @req: Pointer to a scsi_request structure.
 * Initializes .__cmd[], .cmd, .cmd_len and .sense_len but no other members
 * of struct scsi_request.
 */
void scsi_req_init(struct scsi_request *req)
721 722 723 724 725 726 727 728
{
	memset(req->__cmd, 0, sizeof(req->__cmd));
	req->cmd = req->__cmd;
	req->cmd_len = BLK_MAX_CDB;
	req->sense_len = 0;
}
EXPORT_SYMBOL(scsi_req_init);

729
static int __init blk_scsi_ioctl_init(void)
730 731 732 733
{
	blk_set_cmd_filter_defaults(&blk_default_cmd_filter);
	return 0;
}
734
fs_initcall(blk_scsi_ioctl_init);