sd.c 78.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 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48
/*
 *      sd.c Copyright (C) 1992 Drew Eckhardt
 *           Copyright (C) 1993, 1994, 1995, 1999 Eric Youngdale
 *
 *      Linux scsi disk driver
 *              Initial versions: Drew Eckhardt
 *              Subsequent revisions: Eric Youngdale
 *	Modification history:
 *       - Drew Eckhardt <drew@colorado.edu> original
 *       - Eric Youngdale <eric@andante.org> add scatter-gather, multiple 
 *         outstanding request, and other enhancements.
 *         Support loadable low-level scsi drivers.
 *       - Jirka Hanika <geo@ff.cuni.cz> support more scsi disks using 
 *         eight major numbers.
 *       - Richard Gooch <rgooch@atnf.csiro.au> support devfs.
 *	 - Torben Mathiasen <tmm@image.dk> Resource allocation fixes in 
 *	   sd_init and cleanups.
 *	 - Alex Davis <letmein@erols.com> Fix problem where partition info
 *	   not being read in sd_open. Fix problem where removable media 
 *	   could be ejected after sd_open.
 *	 - Douglas Gilbert <dgilbert@interlog.com> cleanup for lk 2.5.x
 *	 - Badari Pulavarty <pbadari@us.ibm.com>, Matthew Wilcox 
 *	   <willy@debian.org>, Kurt Garloff <garloff@suse.de>: 
 *	   Support 32k/1M disks.
 *
 *	Logging policy (needs CONFIG_SCSI_LOGGING defined):
 *	 - setting up transfer: SCSI_LOG_HLQUEUE levels 1 and 2
 *	 - end of transfer (bh + scsi_lib): SCSI_LOG_HLCOMPLETE level 1
 *	 - entering sd_ioctl: SCSI_LOG_IOCTL level 1
 *	 - entering other commands: SCSI_LOG_HLQUEUE level 3
 *	Note: when the logging level is set by the user, it must be greater
 *	than the level indicated above to trigger output.	
 */

#include <linux/module.h>
#include <linux/fs.h>
#include <linux/kernel.h>
#include <linux/mm.h>
#include <linux/bio.h>
#include <linux/genhd.h>
#include <linux/hdreg.h>
#include <linux/errno.h>
#include <linux/idr.h>
#include <linux/interrupt.h>
#include <linux/init.h>
#include <linux/blkdev.h>
#include <linux/blkpg.h>
#include <linux/delay.h>
49
#include <linux/mutex.h>
50
#include <linux/string_helpers.h>
51
#include <linux/async.h>
52
#include <linux/slab.h>
53
#include <linux/pm_runtime.h>
Linus Torvalds's avatar
Linus Torvalds committed
54
#include <asm/uaccess.h>
55
#include <asm/unaligned.h>
Linus Torvalds's avatar
Linus Torvalds committed
56 57 58 59 60 61 62 63 64 65 66

#include <scsi/scsi.h>
#include <scsi/scsi_cmnd.h>
#include <scsi/scsi_dbg.h>
#include <scsi/scsi_device.h>
#include <scsi/scsi_driver.h>
#include <scsi/scsi_eh.h>
#include <scsi/scsi_host.h>
#include <scsi/scsi_ioctl.h>
#include <scsi/scsicam.h>

67
#include "sd.h"
Linus Torvalds's avatar
Linus Torvalds committed
68 69
#include "scsi_logging.h"

70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89
MODULE_AUTHOR("Eric Youngdale");
MODULE_DESCRIPTION("SCSI disk (sd) driver");
MODULE_LICENSE("GPL");

MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK0_MAJOR);
MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK1_MAJOR);
MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK2_MAJOR);
MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK3_MAJOR);
MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK4_MAJOR);
MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK5_MAJOR);
MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK6_MAJOR);
MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK7_MAJOR);
MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK8_MAJOR);
MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK9_MAJOR);
MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK10_MAJOR);
MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK11_MAJOR);
MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK12_MAJOR);
MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK13_MAJOR);
MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK14_MAJOR);
MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK15_MAJOR);
90 91 92
MODULE_ALIAS_SCSI_DEVICE(TYPE_DISK);
MODULE_ALIAS_SCSI_DEVICE(TYPE_MOD);
MODULE_ALIAS_SCSI_DEVICE(TYPE_RBC);
93

94
#if !defined(CONFIG_DEBUG_BLOCK_EXT_DEVT)
95
#define SD_MINORS	16
96
#else
97
#define SD_MINORS	0
98 99
#endif

100
static void sd_config_discard(struct scsi_disk *, unsigned int);
101
static int  sd_revalidate_disk(struct gendisk *);
102
static void sd_unlock_native_capacity(struct gendisk *disk);
103 104 105 106 107 108 109
static int  sd_probe(struct device *);
static int  sd_remove(struct device *);
static void sd_shutdown(struct device *);
static int sd_suspend(struct device *, pm_message_t state);
static int sd_resume(struct device *);
static void sd_rescan(struct device *);
static int sd_done(struct scsi_cmnd *);
110
static int sd_eh_action(struct scsi_cmnd *, unsigned char *, int, int);
111
static void sd_read_capacity(struct scsi_disk *sdkp, unsigned char *buffer);
112
static void scsi_disk_release(struct device *cdev);
113 114 115
static void sd_print_sense_hdr(struct scsi_disk *, struct scsi_sense_hdr *);
static void sd_print_result(struct scsi_disk *, int);

Tejun Heo's avatar
Tejun Heo committed
116
static DEFINE_SPINLOCK(sd_index_lock);
117
static DEFINE_IDA(sd_index_ida);
Linus Torvalds's avatar
Linus Torvalds committed
118 119 120 121

/* This semaphore is used to mediate the 0->1 reference get in the
 * face of object destruction (i.e. we can't allow a get on an
 * object after last put) */
122
static DEFINE_MUTEX(sd_ref_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
123

124 125
static struct kmem_cache *sd_cdb_cache;
static mempool_t *sd_cdb_pool;
126

127 128 129 130 131
static const char *sd_cache_types[] = {
	"write through", "none", "write back",
	"write back, no read (daft)"
};

132 133 134
static ssize_t
sd_store_cache_type(struct device *dev, struct device_attribute *attr,
		    const char *buf, size_t count)
135 136
{
	int i, ct = -1, rcd, wce, sp;
137
	struct scsi_disk *sdkp = to_scsi_disk(dev);
138 139 140 141 142 143 144 145 146 147 148 149 150
	struct scsi_device *sdp = sdkp->device;
	char buffer[64];
	char *buffer_data;
	struct scsi_mode_data data;
	struct scsi_sense_hdr sshdr;
	int len;

	if (sdp->type != TYPE_DISK)
		/* no cache control on RBC devices; theoretically they
		 * can do it, but there's probably so many exceptions
		 * it's not worth the risk */
		return -EINVAL;

151
	for (i = 0; i < ARRAY_SIZE(sd_cache_types); i++) {
152
		len = strlen(sd_cache_types[i]);
153 154 155 156 157 158 159 160 161 162 163 164 165
		if (strncmp(sd_cache_types[i], buf, len) == 0 &&
		    buf[len] == '\n') {
			ct = i;
			break;
		}
	}
	if (ct < 0)
		return -EINVAL;
	rcd = ct & 0x01 ? 1 : 0;
	wce = ct & 0x02 ? 1 : 0;
	if (scsi_mode_sense(sdp, 0x08, 8, buffer, sizeof(buffer), SD_TIMEOUT,
			    SD_MAX_RETRIES, &data, NULL))
		return -EINVAL;
166
	len = min_t(size_t, sizeof(buffer), data.length - data.header_length -
167 168 169 170 171 172 173 174 175 176
		  data.block_descriptor_length);
	buffer_data = buffer + data.header_length +
		data.block_descriptor_length;
	buffer_data[2] &= ~0x05;
	buffer_data[2] |= wce << 2 | rcd;
	sp = buffer_data[0] & 0x80 ? 1 : 0;

	if (scsi_mode_select(sdp, 1, sp, 8, buffer_data, len, SD_TIMEOUT,
			     SD_MAX_RETRIES, &data, &sshdr)) {
		if (scsi_sense_valid(&sshdr))
177
			sd_print_sense_hdr(sdkp, &sshdr);
178 179
		return -EINVAL;
	}
180
	revalidate_disk(sdkp->disk);
181 182 183
	return count;
}

184 185 186
static ssize_t
sd_store_manage_start_stop(struct device *dev, struct device_attribute *attr,
			   const char *buf, size_t count)
187
{
188
	struct scsi_disk *sdkp = to_scsi_disk(dev);
189 190 191 192 193 194 195 196 197 198
	struct scsi_device *sdp = sdkp->device;

	if (!capable(CAP_SYS_ADMIN))
		return -EACCES;

	sdp->manage_start_stop = simple_strtoul(buf, NULL, 10);

	return count;
}

199 200 201
static ssize_t
sd_store_allow_restart(struct device *dev, struct device_attribute *attr,
		       const char *buf, size_t count)
202
{
203
	struct scsi_disk *sdkp = to_scsi_disk(dev);
204 205 206 207 208 209 210 211 212 213 214 215 216
	struct scsi_device *sdp = sdkp->device;

	if (!capable(CAP_SYS_ADMIN))
		return -EACCES;

	if (sdp->type != TYPE_DISK)
		return -EINVAL;

	sdp->allow_restart = simple_strtoul(buf, NULL, 10);

	return count;
}

217 218 219
static ssize_t
sd_show_cache_type(struct device *dev, struct device_attribute *attr,
		   char *buf)
220
{
221
	struct scsi_disk *sdkp = to_scsi_disk(dev);
222 223 224 225 226
	int ct = sdkp->RCD + 2*sdkp->WCE;

	return snprintf(buf, 40, "%s\n", sd_cache_types[ct]);
}

227 228
static ssize_t
sd_show_fua(struct device *dev, struct device_attribute *attr, char *buf)
229
{
230
	struct scsi_disk *sdkp = to_scsi_disk(dev);
231 232 233 234

	return snprintf(buf, 20, "%u\n", sdkp->DPOFUA);
}

235 236 237
static ssize_t
sd_show_manage_start_stop(struct device *dev, struct device_attribute *attr,
			  char *buf)
238
{
239
	struct scsi_disk *sdkp = to_scsi_disk(dev);
240 241 242 243 244
	struct scsi_device *sdp = sdkp->device;

	return snprintf(buf, 20, "%u\n", sdp->manage_start_stop);
}

245 246 247
static ssize_t
sd_show_allow_restart(struct device *dev, struct device_attribute *attr,
		      char *buf)
248
{
249
	struct scsi_disk *sdkp = to_scsi_disk(dev);
250 251 252 253

	return snprintf(buf, 40, "%d\n", sdkp->device->allow_restart);
}

254 255 256 257 258 259 260 261 262
static ssize_t
sd_show_protection_type(struct device *dev, struct device_attribute *attr,
			char *buf)
{
	struct scsi_disk *sdkp = to_scsi_disk(dev);

	return snprintf(buf, 20, "%u\n", sdkp->protection_type);
}

263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284
static ssize_t
sd_show_protection_mode(struct device *dev, struct device_attribute *attr,
			char *buf)
{
	struct scsi_disk *sdkp = to_scsi_disk(dev);
	struct scsi_device *sdp = sdkp->device;
	unsigned int dif, dix;

	dif = scsi_host_dif_capable(sdp->host, sdkp->protection_type);
	dix = scsi_host_dix_capable(sdp->host, sdkp->protection_type);

	if (!dix && scsi_host_dix_capable(sdp->host, SD_DIF_TYPE0_PROTECTION)) {
		dif = 0;
		dix = 1;
	}

	if (!dif && !dix)
		return snprintf(buf, 20, "none\n");

	return snprintf(buf, 20, "%s%u\n", dix ? "dix" : "dif", dif);
}

285 286 287 288 289 290 291 292 293
static ssize_t
sd_show_app_tag_own(struct device *dev, struct device_attribute *attr,
		    char *buf)
{
	struct scsi_disk *sdkp = to_scsi_disk(dev);

	return snprintf(buf, 20, "%u\n", sdkp->ATO);
}

294 295 296 297 298 299
static ssize_t
sd_show_thin_provisioning(struct device *dev, struct device_attribute *attr,
			  char *buf)
{
	struct scsi_disk *sdkp = to_scsi_disk(dev);

300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347
	return snprintf(buf, 20, "%u\n", sdkp->lbpme);
}

static const char *lbp_mode[] = {
	[SD_LBP_FULL]		= "full",
	[SD_LBP_UNMAP]		= "unmap",
	[SD_LBP_WS16]		= "writesame_16",
	[SD_LBP_WS10]		= "writesame_10",
	[SD_LBP_ZERO]		= "writesame_zero",
	[SD_LBP_DISABLE]	= "disabled",
};

static ssize_t
sd_show_provisioning_mode(struct device *dev, struct device_attribute *attr,
			  char *buf)
{
	struct scsi_disk *sdkp = to_scsi_disk(dev);

	return snprintf(buf, 20, "%s\n", lbp_mode[sdkp->provisioning_mode]);
}

static ssize_t
sd_store_provisioning_mode(struct device *dev, struct device_attribute *attr,
			   const char *buf, size_t count)
{
	struct scsi_disk *sdkp = to_scsi_disk(dev);
	struct scsi_device *sdp = sdkp->device;

	if (!capable(CAP_SYS_ADMIN))
		return -EACCES;

	if (sdp->type != TYPE_DISK)
		return -EINVAL;

	if (!strncmp(buf, lbp_mode[SD_LBP_UNMAP], 20))
		sd_config_discard(sdkp, SD_LBP_UNMAP);
	else if (!strncmp(buf, lbp_mode[SD_LBP_WS16], 20))
		sd_config_discard(sdkp, SD_LBP_WS16);
	else if (!strncmp(buf, lbp_mode[SD_LBP_WS10], 20))
		sd_config_discard(sdkp, SD_LBP_WS10);
	else if (!strncmp(buf, lbp_mode[SD_LBP_ZERO], 20))
		sd_config_discard(sdkp, SD_LBP_ZERO);
	else if (!strncmp(buf, lbp_mode[SD_LBP_DISABLE], 20))
		sd_config_discard(sdkp, SD_LBP_DISABLE);
	else
		return -EINVAL;

	return count;
348 349
}

350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374
static ssize_t
sd_show_max_medium_access_timeouts(struct device *dev,
				   struct device_attribute *attr, char *buf)
{
	struct scsi_disk *sdkp = to_scsi_disk(dev);

	return snprintf(buf, 20, "%u\n", sdkp->max_medium_access_timeouts);
}

static ssize_t
sd_store_max_medium_access_timeouts(struct device *dev,
				    struct device_attribute *attr,
				    const char *buf, size_t count)
{
	struct scsi_disk *sdkp = to_scsi_disk(dev);
	int err;

	if (!capable(CAP_SYS_ADMIN))
		return -EACCES;

	err = kstrtouint(buf, 10, &sdkp->max_medium_access_timeouts);

	return err ? err : count;
}

375
static struct device_attribute sd_disk_attrs[] = {
376 377 378
	__ATTR(cache_type, S_IRUGO|S_IWUSR, sd_show_cache_type,
	       sd_store_cache_type),
	__ATTR(FUA, S_IRUGO, sd_show_fua, NULL),
379 380
	__ATTR(allow_restart, S_IRUGO|S_IWUSR, sd_show_allow_restart,
	       sd_store_allow_restart),
381 382
	__ATTR(manage_start_stop, S_IRUGO|S_IWUSR, sd_show_manage_start_stop,
	       sd_store_manage_start_stop),
383
	__ATTR(protection_type, S_IRUGO, sd_show_protection_type, NULL),
384
	__ATTR(protection_mode, S_IRUGO, sd_show_protection_mode, NULL),
385
	__ATTR(app_tag_own, S_IRUGO, sd_show_app_tag_own, NULL),
386
	__ATTR(thin_provisioning, S_IRUGO, sd_show_thin_provisioning, NULL),
387 388
	__ATTR(provisioning_mode, S_IRUGO|S_IWUSR, sd_show_provisioning_mode,
	       sd_store_provisioning_mode),
389 390 391
	__ATTR(max_medium_access_timeouts, S_IRUGO|S_IWUSR,
	       sd_show_max_medium_access_timeouts,
	       sd_store_max_medium_access_timeouts),
392 393 394 395 396 397
	__ATTR_NULL,
};

static struct class sd_disk_class = {
	.name		= "scsi_disk",
	.owner		= THIS_MODULE,
398 399
	.dev_release	= scsi_disk_release,
	.dev_attrs	= sd_disk_attrs,
400
};
Linus Torvalds's avatar
Linus Torvalds committed
401 402 403 404 405 406 407

static struct scsi_driver sd_template = {
	.owner			= THIS_MODULE,
	.gendrv = {
		.name		= "sd",
		.probe		= sd_probe,
		.remove		= sd_remove,
408 409
		.suspend	= sd_suspend,
		.resume		= sd_resume,
Linus Torvalds's avatar
Linus Torvalds committed
410 411 412
		.shutdown	= sd_shutdown,
	},
	.rescan			= sd_rescan,
413
	.done			= sd_done,
414
	.eh_action		= sd_eh_action,
Linus Torvalds's avatar
Linus Torvalds committed
415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445
};

/*
 * Device no to disk mapping:
 * 
 *       major         disc2     disc  p1
 *   |............|.............|....|....| <- dev_t
 *    31        20 19          8 7  4 3  0
 * 
 * Inside a major, we have 16k disks, however mapped non-
 * contiguously. The first 16 disks are for major0, the next
 * ones with major1, ... Disk 256 is for major0 again, disk 272 
 * for major1, ... 
 * As we stay compatible with our numbering scheme, we can reuse 
 * the well-know SCSI majors 8, 65--71, 136--143.
 */
static int sd_major(int major_idx)
{
	switch (major_idx) {
	case 0:
		return SCSI_DISK0_MAJOR;
	case 1 ... 7:
		return SCSI_DISK1_MAJOR + major_idx - 1;
	case 8 ... 15:
		return SCSI_DISK8_MAJOR + major_idx - 8;
	default:
		BUG();
		return 0;	/* shut up gcc */
	}
}

Alan Stern's avatar
Alan Stern committed
446
static struct scsi_disk *__scsi_disk_get(struct gendisk *disk)
Linus Torvalds's avatar
Linus Torvalds committed
447 448 449
{
	struct scsi_disk *sdkp = NULL;

Alan Stern's avatar
Alan Stern committed
450 451 452
	if (disk->private_data) {
		sdkp = scsi_disk(disk);
		if (scsi_device_get(sdkp->device) == 0)
453
			get_device(&sdkp->dev);
Alan Stern's avatar
Alan Stern committed
454 455 456 457 458 459 460 461 462 463
		else
			sdkp = NULL;
	}
	return sdkp;
}

static struct scsi_disk *scsi_disk_get(struct gendisk *disk)
{
	struct scsi_disk *sdkp;

464
	mutex_lock(&sd_ref_mutex);
Alan Stern's avatar
Alan Stern committed
465
	sdkp = __scsi_disk_get(disk);
466
	mutex_unlock(&sd_ref_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
467
	return sdkp;
Alan Stern's avatar
Alan Stern committed
468
}
Linus Torvalds's avatar
Linus Torvalds committed
469

Alan Stern's avatar
Alan Stern committed
470 471 472 473
static struct scsi_disk *scsi_disk_get_from_dev(struct device *dev)
{
	struct scsi_disk *sdkp;

474
	mutex_lock(&sd_ref_mutex);
Alan Stern's avatar
Alan Stern committed
475 476 477
	sdkp = dev_get_drvdata(dev);
	if (sdkp)
		sdkp = __scsi_disk_get(sdkp->disk);
478
	mutex_unlock(&sd_ref_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
479 480 481 482 483 484 485
	return sdkp;
}

static void scsi_disk_put(struct scsi_disk *sdkp)
{
	struct scsi_device *sdev = sdkp->device;

486
	mutex_lock(&sd_ref_mutex);
487
	put_device(&sdkp->dev);
Linus Torvalds's avatar
Linus Torvalds committed
488
	scsi_device_put(sdev);
489
	mutex_unlock(&sd_ref_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
490 491
}

492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516
static void sd_prot_op(struct scsi_cmnd *scmd, unsigned int dif)
{
	unsigned int prot_op = SCSI_PROT_NORMAL;
	unsigned int dix = scsi_prot_sg_count(scmd);

	if (scmd->sc_data_direction == DMA_FROM_DEVICE) {
		if (dif && dix)
			prot_op = SCSI_PROT_READ_PASS;
		else if (dif && !dix)
			prot_op = SCSI_PROT_READ_STRIP;
		else if (!dif && dix)
			prot_op = SCSI_PROT_READ_INSERT;
	} else {
		if (dif && dix)
			prot_op = SCSI_PROT_WRITE_PASS;
		else if (dif && !dix)
			prot_op = SCSI_PROT_WRITE_INSERT;
		else if (!dif && dix)
			prot_op = SCSI_PROT_WRITE_STRIP;
	}

	scsi_set_prot_op(scmd, prot_op);
	scsi_set_prot_type(scmd, dif);
}

517 518 519 520 521 522 523
static void sd_config_discard(struct scsi_disk *sdkp, unsigned int mode)
{
	struct request_queue *q = sdkp->disk->queue;
	unsigned int logical_block_size = sdkp->device->sector_size;
	unsigned int max_blocks = 0;

	q->limits.discard_zeroes_data = sdkp->lbprz;
524 525
	q->limits.discard_alignment = sdkp->unmap_alignment *
		logical_block_size;
526 527 528 529
	q->limits.discard_granularity =
		max(sdkp->physical_block_size,
		    sdkp->unmap_granularity * logical_block_size);

530 531
	sdkp->provisioning_mode = mode;

532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560
	switch (mode) {

	case SD_LBP_DISABLE:
		q->limits.max_discard_sectors = 0;
		queue_flag_clear_unlocked(QUEUE_FLAG_DISCARD, q);
		return;

	case SD_LBP_UNMAP:
		max_blocks = min_not_zero(sdkp->max_unmap_blocks, 0xffffffff);
		break;

	case SD_LBP_WS16:
		max_blocks = min_not_zero(sdkp->max_ws_blocks, 0xffffffff);
		break;

	case SD_LBP_WS10:
		max_blocks = min_not_zero(sdkp->max_ws_blocks, (u32)0xffff);
		break;

	case SD_LBP_ZERO:
		max_blocks = min_not_zero(sdkp->max_ws_blocks, (u32)0xffff);
		q->limits.discard_zeroes_data = 1;
		break;
	}

	q->limits.max_discard_sectors = max_blocks * (logical_block_size >> 9);
	queue_flag_set_unlocked(QUEUE_FLAG_DISCARD, q);
}

561
/**
562 563
 * scsi_setup_discard_cmnd - unmap blocks on thinly provisioned device
 * @sdp: scsi device to operate one
564 565 566 567 568
 * @rq: Request to prepare
 *
 * Will issue either UNMAP or WRITE SAME(16) depending on preference
 * indicated by target device.
 **/
569
static int scsi_setup_discard_cmnd(struct scsi_device *sdp, struct request *rq)
570 571 572 573
{
	struct scsi_disk *sdkp = scsi_disk(rq->rq_disk);
	struct bio *bio = rq->bio;
	sector_t sector = bio->bi_sector;
574 575
	unsigned int nr_sectors = bio_sectors(bio);
	unsigned int len;
576
	int ret;
577
	char *buf;
578
	struct page *page;
579 580 581

	if (sdkp->device->sector_size == 4096) {
		sector >>= 3;
582
		nr_sectors >>= 3;
583 584 585 586 587 588
	}

	rq->timeout = SD_TIMEOUT;

	memset(rq->cmd, 0, rq->cmd_len);

589 590 591 592
	page = alloc_page(GFP_ATOMIC | __GFP_ZERO);
	if (!page)
		return BLKPREP_DEFER;

593 594 595
	switch (sdkp->provisioning_mode) {
	case SD_LBP_UNMAP:
		buf = page_address(page);
596

597
		rq->cmd_len = 10;
598 599 600 601 602 603
		rq->cmd[0] = UNMAP;
		rq->cmd[8] = 24;

		put_unaligned_be16(6 + 16, &buf[0]);
		put_unaligned_be16(16, &buf[2]);
		put_unaligned_be64(sector, &buf[8]);
604
		put_unaligned_be32(nr_sectors, &buf[16]);
605

606
		len = 24;
607 608 609
		break;

	case SD_LBP_WS16:
610
		rq->cmd_len = 16;
611 612 613
		rq->cmd[0] = WRITE_SAME_16;
		rq->cmd[1] = 0x8; /* UNMAP */
		put_unaligned_be64(sector, &rq->cmd[2]);
614 615 616
		put_unaligned_be32(nr_sectors, &rq->cmd[10]);

		len = sdkp->device->sector_size;
617 618 619 620 621 622 623 624 625 626 627 628 629 630 631
		break;

	case SD_LBP_WS10:
	case SD_LBP_ZERO:
		rq->cmd_len = 10;
		rq->cmd[0] = WRITE_SAME;
		if (sdkp->provisioning_mode == SD_LBP_WS10)
			rq->cmd[1] = 0x8; /* UNMAP */
		put_unaligned_be32(sector, &rq->cmd[2]);
		put_unaligned_be16(nr_sectors, &rq->cmd[7]);

		len = sdkp->device->sector_size;
		break;

	default:
632
		ret = BLKPREP_KILL;
633
		goto out;
634 635
	}

636
	blk_add_request_payload(rq, page, len);
637 638
	ret = scsi_setup_blk_pc_cmnd(sdp, rq);
	rq->buffer = page_address(page);
639 640

out:
FUJITA Tomonori's avatar
FUJITA Tomonori committed
641 642 643 644
	if (ret != BLKPREP_OK) {
		__free_page(page);
		rq->buffer = NULL;
	}
645 646 647
	return ret;
}

648 649
static int scsi_setup_flush_cmnd(struct scsi_device *sdp, struct request *rq)
{
650
	rq->timeout = SD_FLUSH_TIMEOUT;
651 652 653 654 655 656 657
	rq->retries = SD_MAX_RETRIES;
	rq->cmd[0] = SYNCHRONIZE_CACHE;
	rq->cmd_len = 10;

	return scsi_setup_blk_pc_cmnd(sdp, rq);
}

658 659
static void sd_unprep_fn(struct request_queue *q, struct request *rq)
{
FUJITA Tomonori's avatar
FUJITA Tomonori committed
660 661 662 663
	if (rq->cmd_flags & REQ_DISCARD) {
		free_page((unsigned long)rq->buffer);
		rq->buffer = NULL;
	}
664 665
}

Linus Torvalds's avatar
Linus Torvalds committed
666 667 668 669 670 671 672 673
/**
 *	sd_init_command - build a scsi (read or write) command from
 *	information in the request structure.
 *	@SCpnt: pointer to mid-level's per scsi command structure that
 *	contains request and into which the scsi command is written
 *
 *	Returns 1 if successful and 0 if error (or cannot be done now).
 **/
674
static int sd_prep_fn(struct request_queue *q, struct request *rq)
Linus Torvalds's avatar
Linus Torvalds committed
675
{
676 677
	struct scsi_cmnd *SCpnt;
	struct scsi_device *sdp = q->queuedata;
678
	struct gendisk *disk = rq->rq_disk;
679
	struct scsi_disk *sdkp;
680
	sector_t block = blk_rq_pos(rq);
681
	sector_t threshold;
682
	unsigned int this_count = blk_rq_sectors(rq);
683
	int ret, host_dif;
684
	unsigned char protect;
685

686 687 688 689
	/*
	 * Discard request come in as REQ_TYPE_FS but we turn them into
	 * block PC requests to make life easier.
	 */
690 691 692
	if (rq->cmd_flags & REQ_DISCARD) {
		ret = scsi_setup_discard_cmnd(sdp, rq);
		goto out;
693 694 695
	} else if (rq->cmd_flags & REQ_FLUSH) {
		ret = scsi_setup_flush_cmnd(sdp, rq);
		goto out;
696
	} else if (rq->cmd_type == REQ_TYPE_BLOCK_PC) {
697 698 699 700 701 702 703 704 705 706
		ret = scsi_setup_blk_pc_cmnd(sdp, rq);
		goto out;
	} else if (rq->cmd_type != REQ_TYPE_FS) {
		ret = BLKPREP_KILL;
		goto out;
	}
	ret = scsi_setup_fs_cmnd(sdp, rq);
	if (ret != BLKPREP_OK)
		goto out;
	SCpnt = rq->special;
707
	sdkp = scsi_disk(disk);
708 709 710 711

	/* from here on until we're complete, any goto out
	 * is used for a killable error condition */
	ret = BLKPREP_KILL;
Linus Torvalds's avatar
Linus Torvalds committed
712

713 714 715 716 717
	SCSI_LOG_HLQUEUE(1, scmd_printk(KERN_INFO, SCpnt,
					"sd_init_command: block=%llu, "
					"count=%d\n",
					(unsigned long long)block,
					this_count));
Linus Torvalds's avatar
Linus Torvalds committed
718 719

	if (!sdp || !scsi_device_online(sdp) ||
720
	    block + blk_rq_sectors(rq) > get_capacity(disk)) {
721
		SCSI_LOG_HLQUEUE(2, scmd_printk(KERN_INFO, SCpnt,
722 723
						"Finishing %u sectors\n",
						blk_rq_sectors(rq)));
724 725
		SCSI_LOG_HLQUEUE(2, scmd_printk(KERN_INFO, SCpnt,
						"Retry with 0x%p\n", SCpnt));
726
		goto out;
Linus Torvalds's avatar
Linus Torvalds committed
727 728 729 730 731 732 733
	}

	if (sdp->changed) {
		/*
		 * quietly refuse to do anything to a changed disc until 
		 * the changed bit has been reset
		 */
734
		/* printk("SCSI disk has been changed or is not present. Prohibiting further I/O.\n"); */
735
		goto out;
Linus Torvalds's avatar
Linus Torvalds committed
736
	}
737

738
	/*
739 740
	 * Some SD card readers can't handle multi-sector accesses which touch
	 * the last one or two hardware sectors.  Split accesses as needed.
741
	 */
742 743 744 745 746 747 748 749 750 751 752 753
	threshold = get_capacity(disk) - SD_LAST_BUGGY_SECTORS *
		(sdp->sector_size / 512);

	if (unlikely(sdp->last_sector_bug && block + this_count > threshold)) {
		if (block < threshold) {
			/* Access up to the threshold but not beyond */
			this_count = threshold - block;
		} else {
			/* Access only a single hardware sector */
			this_count = sdp->sector_size / 512;
		}
	}
754

755 756
	SCSI_LOG_HLQUEUE(2, scmd_printk(KERN_INFO, SCpnt, "block=%llu\n",
					(unsigned long long)block));
Linus Torvalds's avatar
Linus Torvalds committed
757 758 759 760 761 762 763 764 765 766 767 768 769

	/*
	 * If we have a 1K hardware sectorsize, prevent access to single
	 * 512 byte sectors.  In theory we could handle this - in fact
	 * the scsi cdrom driver must be able to handle this because
	 * we typically use 1K blocksizes, and cdroms typically have
	 * 2K hardware sectorsizes.  Of course, things are simpler
	 * with the cdrom, since it is read-only.  For performance
	 * reasons, the filesystems should be able to handle this
	 * and not force the scsi disk driver to use bounce buffers
	 * for this.
	 */
	if (sdp->sector_size == 1024) {
770
		if ((block & 1) || (blk_rq_sectors(rq) & 1)) {
771 772
			scmd_printk(KERN_ERR, SCpnt,
				    "Bad block number requested\n");
773
			goto out;
Linus Torvalds's avatar
Linus Torvalds committed
774 775 776 777 778 779
		} else {
			block = block >> 1;
			this_count = this_count >> 1;
		}
	}
	if (sdp->sector_size == 2048) {
780
		if ((block & 3) || (blk_rq_sectors(rq) & 3)) {
781 782
			scmd_printk(KERN_ERR, SCpnt,
				    "Bad block number requested\n");
783
			goto out;
Linus Torvalds's avatar
Linus Torvalds committed
784 785 786 787 788 789
		} else {
			block = block >> 2;
			this_count = this_count >> 2;
		}
	}
	if (sdp->sector_size == 4096) {
790
		if ((block & 7) || (blk_rq_sectors(rq) & 7)) {
791 792
			scmd_printk(KERN_ERR, SCpnt,
				    "Bad block number requested\n");
793
			goto out;
Linus Torvalds's avatar
Linus Torvalds committed
794 795 796 797 798 799 800
		} else {
			block = block >> 3;
			this_count = this_count >> 3;
		}
	}
	if (rq_data_dir(rq) == WRITE) {
		if (!sdp->writeable) {
801
			goto out;
Linus Torvalds's avatar
Linus Torvalds committed
802 803 804
		}
		SCpnt->cmnd[0] = WRITE_6;
		SCpnt->sc_data_direction = DMA_TO_DEVICE;
805 806 807 808 809

		if (blk_integrity_rq(rq) &&
		    sd_dif_prepare(rq, block, sdp->sector_size) == -EIO)
			goto out;

Linus Torvalds's avatar
Linus Torvalds committed
810 811 812 813
	} else if (rq_data_dir(rq) == READ) {
		SCpnt->cmnd[0] = READ_6;
		SCpnt->sc_data_direction = DMA_FROM_DEVICE;
	} else {
814
		scmd_printk(KERN_ERR, SCpnt, "Unknown command %x\n", rq->cmd_flags);
815
		goto out;
Linus Torvalds's avatar
Linus Torvalds committed
816 817
	}

818
	SCSI_LOG_HLQUEUE(2, scmd_printk(KERN_INFO, SCpnt,
819
					"%s %d/%u 512 byte blocks.\n",
820 821
					(rq_data_dir(rq) == WRITE) ?
					"writing" : "reading", this_count,
822
					blk_rq_sectors(rq)));
Linus Torvalds's avatar
Linus Torvalds committed
823

824
	/* Set RDPROTECT/WRPROTECT if disk is formatted with DIF */
825 826
	host_dif = scsi_host_dif_capable(sdp->host, sdkp->protection_type);
	if (host_dif)
827
		protect = 1 << 5;
828
	else
829 830 831 832 833 834 835 836 837
		protect = 0;

	if (host_dif == SD_DIF_TYPE2_PROTECTION) {
		SCpnt->cmnd = mempool_alloc(sd_cdb_pool, GFP_ATOMIC);

		if (unlikely(SCpnt->cmnd == NULL)) {
			ret = BLKPREP_DEFER;
			goto out;
		}
838

839 840 841 842 843
		SCpnt->cmd_len = SD_EXT_CDB_SIZE;
		memset(SCpnt->cmnd, 0, SCpnt->cmd_len);
		SCpnt->cmnd[0] = VARIABLE_LENGTH_CMD;
		SCpnt->cmnd[7] = 0x18;
		SCpnt->cmnd[9] = (rq_data_dir(rq) == READ) ? READ_32 : WRITE_32;
844
		SCpnt->cmnd[10] = protect | ((rq->cmd_flags & REQ_FUA) ? 0x8 : 0);
845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867

		/* LBA */
		SCpnt->cmnd[12] = sizeof(block) > 4 ? (unsigned char) (block >> 56) & 0xff : 0;
		SCpnt->cmnd[13] = sizeof(block) > 4 ? (unsigned char) (block >> 48) & 0xff : 0;
		SCpnt->cmnd[14] = sizeof(block) > 4 ? (unsigned char) (block >> 40) & 0xff : 0;
		SCpnt->cmnd[15] = sizeof(block) > 4 ? (unsigned char) (block >> 32) & 0xff : 0;
		SCpnt->cmnd[16] = (unsigned char) (block >> 24) & 0xff;
		SCpnt->cmnd[17] = (unsigned char) (block >> 16) & 0xff;
		SCpnt->cmnd[18] = (unsigned char) (block >> 8) & 0xff;
		SCpnt->cmnd[19] = (unsigned char) block & 0xff;

		/* Expected Indirect LBA */
		SCpnt->cmnd[20] = (unsigned char) (block >> 24) & 0xff;
		SCpnt->cmnd[21] = (unsigned char) (block >> 16) & 0xff;
		SCpnt->cmnd[22] = (unsigned char) (block >> 8) & 0xff;
		SCpnt->cmnd[23] = (unsigned char) block & 0xff;

		/* Transfer length */
		SCpnt->cmnd[28] = (unsigned char) (this_count >> 24) & 0xff;
		SCpnt->cmnd[29] = (unsigned char) (this_count >> 16) & 0xff;
		SCpnt->cmnd[30] = (unsigned char) (this_count >> 8) & 0xff;
		SCpnt->cmnd[31] = (unsigned char) this_count & 0xff;
	} else if (block > 0xffffffff) {
Linus Torvalds's avatar
Linus Torvalds committed
868
		SCpnt->cmnd[0] += READ_16 - READ_6;
869
		SCpnt->cmnd[1] = protect | ((rq->cmd_flags & REQ_FUA) ? 0x8 : 0);
Linus Torvalds's avatar
Linus Torvalds committed
870 871 872 873 874 875 876 877 878 879 880 881 882 883
		SCpnt->cmnd[2] = sizeof(block) > 4 ? (unsigned char) (block >> 56) & 0xff : 0;
		SCpnt->cmnd[3] = sizeof(block) > 4 ? (unsigned char) (block >> 48) & 0xff : 0;
		SCpnt->cmnd[4] = sizeof(block) > 4 ? (unsigned char) (block >> 40) & 0xff : 0;
		SCpnt->cmnd[5] = sizeof(block) > 4 ? (unsigned char) (block >> 32) & 0xff : 0;
		SCpnt->cmnd[6] = (unsigned char) (block >> 24) & 0xff;
		SCpnt->cmnd[7] = (unsigned char) (block >> 16) & 0xff;
		SCpnt->cmnd[8] = (unsigned char) (block >> 8) & 0xff;
		SCpnt->cmnd[9] = (unsigned char) block & 0xff;
		SCpnt->cmnd[10] = (unsigned char) (this_count >> 24) & 0xff;
		SCpnt->cmnd[11] = (unsigned char) (this_count >> 16) & 0xff;
		SCpnt->cmnd[12] = (unsigned char) (this_count >> 8) & 0xff;
		SCpnt->cmnd[13] = (unsigned char) this_count & 0xff;
		SCpnt->cmnd[14] = SCpnt->cmnd[15] = 0;
	} else if ((this_count > 0xff) || (block > 0x1fffff) ||
884
		   scsi_device_protection(SCpnt->device) ||
Linus Torvalds's avatar
Linus Torvalds committed
885 886 887 888 889
		   SCpnt->device->use_10_for_rw) {
		if (this_count > 0xffff)
			this_count = 0xffff;

		SCpnt->cmnd[0] += READ_10 - READ_6;
890
		SCpnt->cmnd[1] = protect | ((rq->cmd_flags & REQ_FUA) ? 0x8 : 0);
Linus Torvalds's avatar
Linus Torvalds committed
891 892 893 894 895 896 897 898
		SCpnt->cmnd[2] = (unsigned char) (block >> 24) & 0xff;
		SCpnt->cmnd[3] = (unsigned char) (block >> 16) & 0xff;
		SCpnt->cmnd[4] = (unsigned char) (block >> 8) & 0xff;
		SCpnt->cmnd[5] = (unsigned char) block & 0xff;
		SCpnt->cmnd[6] = SCpnt->cmnd[9] = 0;
		SCpnt->cmnd[7] = (unsigned char) (this_count >> 8) & 0xff;
		SCpnt->cmnd[8] = (unsigned char) this_count & 0xff;
	} else {
899
		if (unlikely(rq->cmd_flags & REQ_FUA)) {
900 901 902 903 904 905
			/*
			 * This happens only if this drive failed
			 * 10byte rw command with ILLEGAL_REQUEST
			 * during operation and thus turned off
			 * use_10_for_rw.
			 */
906 907
			scmd_printk(KERN_ERR, SCpnt,
				    "FUA write on READ/WRITE(6) drive\n");
908
			goto out;
909 910
		}

Linus Torvalds's avatar
Linus Torvalds committed
911 912 913 914 915 916
		SCpnt->cmnd[1] |= (unsigned char) ((block >> 16) & 0x1f);
		SCpnt->cmnd[2] = (unsigned char) ((block >> 8) & 0xff);
		SCpnt->cmnd[3] = (unsigned char) block & 0xff;
		SCpnt->cmnd[4] = (unsigned char) this_count;
		SCpnt->cmnd[5] = 0;
	}
917
	SCpnt->sdb.length = this_count * sdp->sector_size;
Linus Torvalds's avatar
Linus Torvalds committed
918

919
	/* If DIF or DIX is enabled, tell HBA how to handle request */
920
	if (host_dif || scsi_prot_sg_count(SCpnt))
921
		sd_prot_op(SCpnt, host_dif);
922

Linus Torvalds's avatar
Linus Torvalds committed
923 924 925 926 927 928 929 930 931 932 933 934 935
	/*
	 * We shouldn't disconnect in the middle of a sector, so with a dumb
	 * host adapter, it's safe to assume that we can at least transfer
	 * this many bytes between each connect / disconnect.
	 */
	SCpnt->transfersize = sdp->sector_size;
	SCpnt->underflow = this_count << 9;
	SCpnt->allowed = SD_MAX_RETRIES;

	/*
	 * This indicates that the command is ready from our end to be
	 * queued.
	 */
936 937 938
	ret = BLKPREP_OK;
 out:
	return scsi_prep_return(q, rq, ret);
Linus Torvalds's avatar
Linus Torvalds committed
939 940 941 942 943 944 945 946 947 948 949 950 951 952
}

/**
 *	sd_open - open a scsi disk device
 *	@inode: only i_rdev member may be used
 *	@filp: only f_mode and f_flags may be used
 *
 *	Returns 0 if successful. Returns a negated errno value in case 
 *	of error.
 *
 *	Note: This can be called from a user context (e.g. fsck(1) )
 *	or from within the kernel (e.g. as a result of a mount(1) ).
 *	In the latter case @inode and @filp carry an abridged amount
 *	of information as noted above.
953 954
 *
 *	Locking: called with bdev->bd_mutex held.
Linus Torvalds's avatar
Linus Torvalds committed
955
 **/
Al Viro's avatar
Al Viro committed
956
static int sd_open(struct block_device *bdev, fmode_t mode)
Linus Torvalds's avatar
Linus Torvalds committed
957
{
Al Viro's avatar
Al Viro committed
958
	struct scsi_disk *sdkp = scsi_disk_get(bdev->bd_disk);
Linus Torvalds's avatar
Linus Torvalds committed
959 960 961
	struct scsi_device *sdev;
	int retval;

Al Viro's avatar
Al Viro committed
962
	if (!sdkp)
Linus Torvalds's avatar
Linus Torvalds committed
963 964
		return -ENXIO;

965
	SCSI_LOG_HLQUEUE(3, sd_printk(KERN_INFO, sdkp, "sd_open\n"));
Linus Torvalds's avatar
Linus Torvalds committed
966 967 968

	sdev = sdkp->device;

969 970 971 972
	retval = scsi_autopm_get_device(sdev);
	if (retval)
		goto error_autopm;

Linus Torvalds's avatar
Linus Torvalds committed
973 974 975 976 977 978 979 980 981
	/*
	 * If the device is in error recovery, wait until it is done.
	 * If the device is offline, then disallow any access to it.
	 */
	retval = -ENXIO;
	if (!scsi_block_when_processing_errors(sdev))
		goto error_out;

	if (sdev->removable || sdkp->write_prot)
Al Viro's avatar
Al Viro committed
982
		check_disk_change(bdev);
Linus Torvalds's avatar
Linus Torvalds committed
983 984 985 986 987

	/*
	 * If the drive is empty, just let the open fail.
	 */
	retval = -ENOMEDIUM;
Al Viro's avatar
Al Viro committed
988
	if (sdev->removable && !sdkp->media_present && !(mode & FMODE_NDELAY))
Linus Torvalds's avatar
Linus Torvalds committed
989 990 991 992 993 994 995
		goto error_out;

	/*
	 * If the device has the write protect tab set, have the open fail
	 * if the user expects to be able to write to the thing.
	 */
	retval = -EROFS;
Al Viro's avatar
Al Viro committed
996
	if (sdkp->write_prot && (mode & FMODE_WRITE))
Linus Torvalds's avatar
Linus Torvalds committed
997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008
		goto error_out;

	/*
	 * It is possible that the disk changing stuff resulted in
	 * the device being taken offline.  If this is the case,
	 * report this to the user, and don't pretend that the
	 * open actually succeeded.
	 */
	retval = -ENXIO;
	if (!scsi_device_online(sdev))
		goto error_out;

1009
	if ((atomic_inc_return(&sdkp->openers) == 1) && sdev->removable) {
Linus Torvalds's avatar
Linus Torvalds committed
1010 1011 1012 1013 1014 1015 1016
		if (scsi_block_when_processing_errors(sdev))
			scsi_set_medium_removal(sdev, SCSI_REMOVAL_PREVENT);
	}

	return 0;

error_out:
1017 1018
	scsi_autopm_put_device(sdev);
error_autopm:
Linus Torvalds's avatar
Linus Torvalds committed
1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032
	scsi_disk_put(sdkp);
	return retval;	
}

/**
 *	sd_release - invoked when the (last) close(2) is called on this
 *	scsi disk.
 *	@inode: only i_rdev member may be used
 *	@filp: only f_mode and f_flags may be used
 *
 *	Returns 0. 
 *
 *	Note: may block (uninterruptible) if error recovery is underway
 *	on this disk.
1033 1034
 *
 *	Locking: called with bdev->bd_mutex held.
Linus Torvalds's avatar
Linus Torvalds committed
1035
 **/
Al Viro's avatar
Al Viro committed
1036
static int sd_release(struct gendisk *disk, fmode_t mode)
Linus Torvalds's avatar
Linus Torvalds committed
1037 1038 1039 1040
{
	struct scsi_disk *sdkp = scsi_disk(disk);
	struct scsi_device *sdev = sdkp->device;

1041
	SCSI_LOG_HLQUEUE(3, sd_printk(KERN_INFO, sdkp, "sd_release\n"));
Linus Torvalds's avatar
Linus Torvalds committed
1042

Alan Stern's avatar
Alan Stern committed
1043
	if (atomic_dec_return(&sdkp->openers) == 0 && sdev->removable) {
Linus Torvalds's avatar
Linus Torvalds committed
1044 1045 1046 1047 1048 1049 1050 1051
		if (scsi_block_when_processing_errors(sdev))
			scsi_set_medium_removal(sdev, SCSI_REMOVAL_ALLOW);
	}

	/*
	 * XXX and what if there are packets in flight and this close()
	 * XXX is followed by a "rmmod sd_mod"?
	 */
1052 1053

	scsi_autopm_put_device(sdev);
Linus Torvalds's avatar
Linus Torvalds committed
1054 1055 1056 1057
	scsi_disk_put(sdkp);
	return 0;
}

1058
static int sd_getgeo(struct block_device *bdev, struct hd_geometry *geo)
Linus Torvalds's avatar
Linus Torvalds committed
1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075
{
	struct scsi_disk *sdkp = scsi_disk(bdev->bd_disk);
	struct scsi_device *sdp = sdkp->device;
	struct Scsi_Host *host = sdp->host;
	int diskinfo[4];

	/* default to most commonly used values */
        diskinfo[0] = 0x40;	/* 1 << 6 */
       	diskinfo[1] = 0x20;	/* 1 << 5 */
       	diskinfo[2] = sdkp->capacity >> 11;
	
	/* override with calculated, extended default, or driver values */
	if (host->hostt->bios_param)
		host->hostt->bios_param(sdp, bdev, sdkp->capacity, diskinfo);
	else
		scsicam_bios_param(bdev, sdkp->capacity, diskinfo);

1076 1077 1078
	geo->heads = diskinfo[0];
	geo->sectors = diskinfo[1];
	geo->cylinders = diskinfo[2];
Linus Torvalds's avatar
Linus Torvalds committed
1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089
	return 0;
}

/**
 *	sd_ioctl - process an ioctl
 *	@inode: only i_rdev/i_bdev members may be used
 *	@filp: only f_mode and f_flags may be used
 *	@cmd: ioctl command number
 *	@arg: this is third argument given to ioctl(2) system call.
 *	Often contains a pointer.
 *
Lucas De Marchi's avatar
Lucas De Marchi committed
1090
 *	Returns 0 if successful (some ioctls return positive numbers on
Linus Torvalds's avatar
Linus Torvalds committed
1091 1092 1093
 *	success as well). Returns a negated errno value in case of error.
 *
 *	Note: most ioctls are forward onto the block subsystem or further
1094
 *	down in the scsi subsystem.
Linus Torvalds's avatar
Linus Torvalds committed
1095
 **/
Al Viro's avatar
Al Viro committed
1096
static int sd_ioctl(struct block_device *bdev, fmode_t mode,
Linus Torvalds's avatar
Linus Torvalds committed
1097 1098 1099
		    unsigned int cmd, unsigned long arg)
{
	struct gendisk *disk = bdev->bd_disk;
1100 1101
	struct scsi_disk *sdkp = scsi_disk(disk);
	struct scsi_device *sdp = sdkp->device;
Linus Torvalds's avatar
Linus Torvalds committed
1102 1103 1104
	void __user *p = (void __user *)arg;
	int error;
    
1105 1106
	SCSI_LOG_IOCTL(1, sd_printk(KERN_INFO, sdkp, "sd_ioctl: disk=%s, "
				    "cmd=0x%x\n", disk->disk_name, cmd));
Linus Torvalds's avatar
Linus Torvalds committed
1107

1108 1109 1110 1111
	error = scsi_verify_blk_ioctl(bdev, cmd);
	if (error < 0)
		return error;

Linus Torvalds's avatar
Linus Torvalds committed
1112 1113 1114 1115 1116 1117
	/*
	 * If we are in the middle of error recovery, don't let anyone
	 * else try and use this device.  Also, if error recovery fails, it
	 * may try and take the device offline, in which case all further
	 * access to the device is prohibited.
	 */
1118
	error = scsi_nonblockable_ioctl(sdp, cmd, p,
1119
					(mode & FMODE_NDELAY) != 0);
Linus Torvalds's avatar
Linus Torvalds committed
1120
	if (!scsi_block_when_processing_errors(sdp) || !error)
1121
		goto out;
Linus Torvalds's avatar
Linus Torvalds committed
1122 1123 1124 1125 1126 1127 1128 1129 1130

	/*
	 * Send SCSI addressing ioctls directly to mid level, send other
	 * ioctls to block level and then onto mid level if they can't be
	 * resolved.
	 */
	switch (cmd) {
		case SCSI_IOCTL_GET_IDLUN:
		case SCSI_IOCTL_GET_BUS_NUMBER:
1131 1132
			error = scsi_ioctl(sdp, cmd, p);
			break;
Linus Torvalds's avatar
Linus Torvalds committed
1133
		default:
1134
			error = scsi_cmd_blk_ioctl(bdev, mode, cmd, p);
Linus Torvalds's avatar