sd.c 86.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 109
static int sd_suspend_system(struct device *);
static int sd_suspend_runtime(struct device *);
110 111
static int sd_resume(struct device *);
static void sd_rescan(struct device *);
112 113
static int sd_init_command(struct scsi_cmnd *SCpnt);
static void sd_uninit_command(struct scsi_cmnd *SCpnt);
114
static int sd_done(struct scsi_cmnd *);
115
static int sd_eh_action(struct scsi_cmnd *, int);
116
static void sd_read_capacity(struct scsi_disk *sdkp, unsigned char *buffer);
117
static void scsi_disk_release(struct device *cdev);
118 119 120
static void sd_print_sense_hdr(struct scsi_disk *, struct scsi_sense_hdr *);
static void sd_print_result(struct scsi_disk *, int);

121
static DEFINE_SPINLOCK(sd_index_lock);
122
static DEFINE_IDA(sd_index_ida);
Linus Torvalds's avatar
Linus Torvalds committed
123 124 125 126

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

129 130
static struct kmem_cache *sd_cdb_cache;
static mempool_t *sd_cdb_pool;
131

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

137 138 139 140 141 142 143 144 145 146 147 148 149
static void sd_set_flush_flag(struct scsi_disk *sdkp)
{
	unsigned flush = 0;

	if (sdkp->WCE) {
		flush |= REQ_FLUSH;
		if (sdkp->DPOFUA)
			flush |= REQ_FUA;
	}

	blk_queue_flush(sdkp->disk->queue, flush);
}

150
static ssize_t
151 152
cache_type_store(struct device *dev, struct device_attribute *attr,
		 const char *buf, size_t count)
153 154
{
	int i, ct = -1, rcd, wce, sp;
155
	struct scsi_disk *sdkp = to_scsi_disk(dev);
156 157 158 159 160
	struct scsi_device *sdp = sdkp->device;
	char buffer[64];
	char *buffer_data;
	struct scsi_mode_data data;
	struct scsi_sense_hdr sshdr;
161
	static const char temp[] = "temporary ";
162 163 164 165 166 167 168 169
	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;

170 171 172 173 174 175 176
	if (strncmp(buf, temp, sizeof(temp) - 1) == 0) {
		buf += sizeof(temp) - 1;
		sdkp->cache_override = 1;
	} else {
		sdkp->cache_override = 0;
	}

177
	for (i = 0; i < ARRAY_SIZE(sd_cache_types); i++) {
178
		len = strlen(sd_cache_types[i]);
179 180 181 182 183 184 185 186 187 188
		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;
189 190 191 192

	if (sdkp->cache_override) {
		sdkp->WCE = wce;
		sdkp->RCD = rcd;
193
		sd_set_flush_flag(sdkp);
194 195 196
		return count;
	}

197 198 199
	if (scsi_mode_sense(sdp, 0x08, 8, buffer, sizeof(buffer), SD_TIMEOUT,
			    SD_MAX_RETRIES, &data, NULL))
		return -EINVAL;
200
	len = min_t(size_t, sizeof(buffer), data.length - data.header_length -
201 202 203 204 205 206 207 208 209 210
		  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))
211
			sd_print_sense_hdr(sdkp, &sshdr);
212 213
		return -EINVAL;
	}
214
	revalidate_disk(sdkp->disk);
215 216 217
	return count;
}

218
static ssize_t
219 220 221 222 223 224 225 226 227 228 229 230
manage_start_stop_show(struct device *dev, struct device_attribute *attr,
		       char *buf)
{
	struct scsi_disk *sdkp = to_scsi_disk(dev);
	struct scsi_device *sdp = sdkp->device;

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

static ssize_t
manage_start_stop_store(struct device *dev, struct device_attribute *attr,
			const char *buf, size_t count)
231
{
232
	struct scsi_disk *sdkp = to_scsi_disk(dev);
233 234 235 236 237 238 239 240 241
	struct scsi_device *sdp = sdkp->device;

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

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

	return count;
}
242
static DEVICE_ATTR_RW(manage_start_stop);
243

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

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

static ssize_t
allow_restart_store(struct device *dev, struct device_attribute *attr,
		    const char *buf, size_t count)
255
{
256
	struct scsi_disk *sdkp = to_scsi_disk(dev);
257 258 259 260 261 262 263 264 265 266 267 268
	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;
}
269
static DEVICE_ATTR_RW(allow_restart);
270

271
static ssize_t
272
cache_type_show(struct device *dev, struct device_attribute *attr, char *buf)
273
{
274
	struct scsi_disk *sdkp = to_scsi_disk(dev);
275 276 277 278
	int ct = sdkp->RCD + 2*sdkp->WCE;

	return snprintf(buf, 40, "%s\n", sd_cache_types[ct]);
}
279
static DEVICE_ATTR_RW(cache_type);
280

281
static ssize_t
282
FUA_show(struct device *dev, struct device_attribute *attr, char *buf)
283
{
284
	struct scsi_disk *sdkp = to_scsi_disk(dev);
285 286 287

	return snprintf(buf, 20, "%u\n", sdkp->DPOFUA);
}
288
static DEVICE_ATTR_RO(FUA);
289

290
static ssize_t
291 292
protection_type_show(struct device *dev, struct device_attribute *attr,
		     char *buf)
293 294 295 296 297 298
{
	struct scsi_disk *sdkp = to_scsi_disk(dev);

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

299
static ssize_t
300 301
protection_type_store(struct device *dev, struct device_attribute *attr,
		      const char *buf, size_t count)
302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319
{
	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;
}
320
static DEVICE_ATTR_RW(protection_type);
321

322
static ssize_t
323 324
protection_mode_show(struct device *dev, struct device_attribute *attr,
		     char *buf)
325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342
{
	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);
}
343
static DEVICE_ATTR_RO(protection_mode);
344

345
static ssize_t
346
app_tag_own_show(struct device *dev, struct device_attribute *attr, char *buf)
347 348 349 350 351
{
	struct scsi_disk *sdkp = to_scsi_disk(dev);

	return snprintf(buf, 20, "%u\n", sdkp->ATO);
}
352
static DEVICE_ATTR_RO(app_tag_own);
353

354
static ssize_t
355 356
thin_provisioning_show(struct device *dev, struct device_attribute *attr,
		       char *buf)
357 358 359
{
	struct scsi_disk *sdkp = to_scsi_disk(dev);

360 361
	return snprintf(buf, 20, "%u\n", sdkp->lbpme);
}
362
static DEVICE_ATTR_RO(thin_provisioning);
363 364 365 366 367 368 369 370 371 372 373

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
374 375
provisioning_mode_show(struct device *dev, struct device_attribute *attr,
		       char *buf)
376 377 378 379 380 381 382
{
	struct scsi_disk *sdkp = to_scsi_disk(dev);

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

static ssize_t
383 384
provisioning_mode_store(struct device *dev, struct device_attribute *attr,
			const char *buf, size_t count)
385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408
{
	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;
409
}
410
static DEVICE_ATTR_RW(provisioning_mode);
411

412
static ssize_t
413 414
max_medium_access_timeouts_show(struct device *dev,
				struct device_attribute *attr, char *buf)
415 416 417 418 419 420 421
{
	struct scsi_disk *sdkp = to_scsi_disk(dev);

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

static ssize_t
422 423 424
max_medium_access_timeouts_store(struct device *dev,
				 struct device_attribute *attr, const char *buf,
				 size_t count)
425 426 427 428 429 430 431 432 433 434 435
{
	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;
}
436
static DEVICE_ATTR_RW(max_medium_access_timeouts);
437

438
static ssize_t
439 440
max_write_same_blocks_show(struct device *dev, struct device_attribute *attr,
			   char *buf)
441 442 443 444 445 446 447
{
	struct scsi_disk *sdkp = to_scsi_disk(dev);

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

static ssize_t
448 449
max_write_same_blocks_store(struct device *dev, struct device_attribute *attr,
			    const char *buf, size_t count)
450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468
{
	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;
469 470
	else if (max <= SD_MAX_WS16_BLOCKS) {
		sdp->no_write_same = 0;
471
		sdkp->max_ws_blocks = max;
472
	}
473 474 475 476 477

	sd_config_write_same(sdkp);

	return count;
}
478 479 480 481 482 483 484 485 486 487 488 489 490 491 492
static DEVICE_ATTR_RW(max_write_same_blocks);

static struct attribute *sd_disk_attrs[] = {
	&dev_attr_cache_type.attr,
	&dev_attr_FUA.attr,
	&dev_attr_allow_restart.attr,
	&dev_attr_manage_start_stop.attr,
	&dev_attr_protection_type.attr,
	&dev_attr_protection_mode.attr,
	&dev_attr_app_tag_own.attr,
	&dev_attr_thin_provisioning.attr,
	&dev_attr_provisioning_mode.attr,
	&dev_attr_max_write_same_blocks.attr,
	&dev_attr_max_medium_access_timeouts.attr,
	NULL,
493
};
494
ATTRIBUTE_GROUPS(sd_disk);
495 496 497 498

static struct class sd_disk_class = {
	.name		= "scsi_disk",
	.owner		= THIS_MODULE,
499
	.dev_release	= scsi_disk_release,
500
	.dev_groups	= sd_disk_groups,
501
};
Linus Torvalds's avatar
Linus Torvalds committed
502

503
static const struct dev_pm_ops sd_pm_ops = {
504
	.suspend		= sd_suspend_system,
505
	.resume			= sd_resume,
506
	.poweroff		= sd_suspend_system,
507
	.restore		= sd_resume,
508
	.runtime_suspend	= sd_suspend_runtime,
509 510 511
	.runtime_resume		= sd_resume,
};

Linus Torvalds's avatar
Linus Torvalds committed
512 513 514 515 516 517 518
static struct scsi_driver sd_template = {
	.owner			= THIS_MODULE,
	.gendrv = {
		.name		= "sd",
		.probe		= sd_probe,
		.remove		= sd_remove,
		.shutdown	= sd_shutdown,
519
		.pm		= &sd_pm_ops,
Linus Torvalds's avatar
Linus Torvalds committed
520 521
	},
	.rescan			= sd_rescan,
522 523
	.init_command		= sd_init_command,
	.uninit_command		= sd_uninit_command,
524
	.done			= sd_done,
525
	.eh_action		= sd_eh_action,
Linus Torvalds's avatar
Linus Torvalds committed
526 527
};

528 529 530 531 532 533 534 535 536 537
/*
 * Dummy kobj_map->probe function.
 * The default ->probe function will call modprobe, which is
 * pointless as this module is already loaded.
 */
static struct kobject *sd_default_probe(dev_t devt, int *partno, void *data)
{
	return NULL;
}

Linus Torvalds's avatar
Linus Torvalds committed
538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566
/*
 * 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
567
static struct scsi_disk *__scsi_disk_get(struct gendisk *disk)
Linus Torvalds's avatar
Linus Torvalds committed
568 569 570
{
	struct scsi_disk *sdkp = NULL;

Alan Stern's avatar
Alan Stern committed
571 572 573
	if (disk->private_data) {
		sdkp = scsi_disk(disk);
		if (scsi_device_get(sdkp->device) == 0)
574
			get_device(&sdkp->dev);
Alan Stern's avatar
Alan Stern committed
575 576 577 578 579 580 581 582 583 584
		else
			sdkp = NULL;
	}
	return sdkp;
}

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

585
	mutex_lock(&sd_ref_mutex);
Alan Stern's avatar
Alan Stern committed
586
	sdkp = __scsi_disk_get(disk);
587
	mutex_unlock(&sd_ref_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
588
	return sdkp;
Alan Stern's avatar
Alan Stern committed
589
}
Linus Torvalds's avatar
Linus Torvalds committed
590

Alan Stern's avatar
Alan Stern committed
591 592 593 594
static struct scsi_disk *scsi_disk_get_from_dev(struct device *dev)
{
	struct scsi_disk *sdkp;

595
	mutex_lock(&sd_ref_mutex);
Alan Stern's avatar
Alan Stern committed
596 597 598
	sdkp = dev_get_drvdata(dev);
	if (sdkp)
		sdkp = __scsi_disk_get(sdkp->disk);
599
	mutex_unlock(&sd_ref_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
600 601 602 603 604 605 606
	return sdkp;
}

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

607
	mutex_lock(&sd_ref_mutex);
608
	put_device(&sdkp->dev);
Linus Torvalds's avatar
Linus Torvalds committed
609
	scsi_device_put(sdev);
610
	mutex_unlock(&sd_ref_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
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
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);
}

638 639 640 641 642 643 644
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;
645 646
	q->limits.discard_alignment = sdkp->unmap_alignment *
		logical_block_size;
647 648 649 650
	q->limits.discard_granularity =
		max(sdkp->physical_block_size,
		    sdkp->unmap_granularity * logical_block_size);

651 652
	sdkp->provisioning_mode = mode;

653 654 655 656 657 658 659 660
	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:
661 662
		max_blocks = min_not_zero(sdkp->max_unmap_blocks,
					  (u32)SD_MAX_WS16_BLOCKS);
663 664 665
		break;

	case SD_LBP_WS16:
666 667
		max_blocks = min_not_zero(sdkp->max_ws_blocks,
					  (u32)SD_MAX_WS16_BLOCKS);
668 669 670
		break;

	case SD_LBP_WS10:
671 672
		max_blocks = min_not_zero(sdkp->max_ws_blocks,
					  (u32)SD_MAX_WS10_BLOCKS);
673 674 675
		break;

	case SD_LBP_ZERO:
676 677
		max_blocks = min_not_zero(sdkp->max_ws_blocks,
					  (u32)SD_MAX_WS10_BLOCKS);
678 679 680 681 682 683 684 685
		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);
}

686
/**
687
 * sd_setup_discard_cmnd - unmap blocks on thinly provisioned device
688
 * @sdp: scsi device to operate one
689 690 691 692 693
 * @rq: Request to prepare
 *
 * Will issue either UNMAP or WRITE SAME(16) depending on preference
 * indicated by target device.
 **/
694
static int sd_setup_discard_cmnd(struct scsi_cmnd *cmd)
695
{
696 697
	struct request *rq = cmd->request;
	struct scsi_device *sdp = cmd->device;
698
	struct scsi_disk *sdkp = scsi_disk(rq->rq_disk);
699 700 701
	sector_t sector = blk_rq_pos(rq);
	unsigned int nr_sectors = blk_rq_sectors(rq);
	unsigned int nr_bytes = blk_rq_bytes(rq);
702
	unsigned int len;
703
	int ret;
704
	char *buf;
705
	struct page *page;
706

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

710 711 712 713
	page = alloc_page(GFP_ATOMIC | __GFP_ZERO);
	if (!page)
		return BLKPREP_DEFER;

714 715 716
	switch (sdkp->provisioning_mode) {
	case SD_LBP_UNMAP:
		buf = page_address(page);
717

718 719 720
		cmd->cmd_len = 10;
		cmd->cmnd[0] = UNMAP;
		cmd->cmnd[8] = 24;
721 722 723 724

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

727
		len = 24;
728 729 730
		break;

	case SD_LBP_WS16:
731 732 733 734 735
		cmd->cmd_len = 16;
		cmd->cmnd[0] = WRITE_SAME_16;
		cmd->cmnd[1] = 0x8; /* UNMAP */
		put_unaligned_be64(sector, &cmd->cmnd[2]);
		put_unaligned_be32(nr_sectors, &cmd->cmnd[10]);
736 737

		len = sdkp->device->sector_size;
738 739 740 741
		break;

	case SD_LBP_WS10:
	case SD_LBP_ZERO:
742 743
		cmd->cmd_len = 10;
		cmd->cmnd[0] = WRITE_SAME;
744
		if (sdkp->provisioning_mode == SD_LBP_WS10)
745 746 747
			cmd->cmnd[1] = 0x8; /* UNMAP */
		put_unaligned_be32(sector, &cmd->cmnd[2]);
		put_unaligned_be16(nr_sectors, &cmd->cmnd[7]);
748 749 750 751 752

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

	default:
753
		ret = BLKPREP_KILL;
754
		goto out;
755 756
	}

757
	rq->completion_data = page;
758 759 760
	rq->timeout = SD_TIMEOUT;

	cmd->transfersize = len;
761
	cmd->allowed = SD_MAX_RETRIES;
762 763 764 765 766 767 768 769 770

	/*
	 * Initially __data_len is set to the amount of data that needs to be
	 * transferred to the target. This amount depends on whether WRITE SAME
	 * or UNMAP is being used. After the scatterlist has been mapped by
	 * scsi_init_io() we set __data_len to the size of the area to be
	 * discarded on disk. This allows us to report completion on the full
	 * amount of blocks described by the request.
	 */
771
	blk_add_request_payload(rq, page, len);
772
	ret = scsi_init_io(cmd, GFP_ATOMIC);
773
	rq->__data_len = nr_bytes;
774 775

out:
776
	if (ret != BLKPREP_OK)
777
		__free_page(page);
778 779 780
	return ret;
}

781 782 783 784 785 786 787 788 789 790 791 792 793 794 795
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;

	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.
	 */
796 797 798 799 800 801 802 803 804 805
	if (sdkp->max_ws_blocks > SD_MAX_WS10_BLOCKS)
		sdkp->max_ws_blocks = min_not_zero(sdkp->max_ws_blocks,
						   (u32)SD_MAX_WS16_BLOCKS);
	else if (sdkp->ws16 || sdkp->ws10 || sdkp->device->no_report_opcodes)
		sdkp->max_ws_blocks = min_not_zero(sdkp->max_ws_blocks,
						   (u32)SD_MAX_WS10_BLOCKS);
	else {
		sdkp->device->no_write_same = 1;
		sdkp->max_ws_blocks = 0;
	}
806 807

out:
808 809
	blk_queue_max_write_same_sectors(q, sdkp->max_ws_blocks *
					 (logical_block_size >> 9));
810 811 812 813
}

/**
 * sd_setup_write_same_cmnd - write the same data to multiple blocks
814
 * @cmd: command to prepare
815 816 817 818
 *
 * Will issue either WRITE SAME(10) or WRITE SAME(16) depending on
 * preference indicated by target device.
 **/
819
static int sd_setup_write_same_cmnd(struct scsi_cmnd *cmd)
820
{
821 822
	struct request *rq = cmd->request;
	struct scsi_device *sdp = cmd->device;
823 824 825 826 827 828 829 830 831 832
	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;

833
	BUG_ON(bio_offset(bio) || bio_iovec(bio).bv_len != sdp->sector_size);
834 835 836 837 838 839 840

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

	rq->timeout = SD_WRITE_SAME_TIMEOUT;

	if (sdkp->ws16 || sector > 0xffffffff || nr_sectors > 0xffff) {
841 842 843 844
		cmd->cmd_len = 16;
		cmd->cmnd[0] = WRITE_SAME_16;
		put_unaligned_be64(sector, &cmd->cmnd[2]);
		put_unaligned_be32(nr_sectors, &cmd->cmnd[10]);
845
	} else {
846 847 848 849
		cmd->cmd_len = 10;
		cmd->cmnd[0] = WRITE_SAME;
		put_unaligned_be32(sector, &cmd->cmnd[2]);
		put_unaligned_be16(nr_sectors, &cmd->cmnd[7]);
850 851
	}

852
	cmd->transfersize = sdp->sector_size;
853
	cmd->allowed = SD_MAX_RETRIES;
854

855 856 857 858 859 860 861 862 863 864 865 866 867
	/*
	 * For WRITE_SAME the data transferred in the DATA IN buffer is
	 * different from the amount of data actually written to the target.
	 *
	 * We set up __data_len to the amount of data transferred from the
	 * DATA IN buffer so that blk_rq_map_sg set up the proper S/G list
	 * to transfer a single sector of data first, but then reset it to
	 * the amount of data to be written right after so that the I/O path
	 * knows how much to actually write.
	 */
	rq->__data_len = sdp->sector_size;
	ret = scsi_init_io(cmd, GFP_ATOMIC);
	rq->__data_len = nr_bytes;
868 869 870
	return ret;
}

871
static int sd_setup_flush_cmnd(struct scsi_cmnd *cmd)
872
{
873 874 875 876
	struct request *rq = cmd->request;

	/* flush requests don't perform I/O, zero the S/G table */
	memset(&cmd->sdb, 0, sizeof(cmd->sdb));
877

878 879 880 881 882 883 884
	cmd->cmnd[0] = SYNCHRONIZE_CACHE;
	cmd->cmd_len = 10;
	cmd->transfersize = 0;
	cmd->allowed = SD_MAX_RETRIES;

	rq->timeout *= SD_FLUSH_TIMEOUT_MULTIPLIER;
	return BLKPREP_OK;
885 886
}

887
static int sd_setup_read_write_cmnd(struct scsi_cmnd *SCpnt)
Linus Torvalds's avatar
Linus Torvalds committed
888
{
889 890
	struct request *rq = SCpnt->request;
	struct scsi_device *sdp = SCpnt->device;
891
	struct gendisk *disk = rq->rq_disk;
892
	struct scsi_disk *sdkp;
893
	sector_t block = blk_rq_pos(rq);
894
	sector_t threshold;
895
	unsigned int this_count = blk_rq_sectors(rq);
896
	int ret, host_dif;
897
	unsigned char protect;
898

899
	ret = scsi_init_io(SCpnt, GFP_ATOMIC);
900 901 902
	if (ret != BLKPREP_OK)
		goto out;
	SCpnt = rq->special;
903
	sdkp = scsi_disk(disk);
904 905 906 907

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

909 910 911 912
	SCSI_LOG_HLQUEUE(1,
		scmd_printk(KERN_INFO, SCpnt,
			"%s: block=%llu, count=%d\n",
			__func__, (unsigned long long)block, this_count));
Linus Torvalds's avatar
Linus Torvalds committed
913 914

	if (!sdp || !scsi_device_online(sdp) ||
915
	    block + blk_rq_sectors(rq) > get_capacity(disk)) {
916
		SCSI_LOG_HLQUEUE(2, scmd_printk(KERN_INFO, SCpnt,
917 918
						"Finishing %u sectors\n",
						blk_rq_sectors(rq)));
919 920
		SCSI_LOG_HLQUEUE(2, scmd_printk(KERN_INFO, SCpnt,
						"Retry with 0x%p\n", SCpnt));
921
		goto out;
Linus Torvalds's avatar
Linus Torvalds committed
922 923 924 925 926 927 928
	}

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

933
	/*
934 935
	 * Some SD card readers can't handle multi-sector accesses which touch
	 * the last one or two hardware sectors.  Split accesses as needed.
936
	 */
937 938 939 940 941 942 943 944 945 946 947 948
	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;
		}
	}
949

950 951
	SCSI_LOG_HLQUEUE(2, scmd_printk(KERN_INFO, SCpnt, "block=%llu\n",
					(unsigned long long)block));
Linus Torvalds's avatar
Linus Torvalds committed
952 953 954 955 956 957 958 959 960 961 962 963 964

	/*
	 * 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) {
965
		if ((block & 1) || (blk_rq_sectors(rq) & 1)) {
966 967
			scmd_printk(KERN_ERR, SCpnt,
				    "Bad block number requested\n");
968
			goto out;
Linus Torvalds's avatar
Linus Torvalds committed
969 970 971 972 973 974
		} else {
			block = block >> 1;
			this_count = this_count >> 1;
		}
	}
	if (sdp->sector_size == 2048) {
975
		if ((block & 3) || (blk_rq_sectors(rq) & 3)) {
976 977
			scmd_printk(KERN_ERR, SCpnt,
				    "Bad block number requested\n");
978
			goto out;
Linus Torvalds's avatar
Linus Torvalds committed
979 980 981 982 983 984
		} else {
			block = block >> 2;
			this_count = this_count >> 2;
		}
	}
	if (sdp->sector_size == 4096) {
985
		if ((block & 7) || (blk_rq_sectors(rq) & 7)) {
986 987
			scmd_printk(KERN_ERR, SCpnt,
				    "Bad block number requested\n");
988
			goto out;
Linus Torvalds's avatar
Linus Torvalds committed
989 990 991 992 993 994 995
		} else {
			block = block >> 3;
			this_count = this_count >> 3;
		}
	}
	if (rq_data_dir(rq) == WRITE) {
		SCpnt->cmnd[0] = WRITE_6;
996

997 998
		if (blk_integrity_rq(rq))
			sd_dif_prepare(rq, block, sdp->sector_size);
999

Linus Torvalds's avatar
Linus Torvalds committed
1000 1001 1002
	} else if (rq_data_dir(rq) == READ) {
		SCpnt->cmnd[0] = READ_6;
	} else {
1003
		scmd_printk(KERN_ERR, SCpnt, "Unknown command %llx\n", (unsigned long long) rq->cmd_flags);
1004
		goto out;
Linus Torvalds's avatar
Linus Torvalds committed
1005 1006
	}

1007
	SCSI_LOG_HLQUEUE(2, scmd_printk(KERN_INFO, SCpnt,
1008
					"%s %d/%u 512 byte blocks.\n",
1009 1010
					(rq_data_dir(rq) == WRITE) ?
					"writing" : "reading", this_count,
1011
					blk_rq_sectors(rq)));
Linus Torvalds's avatar
Linus Torvalds committed
1012

1013
	/* Set RDPROTECT/WRPROTECT if disk is formatted with DIF */
1014 1015
	host_dif = scsi_host_dif_capable(sdp->host, sdkp->protection_type);
	if (host_dif)
1016
		protect = 1 << 5;
1017
	else
1018 1019 1020 1021 1022 1023 1024 1025 1026
		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;
		}
1027

1028 1029 1030 1031 1032
		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;
1033
		SCpnt->cmnd[10] = protect | ((rq->cmd_flags & REQ_FUA) ? 0x8 : 0);
1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055

		/* 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;
1056
	} else if (sdp->use_16_for_rw || (this_count > 0xffff)) {
Linus Torvalds's avatar
Linus Torvalds committed
1057
		SCpnt->cmnd[0] += READ_16 - READ_6;
1058
		SCpnt->cmnd[1] = protect | ((rq->cmd_flags & REQ_FUA) ? 0x8 : 0);
Linus Torvalds's avatar
Linus Torvalds committed
1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072
		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) ||
1073
		   scsi_device_protection(SCpnt->device) ||
Linus Torvalds's avatar
Linus Torvalds committed
1074 1075
		   SCpnt->device->use_10_for_rw) {
		SCpnt->cmnd[0] += READ_10 - READ_6;
1076
		SCpnt->cmnd[1] = protect | ((rq->cmd_flags & REQ_FUA) ? 0x8 : 0);
Linus Torvalds's avatar
Linus Torvalds committed
1077 1078 1079 1080 1081 1082 1083 1084
		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 {
1085
		if (unlikely(rq->cmd_flags & REQ_FUA)) {
1086 1087 1088 1089 1090 1091
			/*
			 * This happens only if this drive failed
			 * 10byte rw command with ILLEGAL_REQUEST
			 * during operation and thus turned off
			 * use_10_for_rw.
			 */
1092 1093
			scmd_printk(KERN_ERR, SCpnt,
				    "FUA write on READ/WRITE(6) drive\n");
1094
			goto out;
1095 1096
		}

Linus Torvalds's avatar
Linus Torvalds committed
1097 1098 1099 1100 1101 1102
		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;
	}
1103
	SCpnt->sdb.length = this_count * sdp->sector_size;
Linus Torvalds's avatar
Linus Torvalds committed
1104

1105
	/* If DIF or DIX is enabled, tell HBA how to handle request */
1106
	if (host_dif || scsi_prot_sg_count(SCpnt))
1107
		sd_prot_op(SCpnt, host_dif);
1108

Linus Torvalds's avatar
Linus Torvalds committed
1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121
	/*
	 * 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.
	 */
1122 1123
	ret = BLKPREP_OK;
 out:
1124
	return ret;
Linus Torvalds's avatar
Linus Torvalds committed
1125 1126
}

1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154
static int sd_init_command(struct scsi_cmnd *cmd)
{
	struct request *rq = cmd->request;

	if (rq->cmd_flags & REQ_DISCARD)
		return sd_setup_discard_cmnd(cmd);
	else if (rq->cmd_flags & REQ_WRITE_SAME)
		return sd_setup_write_same_cmnd(cmd);
	else if (rq->cmd_flags & REQ_FLUSH)
		return sd_setup_flush_cmnd(cmd);
	else
		return sd_setup_read_write_cmnd(cmd);
}

static void sd_uninit_command(struct scsi_cmnd *SCpnt)
{
	struct request *rq = SCpnt->request;

	if (rq->cmd_flags & REQ_DISCARD)
		__free_page(rq->completion_data);

	if (SCpnt->cmnd != rq->cmd) {
		mempool_free(SCpnt->cmnd, sd_cdb_pool);
		SCpnt->cmnd = NULL;
		SCpnt->cmd_len = 0;
	}
}

Linus Torvalds's avatar
Linus Torvalds committed
1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166
/**
 *	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.
1167 1168
 *
 *	Locking: called with bdev->bd_mutex held.
Linus Torvalds's avatar
Linus Torvalds committed
1169
 **/
Al Viro's avatar
Al Viro committed
1170
static int sd_open(struct block_device *bdev, fmode_t mode)
Linus Torvalds's avatar
Linus Torvalds committed
1171
{
Al Viro's avatar
Al Viro committed
1172
	struct scsi_disk *sdkp = scsi_disk_get(bdev->bd_disk);
Linus Torvalds's avatar
Linus Torvalds committed
1173 1174 1175
	struct scsi_device *sdev;
	int retval;

Al Viro's avatar
Al Viro committed
1176
	if (!sdkp)
Linus Torvalds's avatar
Linus Torvalds committed
1177 1178
		return -ENXIO;

1179
	SCSI_LOG_HLQUEUE(3, sd_printk(KERN_INFO, sdkp, "sd_open\n"));
Linus Torvalds's avatar
Linus Torvalds committed
1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191

	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
1192
		check_disk_change(bdev);
Linus Torvalds's avatar
Linus Torvalds committed
1193 1194 1195 1196 1197

	/*
	 * If the drive is empty, just let the open fail.
	 */
	retval = -ENOMEDIUM;
Al Viro's avatar
Al Viro committed
1198
	if (sdev->removable && !sdkp->media_present && !(mode & FMODE_NDELAY))
Linus Torvalds's avatar
Linus Torvalds committed
1199 1200 1201 1202 1203 1204 1205
		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
1206
	if (sdkp->write_prot && (mode & FMODE_WRITE))
Linus Torvalds's avatar
Linus Torvalds committed
1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218
		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;

1219
	if ((atomic_inc_return(&sdkp->openers) == 1) && sdev->removable) {
Linus Torvalds's avatar
Linus Torvalds committed
1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240
		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.
1241 1242
 *
 *	Locking: called with bdev->bd_mutex held.
Linus Torvalds's avatar
Linus Torvalds committed
1243
 **/
1244
static void sd_release(struct gendisk *disk, fmode_t mode)
Linus Torvalds's avatar
Linus Torvalds committed
1245 1246 1247 1248
{
	struct scsi_disk *sdkp = scsi_disk(disk);
	struct scsi_device *sdev = sdkp->device;

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

1251
	if (atomic_dec_return(&sdkp->openers) == 0 && sdev->removable) {
Linus Torvalds's avatar
Linus Torvalds committed
1252 1253 1254 1255 1256 1257 1258 1259
		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"?
	 */
1260

Linus Torvalds's avatar
Linus Torvalds committed
1261 1262 1263
	scsi_disk_put(sdkp);
}

1264
static int sd_getgeo(struct block_device *bdev, struct hd_geometry *geo)
Linus Torvalds's avatar
Linus Torvalds committed
1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281
{
	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);

1282 1283 1284
	geo->heads = diskinfo[0];
	geo->sectors = diskinfo[1];
	geo->cylinders = diskinfo[2];
Linus Torvalds's avatar
Linus Torvalds committed
1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295
	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.
 *
1296
 *	Returns 0 if successful (some ioctls return positive numbers on
Linus Torvalds's avatar
Linus Torvalds committed
1297 1298 1299
 *	success as well). Returns a negated errno value in case of error.
 *
 *	Note: most ioctls are forward onto the block subsystem or further
1300
 *	down in the scsi subsystem.
Linus Torvalds's avatar
Linus Torvalds committed
1301
 **/
Al Viro's avatar
Al Viro committed
1302
static int sd_ioctl(struct block_device *bdev, fmode_t mode,
Linus Torvalds's avatar
Linus Torvalds committed
1303 1304 1305
		    unsigned int cmd, unsigned long arg)
{
	struct gendisk *disk = bdev->bd_disk;
1306 1307
	struct scsi_disk *sdkp = scsi_disk(disk);
	struct scsi_device *sdp = sdkp->device;
Linus Torvalds's avatar
Linus Torvalds committed
1308 1309 1310
	void __user *p = (void __user *)arg;
	int error;
    
1311 1312
	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
1313

1314 1315 1316 1317
	error = scsi_verify_blk_ioctl(bdev, cmd);
	if (error < 0)
		return error;

Linus Torvalds's avatar
Linus Torvalds committed
1318 1319 1320 1321 1322 1323
	/*
	 * 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.
	 */
1324
	error = scsi_nonblockable_ioctl(sdp, cmd, p,
1325
					(mode & FMODE_NDELAY) != 0);
Linus Torvalds's avatar
Linus Torvalds committed
1326
	if (!scsi_block_when_processing_errors(sdp) || !error)
1327
		goto out;
Linus Torvalds's avatar
Linus Torvalds committed
1328 1329 1330 1331 1332 1333 1334 1335 1336

	/*
	 * 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:
1337 1338
			error = scsi_ioctl(sdp, cmd, p);
			break;
Linus Torvalds's avatar
Linus Torvalds committed
1339
		default:
1340
			error = scsi_cmd_blk_ioctl(bdev, mode, cmd, p);
Linus Torvalds's avatar
Linus Torvalds committed
1341
			if (error != -ENOTTY)
1342 1343 1344
				break;
			error = scsi_ioctl(sdp, cmd, p);
			break;
Linus Torvalds's avatar
Linus Torvalds committed
1345
	}
1346 1347
out:
	return error;
Linus Torvalds's avatar
Linus Torvalds committed
1348 1349 1350 1351
}

static void set_media_not_present(struct scsi_disk *sdkp)
{
1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377
	if (sdkp->media_present)
		sdkp->device->changed = 1;

	if (sdkp->device->removable) {
		sdkp->media_present = 0;
		sdkp->capacity = 0;
	}
}

static int media_not_present(struct scsi_disk *sdkp,
			     struct scsi_sense_hdr *sshdr)
{
	if (!scsi_sense_valid(sshdr))
		return 0;

	/* not invoked for commands that could return deferred errors */
	switch (sshdr->sense_key) {
	case UNIT_ATTENTION:
	case NOT_READY:
		/* medium not present */
		if (sshdr->asc == 0x3A) {
			set_media_not_present(sdkp);
			return 1;
		}
	}
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
1378 1379 1380
}

/**
1381 1382 1383
 *	sd_check_events - check media events
 *	@disk: kernel device descriptor
 *	@clearing: disk events currently being cleared
Linus Torvalds's avatar
Linus Torvalds committed
1384
 *
1385
 *	Returns mask of DISK_EVENT_*.
Linus Torvalds's avatar
Linus Torvalds committed
1386 1387 1388
 *
 *	Note: this function is invoked from the block subsystem.
 **/
1389
static unsigned int sd_check_events(struct gendisk *disk, unsigned int clearing)
Linus Torvalds's avatar
Linus Torvalds committed
1390 1391 1392
{
	struct scsi_disk *sdkp = scsi_disk(disk);
	struct scsi_device *sdp = sdkp->device;
1393
	struct scsi_sense_hdr *sshdr = NULL;
Linus Torvalds's avatar
Linus Torvalds committed
1394 1395
	int retval;

1396
	SCSI_LOG_HLQUEUE(3, sd_printk(KERN_INFO, sdkp, "sd_check_events\n"));
Linus Torvalds's avatar
Linus Torvalds committed
1397 1398 1399 1400 1401 1402 1403

	/*
	 * If the device is offline, don't send any commands - just pretend as
	 * if the command failed.  If the device ever comes back online, we
	 * can deal with it then.  It is only because of unrecoverable errors
	 * that we would ever take a device offline in the first place.
	 */
1404 1405 1406 1407
	if (!scsi_device_online(sdp)) {
		set_media_not_present(sdkp);
		goto out;
	}
Linus Torvalds's avatar
Linus Torvalds committed
1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418

	/*
	 * Using TEST_UNIT_READY enables differentiation between drive with
	 * no cartridge loaded - NOT READY, drive with changed cartridge -
	 * UNIT ATTENTION, or with same cartridge - GOOD STATUS.
	 *
	 * Drives that auto spin down. eg iomega jaz 1G, will be started
	 * by sd_spinup_disk() from sd_revalidate_disk(), which happens whenever
	 * sd_revalidate() is called.
	 */
	retval = -ENODEV;
1419

1420 1421 1422 1423 1424
	if (scsi_block_when_processing_errors(sdp)) {
		sshdr  = kzalloc(sizeof(*sshdr), GFP_KERNEL);
		retval = scsi_test_unit_ready(sdp, SD_TIMEOUT, SD_MAX_RETRIES,
					      sshdr);
	}
Linus Torvalds's avatar
Linus Torvalds committed
1425

1426 1427
	/* failed to execute TUR, assume media not present */
	if (host_byte(retval)) {
1428 1429 1430
		set_media_not_present(sdkp);
		goto out;
	}
Linus Torvalds's avatar
Linus Torvalds committed
1431

1432 1433 1434
	if (media_not_present(sdkp, sshdr))
		goto out;

Linus Torvalds's avatar
Linus Torvalds committed
1435 1436
	/*
	 * For removable scsi disk we have to recognise the presence
1437
	 * of a disk in the drive.
Linus Torvalds's avatar
Linus Torvalds committed
1438
	 */
1439 1440
	if (!sdkp->media_present)
		sdp->changed = 1;
Linus Torvalds's avatar
Linus Torvalds committed
1441
	sdkp->media_present = 1;
1442
out:
1443
	/*
1444
	 * sdp->changed is set under the following conditions:
1445
	 *
1446 1447
	 *	Medium present state has changed in either direction.
	 *	Device has indicated UNIT_ATTENTION.
1448
	 */
1449
	kfree(sshdr);
Tejun Heo's avatar