sd.c 83.8 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"
68
#include "scsi_priv.h"
Linus Torvalds's avatar
Linus Torvalds committed
69 70
#include "scsi_logging.h"

71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90
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);
91 92 93
MODULE_ALIAS_SCSI_DEVICE(TYPE_DISK);
MODULE_ALIAS_SCSI_DEVICE(TYPE_MOD);
MODULE_ALIAS_SCSI_DEVICE(TYPE_RBC);
94

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

101
static void sd_config_discard(struct scsi_disk *, unsigned int);
102
static void sd_config_write_same(struct scsi_disk *);
103
static int  sd_revalidate_disk(struct gendisk *);
104
static void sd_unlock_native_capacity(struct gendisk *disk);
105 106 107
static int  sd_probe(struct device *);
static int  sd_remove(struct device *);
static void sd_shutdown(struct device *);
108
static int sd_suspend(struct device *);
109 110 111
static int sd_resume(struct device *);
static void sd_rescan(struct device *);
static int sd_done(struct scsi_cmnd *);
112
static int sd_eh_action(struct scsi_cmnd *, unsigned char *, int, int);
113
static void sd_read_capacity(struct scsi_disk *sdkp, unsigned char *buffer);
114
static void scsi_disk_release(struct device *cdev);
115 116 117
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
118
static DEFINE_SPINLOCK(sd_index_lock);
119
static DEFINE_IDA(sd_index_ida);
Linus Torvalds's avatar
Linus Torvalds committed
120 121 122 123

/* 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) */
124
static DEFINE_MUTEX(sd_ref_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
125

126 127
static struct kmem_cache *sd_cdb_cache;
static mempool_t *sd_cdb_pool;
128

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

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

154 155 156 157 158 159 160
	if (strncmp(buf, temp, sizeof(temp) - 1) == 0) {
		buf += sizeof(temp) - 1;
		sdkp->cache_override = 1;
	} else {
		sdkp->cache_override = 0;
	}

161
	for (i = 0; i < ARRAY_SIZE(sd_cache_types); i++) {
162
		len = strlen(sd_cache_types[i]);
163 164 165 166 167 168 169 170 171 172
		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;
173 174 175 176 177 178 179

	if (sdkp->cache_override) {
		sdkp->WCE = wce;
		sdkp->RCD = rcd;
		return count;
	}

180 181 182
	if (scsi_mode_sense(sdp, 0x08, 8, buffer, sizeof(buffer), SD_TIMEOUT,
			    SD_MAX_RETRIES, &data, NULL))
		return -EINVAL;
183
	len = min_t(size_t, sizeof(buffer), data.length - data.header_length -
184 185 186 187 188 189 190 191 192 193
		  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))
194
			sd_print_sense_hdr(sdkp, &sshdr);
195 196
		return -EINVAL;
	}
197
	revalidate_disk(sdkp->disk);
198 199 200
	return count;
}

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

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

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

	return count;
}

216 217 218
static ssize_t
sd_store_allow_restart(struct device *dev, struct device_attribute *attr,
		       const char *buf, size_t count)
219
{
220
	struct scsi_disk *sdkp = to_scsi_disk(dev);
221 222 223 224 225 226 227 228 229 230 231 232 233
	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;
}

234 235 236
static ssize_t
sd_show_cache_type(struct device *dev, struct device_attribute *attr,
		   char *buf)
237
{
238
	struct scsi_disk *sdkp = to_scsi_disk(dev);
239 240 241 242 243
	int ct = sdkp->RCD + 2*sdkp->WCE;

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

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

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

252 253 254
static ssize_t
sd_show_manage_start_stop(struct device *dev, struct device_attribute *attr,
			  char *buf)
255
{
256
	struct scsi_disk *sdkp = to_scsi_disk(dev);
257 258 259 260 261
	struct scsi_device *sdp = sdkp->device;

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

262 263 264
static ssize_t
sd_show_allow_restart(struct device *dev, struct device_attribute *attr,
		      char *buf)
265
{
266
	struct scsi_disk *sdkp = to_scsi_disk(dev);
267 268 269 270

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

271 272 273 274 275 276 277 278 279
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);
}

280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301
static ssize_t
sd_store_protection_type(struct device *dev, struct device_attribute *attr,
			 const char *buf, size_t count)
{
	struct scsi_disk *sdkp = to_scsi_disk(dev);
	unsigned int val;
	int err;

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

	err = kstrtouint(buf, 10, &val);

	if (err)
		return err;

	if (val >= 0 && val <= SD_DIF_TYPE3_PROTECTION)
		sdkp->protection_type = val;

	return count;
}

302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323
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);
}

324 325 326 327 328 329 330 331 332
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);
}

333 334 335 336 337 338
static ssize_t
sd_show_thin_provisioning(struct device *dev, struct device_attribute *attr,
			  char *buf)
{
	struct scsi_disk *sdkp = to_scsi_disk(dev);

339 340 341 342 343 344 345 346 347 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 375 376 377 378 379 380 381 382 383 384 385 386
	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;
387 388
}

389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413
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;
}

414 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 446 447 448 449 450 451 452
static ssize_t
sd_show_write_same_blocks(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_ws_blocks);
}

static ssize_t
sd_store_write_same_blocks(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;
	unsigned long max;
	int err;

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

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

	err = kstrtoul(buf, 10, &max);

	if (err)
		return err;

	if (max == 0)
		sdp->no_write_same = 1;
	else if (max <= SD_MAX_WS16_BLOCKS)
		sdkp->max_ws_blocks = max;

	sd_config_write_same(sdkp);

	return count;
}

453
static struct device_attribute sd_disk_attrs[] = {
454 455 456
	__ATTR(cache_type, S_IRUGO|S_IWUSR, sd_show_cache_type,
	       sd_store_cache_type),
	__ATTR(FUA, S_IRUGO, sd_show_fua, NULL),
457 458
	__ATTR(allow_restart, S_IRUGO|S_IWUSR, sd_show_allow_restart,
	       sd_store_allow_restart),
459 460
	__ATTR(manage_start_stop, S_IRUGO|S_IWUSR, sd_show_manage_start_stop,
	       sd_store_manage_start_stop),
461 462
	__ATTR(protection_type, S_IRUGO|S_IWUSR, sd_show_protection_type,
	       sd_store_protection_type),
463
	__ATTR(protection_mode, S_IRUGO, sd_show_protection_mode, NULL),
464
	__ATTR(app_tag_own, S_IRUGO, sd_show_app_tag_own, NULL),
465
	__ATTR(thin_provisioning, S_IRUGO, sd_show_thin_provisioning, NULL),
466 467
	__ATTR(provisioning_mode, S_IRUGO|S_IWUSR, sd_show_provisioning_mode,
	       sd_store_provisioning_mode),
468 469
	__ATTR(max_write_same_blocks, S_IRUGO|S_IWUSR,
	       sd_show_write_same_blocks, sd_store_write_same_blocks),
470 471 472
	__ATTR(max_medium_access_timeouts, S_IRUGO|S_IWUSR,
	       sd_show_max_medium_access_timeouts,
	       sd_store_max_medium_access_timeouts),
473 474 475 476 477 478
	__ATTR_NULL,
};

static struct class sd_disk_class = {
	.name		= "scsi_disk",
	.owner		= THIS_MODULE,
479 480
	.dev_release	= scsi_disk_release,
	.dev_attrs	= sd_disk_attrs,
481
};
Linus Torvalds's avatar
Linus Torvalds committed
482

483 484 485 486 487 488 489 490 491
static const struct dev_pm_ops sd_pm_ops = {
	.suspend		= sd_suspend,
	.resume			= sd_resume,
	.poweroff		= sd_suspend,
	.restore		= sd_resume,
	.runtime_suspend	= sd_suspend,
	.runtime_resume		= sd_resume,
};

Linus Torvalds's avatar
Linus Torvalds committed
492 493 494 495 496 497 498
static struct scsi_driver sd_template = {
	.owner			= THIS_MODULE,
	.gendrv = {
		.name		= "sd",
		.probe		= sd_probe,
		.remove		= sd_remove,
		.shutdown	= sd_shutdown,
499
		.pm		= &sd_pm_ops,
Linus Torvalds's avatar
Linus Torvalds committed
500 501
	},
	.rescan			= sd_rescan,
502
	.done			= sd_done,
503
	.eh_action		= sd_eh_action,
Linus Torvalds's avatar
Linus Torvalds committed
504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534
};

/*
 * 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
535
static struct scsi_disk *__scsi_disk_get(struct gendisk *disk)
Linus Torvalds's avatar
Linus Torvalds committed
536 537 538
{
	struct scsi_disk *sdkp = NULL;

Alan Stern's avatar
Alan Stern committed
539 540 541
	if (disk->private_data) {
		sdkp = scsi_disk(disk);
		if (scsi_device_get(sdkp->device) == 0)
542
			get_device(&sdkp->dev);
Alan Stern's avatar
Alan Stern committed
543 544 545 546 547 548 549 550 551 552
		else
			sdkp = NULL;
	}
	return sdkp;
}

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

553
	mutex_lock(&sd_ref_mutex);
Alan Stern's avatar
Alan Stern committed
554
	sdkp = __scsi_disk_get(disk);
555
	mutex_unlock(&sd_ref_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
556
	return sdkp;
Alan Stern's avatar
Alan Stern committed
557
}
Linus Torvalds's avatar
Linus Torvalds committed
558

Alan Stern's avatar
Alan Stern committed
559 560 561 562
static struct scsi_disk *scsi_disk_get_from_dev(struct device *dev)
{
	struct scsi_disk *sdkp;

563
	mutex_lock(&sd_ref_mutex);
Alan Stern's avatar
Alan Stern committed
564 565 566
	sdkp = dev_get_drvdata(dev);
	if (sdkp)
		sdkp = __scsi_disk_get(sdkp->disk);
567
	mutex_unlock(&sd_ref_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
568 569 570 571 572 573 574
	return sdkp;
}

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

575
	mutex_lock(&sd_ref_mutex);
576
	put_device(&sdkp->dev);
Linus Torvalds's avatar
Linus Torvalds committed
577
	scsi_device_put(sdev);
578
	mutex_unlock(&sd_ref_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
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
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);
}

606 607 608 609 610 611 612
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;
613 614
	q->limits.discard_alignment = sdkp->unmap_alignment *
		logical_block_size;
615 616 617 618
	q->limits.discard_granularity =
		max(sdkp->physical_block_size,
		    sdkp->unmap_granularity * logical_block_size);

619 620
	sdkp->provisioning_mode = mode;

621 622 623 624 625 626 627 628
	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:
629 630
		max_blocks = min_not_zero(sdkp->max_unmap_blocks,
					  (u32)SD_MAX_WS16_BLOCKS);
631 632 633
		break;

	case SD_LBP_WS16:
634 635
		max_blocks = min_not_zero(sdkp->max_ws_blocks,
					  (u32)SD_MAX_WS16_BLOCKS);
636 637 638
		break;

	case SD_LBP_WS10:
639 640
		max_blocks = min_not_zero(sdkp->max_ws_blocks,
					  (u32)SD_MAX_WS10_BLOCKS);
641 642 643
		break;

	case SD_LBP_ZERO:
644 645
		max_blocks = min_not_zero(sdkp->max_ws_blocks,
					  (u32)SD_MAX_WS10_BLOCKS);
646 647 648 649 650 651 652 653
		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);
}

654
/**
655
 * sd_setup_discard_cmnd - unmap blocks on thinly provisioned device
656
 * @sdp: scsi device to operate one
657 658 659 660 661
 * @rq: Request to prepare
 *
 * Will issue either UNMAP or WRITE SAME(16) depending on preference
 * indicated by target device.
 **/
662
static int sd_setup_discard_cmnd(struct scsi_device *sdp, struct request *rq)
663 664
{
	struct scsi_disk *sdkp = scsi_disk(rq->rq_disk);
665 666 667
	sector_t sector = blk_rq_pos(rq);
	unsigned int nr_sectors = blk_rq_sectors(rq);
	unsigned int nr_bytes = blk_rq_bytes(rq);
668
	unsigned int len;
669
	int ret;
670
	char *buf;
671
	struct page *page;
672

673 674
	sector >>= ilog2(sdp->sector_size) - 9;
	nr_sectors >>= ilog2(sdp->sector_size) - 9;
675 676 677 678
	rq->timeout = SD_TIMEOUT;

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

679 680 681 682
	page = alloc_page(GFP_ATOMIC | __GFP_ZERO);
	if (!page)
		return BLKPREP_DEFER;

683 684 685
	switch (sdkp->provisioning_mode) {
	case SD_LBP_UNMAP:
		buf = page_address(page);
686

687
		rq->cmd_len = 10;
688 689 690 691 692 693
		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]);
694
		put_unaligned_be32(nr_sectors, &buf[16]);
695

696
		len = 24;
697 698 699
		break;

	case SD_LBP_WS16:
700
		rq->cmd_len = 16;
701 702 703
		rq->cmd[0] = WRITE_SAME_16;
		rq->cmd[1] = 0x8; /* UNMAP */
		put_unaligned_be64(sector, &rq->cmd[2]);
704 705 706
		put_unaligned_be32(nr_sectors, &rq->cmd[10]);

		len = sdkp->device->sector_size;
707 708 709 710 711 712 713 714 715 716 717 718 719 720 721
		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:
722
		ret = BLKPREP_KILL;
723
		goto out;
724 725
	}

726
	blk_add_request_payload(rq, page, len);
727 728
	ret = scsi_setup_blk_pc_cmnd(sdp, rq);
	rq->buffer = page_address(page);
729
	rq->__data_len = nr_bytes;
730 731

out:
FUJITA Tomonori's avatar
FUJITA Tomonori committed
732 733 734 735
	if (ret != BLKPREP_OK) {
		__free_page(page);
		rq->buffer = NULL;
	}
736 737 738
	return ret;
}

739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815
static void sd_config_write_same(struct scsi_disk *sdkp)
{
	struct request_queue *q = sdkp->disk->queue;
	unsigned int logical_block_size = sdkp->device->sector_size;
	unsigned int blocks = 0;

	if (sdkp->device->no_write_same) {
		sdkp->max_ws_blocks = 0;
		goto out;
	}

	/* Some devices can not handle block counts above 0xffff despite
	 * supporting WRITE SAME(16). Consequently we default to 64k
	 * blocks per I/O unless the device explicitly advertises a
	 * bigger limit.
	 */
	if (sdkp->max_ws_blocks == 0)
		sdkp->max_ws_blocks = SD_MAX_WS10_BLOCKS;

	if (sdkp->ws16 || sdkp->max_ws_blocks > SD_MAX_WS10_BLOCKS)
		blocks = min_not_zero(sdkp->max_ws_blocks,
				      (u32)SD_MAX_WS16_BLOCKS);
	else
		blocks = min_not_zero(sdkp->max_ws_blocks,
				      (u32)SD_MAX_WS10_BLOCKS);

out:
	blk_queue_max_write_same_sectors(q, blocks * (logical_block_size >> 9));
}

/**
 * sd_setup_write_same_cmnd - write the same data to multiple blocks
 * @sdp: scsi device to operate one
 * @rq: Request to prepare
 *
 * Will issue either WRITE SAME(10) or WRITE SAME(16) depending on
 * preference indicated by target device.
 **/
static int sd_setup_write_same_cmnd(struct scsi_device *sdp, struct request *rq)
{
	struct scsi_disk *sdkp = scsi_disk(rq->rq_disk);
	struct bio *bio = rq->bio;
	sector_t sector = blk_rq_pos(rq);
	unsigned int nr_sectors = blk_rq_sectors(rq);
	unsigned int nr_bytes = blk_rq_bytes(rq);
	int ret;

	if (sdkp->device->no_write_same)
		return BLKPREP_KILL;

	BUG_ON(bio_offset(bio) || bio_iovec(bio)->bv_len != sdp->sector_size);

	sector >>= ilog2(sdp->sector_size) - 9;
	nr_sectors >>= ilog2(sdp->sector_size) - 9;

	rq->__data_len = sdp->sector_size;
	rq->timeout = SD_WRITE_SAME_TIMEOUT;
	memset(rq->cmd, 0, rq->cmd_len);

	if (sdkp->ws16 || sector > 0xffffffff || nr_sectors > 0xffff) {
		rq->cmd_len = 16;
		rq->cmd[0] = WRITE_SAME_16;
		put_unaligned_be64(sector, &rq->cmd[2]);
		put_unaligned_be32(nr_sectors, &rq->cmd[10]);
	} else {
		rq->cmd_len = 10;
		rq->cmd[0] = WRITE_SAME;
		put_unaligned_be32(sector, &rq->cmd[2]);
		put_unaligned_be16(nr_sectors, &rq->cmd[7]);
	}

	ret = scsi_setup_blk_pc_cmnd(sdp, rq);
	rq->__data_len = nr_bytes;

	return ret;
}

816 817
static int scsi_setup_flush_cmnd(struct scsi_device *sdp, struct request *rq)
{
818
	rq->timeout = SD_FLUSH_TIMEOUT;
819 820 821 822 823 824 825
	rq->retries = SD_MAX_RETRIES;
	rq->cmd[0] = SYNCHRONIZE_CACHE;
	rq->cmd_len = 10;

	return scsi_setup_blk_pc_cmnd(sdp, rq);
}

826 827
static void sd_unprep_fn(struct request_queue *q, struct request *rq)
{
FUJITA Tomonori's avatar
FUJITA Tomonori committed
828 829 830 831
	if (rq->cmd_flags & REQ_DISCARD) {
		free_page((unsigned long)rq->buffer);
		rq->buffer = NULL;
	}
832 833
}

Linus Torvalds's avatar
Linus Torvalds committed
834
/**
835
 *	sd_prep_fn - build a scsi (read or write) command from
Linus Torvalds's avatar
Linus Torvalds committed
836 837 838 839 840 841
 *	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).
 **/
842
static int sd_prep_fn(struct request_queue *q, struct request *rq)
Linus Torvalds's avatar
Linus Torvalds committed
843
{
844 845
	struct scsi_cmnd *SCpnt;
	struct scsi_device *sdp = q->queuedata;
846
	struct gendisk *disk = rq->rq_disk;
847
	struct scsi_disk *sdkp;
848
	sector_t block = blk_rq_pos(rq);
849
	sector_t threshold;
850
	unsigned int this_count = blk_rq_sectors(rq);
851
	int ret, host_dif;
852
	unsigned char protect;
853

854 855 856 857
	/*
	 * Discard request come in as REQ_TYPE_FS but we turn them into
	 * block PC requests to make life easier.
	 */
858
	if (rq->cmd_flags & REQ_DISCARD) {
859
		ret = sd_setup_discard_cmnd(sdp, rq);
860
		goto out;
861 862 863
	} else if (rq->cmd_flags & REQ_WRITE_SAME) {
		ret = sd_setup_write_same_cmnd(sdp, rq);
		goto out;
864 865 866
	} else if (rq->cmd_flags & REQ_FLUSH) {
		ret = scsi_setup_flush_cmnd(sdp, rq);
		goto out;
867
	} else if (rq->cmd_type == REQ_TYPE_BLOCK_PC) {
868 869 870 871 872 873 874 875 876 877
		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;
878
	sdkp = scsi_disk(disk);
879 880 881 882

	/* 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
883

884
	SCSI_LOG_HLQUEUE(1, scmd_printk(KERN_INFO, SCpnt,
885
					"sd_prep_fn: block=%llu, "
886 887 888
					"count=%d\n",
					(unsigned long long)block,
					this_count));
Linus Torvalds's avatar
Linus Torvalds committed
889 890

	if (!sdp || !scsi_device_online(sdp) ||
891
	    block + blk_rq_sectors(rq) > get_capacity(disk)) {
892
		SCSI_LOG_HLQUEUE(2, scmd_printk(KERN_INFO, SCpnt,
893 894
						"Finishing %u sectors\n",
						blk_rq_sectors(rq)));
895 896
		SCSI_LOG_HLQUEUE(2, scmd_printk(KERN_INFO, SCpnt,
						"Retry with 0x%p\n", SCpnt));
897
		goto out;
Linus Torvalds's avatar
Linus Torvalds committed
898 899 900 901 902 903 904
	}

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

909
	/*
910 911
	 * Some SD card readers can't handle multi-sector accesses which touch
	 * the last one or two hardware sectors.  Split accesses as needed.
912
	 */
913 914 915 916 917 918 919 920 921 922 923 924
	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;
		}
	}
925

926 927
	SCSI_LOG_HLQUEUE(2, scmd_printk(KERN_INFO, SCpnt, "block=%llu\n",
					(unsigned long long)block));
Linus Torvalds's avatar
Linus Torvalds committed
928 929 930 931 932 933 934 935 936 937 938 939 940

	/*
	 * 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) {
941
		if ((block & 1) || (blk_rq_sectors(rq) & 1)) {
942 943
			scmd_printk(KERN_ERR, SCpnt,
				    "Bad block number requested\n");
944
			goto out;
Linus Torvalds's avatar
Linus Torvalds committed
945 946 947 948 949 950
		} else {
			block = block >> 1;
			this_count = this_count >> 1;
		}
	}
	if (sdp->sector_size == 2048) {
951
		if ((block & 3) || (blk_rq_sectors(rq) & 3)) {
952 953
			scmd_printk(KERN_ERR, SCpnt,
				    "Bad block number requested\n");
954
			goto out;
Linus Torvalds's avatar
Linus Torvalds committed
955 956 957 958 959 960
		} else {
			block = block >> 2;
			this_count = this_count >> 2;
		}
	}
	if (sdp->sector_size == 4096) {
961
		if ((block & 7) || (blk_rq_sectors(rq) & 7)) {
962 963
			scmd_printk(KERN_ERR, SCpnt,
				    "Bad block number requested\n");
964
			goto out;
Linus Torvalds's avatar
Linus Torvalds committed
965 966 967 968 969 970 971
		} else {
			block = block >> 3;
			this_count = this_count >> 3;
		}
	}
	if (rq_data_dir(rq) == WRITE) {
		if (!sdp->writeable) {
972
			goto out;
Linus Torvalds's avatar
Linus Torvalds committed
973 974 975
		}
		SCpnt->cmnd[0] = WRITE_6;
		SCpnt->sc_data_direction = DMA_TO_DEVICE;
976

977 978
		if (blk_integrity_rq(rq))
			sd_dif_prepare(rq, block, sdp->sector_size);
979

Linus Torvalds's avatar
Linus Torvalds committed
980 981 982 983
	} else if (rq_data_dir(rq) == READ) {
		SCpnt->cmnd[0] = READ_6;
		SCpnt->sc_data_direction = DMA_FROM_DEVICE;
	} else {
984
		scmd_printk(KERN_ERR, SCpnt, "Unknown command %x\n", rq->cmd_flags);
985
		goto out;
Linus Torvalds's avatar
Linus Torvalds committed
986 987
	}

988
	SCSI_LOG_HLQUEUE(2, scmd_printk(KERN_INFO, SCpnt,
989
					"%s %d/%u 512 byte blocks.\n",
990 991
					(rq_data_dir(rq) == WRITE) ?
					"writing" : "reading", this_count,
992
					blk_rq_sectors(rq)));
Linus Torvalds's avatar
Linus Torvalds committed
993

994
	/* Set RDPROTECT/WRPROTECT if disk is formatted with DIF */
995 996
	host_dif = scsi_host_dif_capable(sdp->host, sdkp->protection_type);
	if (host_dif)
997
		protect = 1 << 5;
998
	else
999 1000 1001 1002 1003 1004 1005 1006 1007
		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;
		}
1008

1009 1010 1011 1012 1013
		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;
1014
		SCpnt->cmnd[10] = protect | ((rq->cmd_flags & REQ_FUA) ? 0x8 : 0);
1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036

		/* 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;
1037
	} else if (sdp->use_16_for_rw) {
Linus Torvalds's avatar
Linus Torvalds committed
1038
		SCpnt->cmnd[0] += READ_16 - READ_6;
1039
		SCpnt->cmnd[1] = protect | ((rq->cmd_flags & REQ_FUA) ? 0x8 : 0);
Linus Torvalds's avatar
Linus Torvalds committed
1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053
		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) ||
1054
		   scsi_device_protection(SCpnt->device) ||
Linus Torvalds's avatar
Linus Torvalds committed
1055 1056 1057 1058 1059
		   SCpnt->device->use_10_for_rw) {
		if (this_count > 0xffff)
			this_count = 0xffff;

		SCpnt->cmnd[0] += READ_10 - READ_6;
1060
		SCpnt->cmnd[1] = protect | ((rq->cmd_flags & REQ_FUA) ? 0x8 : 0);
Linus Torvalds's avatar
Linus Torvalds committed
1061 1062 1063 1064 1065 1066 1067 1068
		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 {
1069
		if (unlikely(rq->cmd_flags & REQ_FUA)) {
1070 1071 1072 1073 1074 1075
			/*
			 * This happens only if this drive failed
			 * 10byte rw command with ILLEGAL_REQUEST
			 * during operation and thus turned off
			 * use_10_for_rw.
			 */
1076 1077
			scmd_printk(KERN_ERR, SCpnt,
				    "FUA write on READ/WRITE(6) drive\n");
1078
			goto out;
1079 1080
		}

Linus Torvalds's avatar
Linus Torvalds committed
1081 1082 1083 1084 1085 1086
		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;
	}
1087
	SCpnt->sdb.length = this_count * sdp->sector_size;
Linus Torvalds's avatar
Linus Torvalds committed
1088

1089
	/* If DIF or DIX is enabled, tell HBA how to handle request */
1090
	if (host_dif || scsi_prot_sg_count(SCpnt))
1091
		sd_prot_op(SCpnt, host_dif);
1092

Linus Torvalds's avatar
Linus Torvalds committed
1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105
	/*
	 * 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.
	 */
1106 1107 1108
	ret = BLKPREP_OK;
 out:
	return scsi_prep_return(q, rq, ret);
Linus Torvalds's avatar
Linus Torvalds committed
1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122
}

/**
 *	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.
1123 1124
 *
 *	Locking: called with bdev->bd_mutex held.
Linus Torvalds's avatar
Linus Torvalds committed
1125
 **/
Al Viro's avatar
Al Viro committed
1126
static int sd_open(struct block_device *bdev, fmode_t mode)
Linus Torvalds's avatar
Linus Torvalds committed
1127
{
Al Viro's avatar
Al Viro committed
1128
	struct scsi_disk *sdkp = scsi_disk_get(bdev->bd_disk);
Linus Torvalds's avatar
Linus Torvalds committed
1129 1130 1131
	struct scsi_device *sdev;
	int retval;

Al Viro's avatar
Al Viro committed
1132
	if (!sdkp)
Linus Torvalds's avatar
Linus Torvalds committed
1133 1134
		return -ENXIO;

1135
	SCSI_LOG_HLQUEUE(3, sd_printk(KERN_INFO, sdkp, "sd_open\n"));
Linus Torvalds's avatar
Linus Torvalds committed
1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147

	sdev = sdkp->device;

	/*
	 * 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
1148
		check_disk_change(bdev);
Linus Torvalds's avatar
Linus Torvalds committed
1149 1150 1151 1152 1153

	/*
	 * If the drive is empty, just let the open fail.
	 */
	retval = -ENOMEDIUM;
Al Viro's avatar
Al Viro committed
1154
	if (sdev->removable && !sdkp->media_present && !(mode & FMODE_NDELAY))
Linus Torvalds's avatar
Linus Torvalds committed
1155 1156 1157 1158 1159 1160 1161
		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
1162
	if (sdkp->write_prot && (mode & FMODE_WRITE))
Linus Torvalds's avatar
Linus Torvalds committed
1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174
		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;

1175
	if ((atomic_inc_return(&sdkp->openers) == 1) && sdev->removable) {
Linus Torvalds's avatar
Linus Torvalds committed
1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196
		if (scsi_block_when_processing_errors(sdev))
			scsi_set_medium_removal(sdev, SCSI_REMOVAL_PREVENT);
	}

	return 0;

error_out:
	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.
1197 1198
 *
 *	Locking: called with bdev->bd_mutex held.
Linus Torvalds's avatar
Linus Torvalds committed
1199
 **/
1200
static void sd_release(struct gendisk *disk, fmode_t mode)
Linus Torvalds's avatar
Linus Torvalds committed
1201 1202 1203 1204
{
	struct scsi_disk *sdkp = scsi_disk(disk);
	struct scsi_device *sdev = sdkp->device;

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

Alan Stern's avatar
Alan Stern committed
1207
	if (atomic_dec_return(&sdkp->openers) == 0 && sdev->removable) {
Linus Torvalds's avatar
Linus Torvalds committed
1208 1209 1210 1211 1212 1213 1214 1215
		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"?
	 */
1216

Linus Torvalds's avatar
Linus Torvalds committed
1217 1218 1219
	scsi_disk_put(sdkp);
}

1220
static int sd_getgeo(struct block_device *bdev, struct hd_geometry *geo)
Linus Torvalds's avatar
Linus Torvalds committed
1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237
{
	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);

1238 1239 1240
	geo->heads = diskinfo[0];
	geo->sectors = diskinfo[1];
	geo->cylinders = diskinfo[2];
Linus Torvalds's avatar
Linus Torvalds committed
1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251
	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
1252
 *	Returns 0 if successful (some ioctls return positive numbers on
Linus Torvalds's avatar
Linus Torvalds committed
1253 1254 1255
 *	success as well). Returns a negated errno value in case of error.
 *
 *	Note: most ioctls are forward onto the block subsystem or further
1256 </