sd.c

   1// SPDX-License-Identifier: GPL-2.0-only
   2/*
   3 *      sd.c Copyright (C) 1992 Drew Eckhardt
   4 *           Copyright (C) 1993, 1994, 1995, 1999 Eric Youngdale
   5 *
   6 *      Linux scsi disk driver
   7 *              Initial versions: Drew Eckhardt
   8 *              Subsequent revisions: Eric Youngdale
   9 *	Modification history:
  10 *       - Drew Eckhardt <drew@colorado.edu> original
  11 *       - Eric Youngdale <eric@andante.org> add scatter-gather, multiple 
  12 *         outstanding request, and other enhancements.
  13 *         Support loadable low-level scsi drivers.
  14 *       - Jirka Hanika <geo@ff.cuni.cz> support more scsi disks using 
  15 *         eight major numbers.
  16 *       - Richard Gooch <rgooch@atnf.csiro.au> support devfs.
  17 *	 - Torben Mathiasen <tmm@image.dk> Resource allocation fixes in 
  18 *	   sd_init and cleanups.
  19 *	 - Alex Davis <letmein@erols.com> Fix problem where partition info
  20 *	   not being read in sd_open. Fix problem where removable media 
  21 *	   could be ejected after sd_open.
  22 *	 - Douglas Gilbert <dgilbert@interlog.com> cleanup for lk 2.5.x
  23 *	 - Badari Pulavarty <pbadari@us.ibm.com>, Matthew Wilcox 
  24 *	   <willy@debian.org>, Kurt Garloff <garloff@suse.de>: 
  25 *	   Support 32k/1M disks.
  26 *
  27 *	Logging policy (needs CONFIG_SCSI_LOGGING defined):
  28 *	 - setting up transfer: SCSI_LOG_HLQUEUE levels 1 and 2
  29 *	 - end of transfer (bh + scsi_lib): SCSI_LOG_HLCOMPLETE level 1
  30 *	 - entering sd_ioctl: SCSI_LOG_IOCTL level 1
  31 *	 - entering other commands: SCSI_LOG_HLQUEUE level 3
  32 *	Note: when the logging level is set by the user, it must be greater
  33 *	than the level indicated above to trigger output.	
  34 */
  35
  36#include <linux/bio-integrity.h>
  37#include <linux/module.h>
  38#include <linux/fs.h>
  39#include <linux/kernel.h>
  40#include <linux/mm.h>
  41#include <linux/hdreg.h>
  42#include <linux/errno.h>
  43#include <linux/idr.h>
  44#include <linux/interrupt.h>
  45#include <linux/init.h>
  46#include <linux/blkdev.h>
  47#include <linux/blkpg.h>
  48#include <linux/blk-pm.h>
  49#include <linux/delay.h>
  50#include <linux/rw_hint.h>
  51#include <linux/major.h>
  52#include <linux/mutex.h>
  53#include <linux/string_helpers.h>
  54#include <linux/slab.h>
  55#include <linux/sed-opal.h>
  56#include <linux/pm_runtime.h>
  57#include <linux/pr.h>
  58#include <linux/t10-pi.h>
  59#include <linux/uaccess.h>
  60#include <linux/unaligned.h>
  61
  62#include <scsi/scsi.h>
  63#include <scsi/scsi_cmnd.h>
  64#include <scsi/scsi_dbg.h>
  65#include <scsi/scsi_device.h>
  66#include <scsi/scsi_devinfo.h>
  67#include <scsi/scsi_driver.h>
  68#include <scsi/scsi_eh.h>
  69#include <scsi/scsi_host.h>
  70#include <scsi/scsi_ioctl.h>
  71#include <scsi/scsicam.h>
  72#include <scsi/scsi_common.h>
  73
  74#include "sd.h"
  75#include "scsi_priv.h"
  76#include "scsi_logging.h"
  77
  78MODULE_AUTHOR("Eric Youngdale");
  79MODULE_DESCRIPTION("SCSI disk (sd) driver");
  80MODULE_LICENSE("GPL");
  81
  82MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK0_MAJOR);
  83MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK1_MAJOR);
  84MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK2_MAJOR);
  85MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK3_MAJOR);
  86MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK4_MAJOR);
  87MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK5_MAJOR);
  88MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK6_MAJOR);
  89MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK7_MAJOR);
  90MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK8_MAJOR);
  91MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK9_MAJOR);
  92MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK10_MAJOR);
  93MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK11_MAJOR);
  94MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK12_MAJOR);
  95MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK13_MAJOR);
  96MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK14_MAJOR);
  97MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK15_MAJOR);
  98MODULE_ALIAS_SCSI_DEVICE(TYPE_DISK);
  99MODULE_ALIAS_SCSI_DEVICE(TYPE_MOD);
 100MODULE_ALIAS_SCSI_DEVICE(TYPE_RBC);
 101MODULE_ALIAS_SCSI_DEVICE(TYPE_ZBC);
 102
 103#define SD_MINORS	16
 104
 105static void sd_config_discard(struct scsi_disk *sdkp, struct queue_limits *lim,
 106		unsigned int mode);
 107static void sd_config_write_same(struct scsi_disk *sdkp,
 108		struct queue_limits *lim);
 109static void  sd_revalidate_disk(struct gendisk *);
 110static void sd_unlock_native_capacity(struct gendisk *disk);
 111static void sd_shutdown(struct device *);
 112static void scsi_disk_release(struct device *cdev);
 113
 114static DEFINE_IDA(sd_index_ida);
 115
 116static mempool_t *sd_page_pool;
 117static struct lock_class_key sd_bio_compl_lkclass;
 118
 119static const char *sd_cache_types[] = {
 120	"write through", "none", "write back",
 121	"write back, no read (daft)"
 122};
 123
 124static void sd_set_flush_flag(struct scsi_disk *sdkp,
 125		struct queue_limits *lim)
 126{
 127	if (sdkp->WCE) {
 128		lim->features |= BLK_FEAT_WRITE_CACHE;
 129		if (sdkp->DPOFUA)
 130			lim->features |= BLK_FEAT_FUA;
 131		else
 132			lim->features &= ~BLK_FEAT_FUA;
 133	} else {
 134		lim->features &= ~(BLK_FEAT_WRITE_CACHE | BLK_FEAT_FUA);
 135	}
 136}
 137
 138static ssize_t
 139cache_type_store(struct device *dev, struct device_attribute *attr,
 140		 const char *buf, size_t count)
 141{
 142	int ct, rcd, wce, sp;
 143	struct scsi_disk *sdkp = to_scsi_disk(dev);
 144	struct scsi_device *sdp = sdkp->device;
 145	char buffer[64];
 146	char *buffer_data;
 147	struct scsi_mode_data data;
 148	struct scsi_sense_hdr sshdr;
 149	static const char temp[] = "temporary ";
 150	int len, ret;
 151
 152	if (sdp->type != TYPE_DISK && sdp->type != TYPE_ZBC)
 153		/* no cache control on RBC devices; theoretically they
 154		 * can do it, but there's probably so many exceptions
 155		 * it's not worth the risk */
 156		return -EINVAL;
 157
 158	if (strncmp(buf, temp, sizeof(temp) - 1) == 0) {
 159		buf += sizeof(temp) - 1;
 160		sdkp->cache_override = 1;
 161	} else {
 162		sdkp->cache_override = 0;
 163	}
 164
 165	ct = sysfs_match_string(sd_cache_types, buf);
 166	if (ct < 0)
 167		return -EINVAL;
 168
 169	rcd = ct & 0x01 ? 1 : 0;
 170	wce = (ct & 0x02) && !sdkp->write_prot ? 1 : 0;
 171
 172	if (sdkp->cache_override) {
 173		struct queue_limits lim;
 174
 175		sdkp->WCE = wce;
 176		sdkp->RCD = rcd;
 177
 178		lim = queue_limits_start_update(sdkp->disk->queue);
 179		sd_set_flush_flag(sdkp, &lim);
 180		ret = queue_limits_commit_update_frozen(sdkp->disk->queue,
 181				&lim);
 182		if (ret)
 183			return ret;
 184		return count;
 185	}
 186
 187	if (scsi_mode_sense(sdp, 0x08, 8, 0, buffer, sizeof(buffer), SD_TIMEOUT,
 188			    sdkp->max_retries, &data, NULL))
 189		return -EINVAL;
 190	len = min_t(size_t, sizeof(buffer), data.length - data.header_length -
 191		  data.block_descriptor_length);
 192	buffer_data = buffer + data.header_length +
 193		data.block_descriptor_length;
 194	buffer_data[2] &= ~0x05;
 195	buffer_data[2] |= wce << 2 | rcd;
 196	sp = buffer_data[0] & 0x80 ? 1 : 0;
 197	buffer_data[0] &= ~0x80;
 198
 199	/*
 200	 * Ensure WP, DPOFUA, and RESERVED fields are cleared in
 201	 * received mode parameter buffer before doing MODE SELECT.
 202	 */
 203	data.device_specific = 0;
 204
 205	ret = scsi_mode_select(sdp, 1, sp, buffer_data, len, SD_TIMEOUT,
 206			       sdkp->max_retries, &data, &sshdr);
 207	if (ret) {
 208		if (ret > 0 && scsi_sense_valid(&sshdr))
 209			sd_print_sense_hdr(sdkp, &sshdr);
 210		return -EINVAL;
 211	}
 212	sd_revalidate_disk(sdkp->disk);
 213	return count;
 214}
 215
 216static ssize_t
 217manage_start_stop_show(struct device *dev,
 218		       struct device_attribute *attr, char *buf)
 219{
 220	struct scsi_disk *sdkp = to_scsi_disk(dev);
 221	struct scsi_device *sdp = sdkp->device;
 222
 223	return sysfs_emit(buf, "%u\n",
 224			  sdp->manage_system_start_stop &&
 225			  sdp->manage_runtime_start_stop &&
 226			  sdp->manage_shutdown);
 227}
 228static DEVICE_ATTR_RO(manage_start_stop);
 229
 230static ssize_t
 231manage_system_start_stop_show(struct device *dev,
 232			      struct device_attribute *attr, char *buf)
 233{
 234	struct scsi_disk *sdkp = to_scsi_disk(dev);
 235	struct scsi_device *sdp = sdkp->device;
 236
 237	return sysfs_emit(buf, "%u\n", sdp->manage_system_start_stop);
 238}
 239
 240static ssize_t
 241manage_system_start_stop_store(struct device *dev,
 242			       struct device_attribute *attr,
 243			       const char *buf, size_t count)
 244{
 245	struct scsi_disk *sdkp = to_scsi_disk(dev);
 246	struct scsi_device *sdp = sdkp->device;
 247	bool v;
 248
 249	if (!capable(CAP_SYS_ADMIN))
 250		return -EACCES;
 251
 252	if (kstrtobool(buf, &v))
 253		return -EINVAL;
 254
 255	sdp->manage_system_start_stop = v;
 256
 257	return count;
 258}
 259static DEVICE_ATTR_RW(manage_system_start_stop);
 260
 261static ssize_t
 262manage_runtime_start_stop_show(struct device *dev,
 263			       struct device_attribute *attr, char *buf)
 264{
 265	struct scsi_disk *sdkp = to_scsi_disk(dev);
 266	struct scsi_device *sdp = sdkp->device;
 267
 268	return sysfs_emit(buf, "%u\n", sdp->manage_runtime_start_stop);
 269}
 270
 271static ssize_t
 272manage_runtime_start_stop_store(struct device *dev,
 273				struct device_attribute *attr,
 274				const char *buf, size_t count)
 275{
 276	struct scsi_disk *sdkp = to_scsi_disk(dev);
 277	struct scsi_device *sdp = sdkp->device;
 278	bool v;
 279
 280	if (!capable(CAP_SYS_ADMIN))
 281		return -EACCES;
 282
 283	if (kstrtobool(buf, &v))
 284		return -EINVAL;
 285
 286	sdp->manage_runtime_start_stop = v;
 287
 288	return count;
 289}
 290static DEVICE_ATTR_RW(manage_runtime_start_stop);
 291
 292static ssize_t manage_shutdown_show(struct device *dev,
 293				    struct device_attribute *attr, char *buf)
 294{
 295	struct scsi_disk *sdkp = to_scsi_disk(dev);
 296	struct scsi_device *sdp = sdkp->device;
 297
 298	return sysfs_emit(buf, "%u\n", sdp->manage_shutdown);
 299}
 300
 301static ssize_t manage_shutdown_store(struct device *dev,
 302				     struct device_attribute *attr,
 303				     const char *buf, size_t count)
 304{
 305	struct scsi_disk *sdkp = to_scsi_disk(dev);
 306	struct scsi_device *sdp = sdkp->device;
 307	bool v;
 308
 309	if (!capable(CAP_SYS_ADMIN))
 310		return -EACCES;
 311
 312	if (kstrtobool(buf, &v))
 313		return -EINVAL;
 314
 315	sdp->manage_shutdown = v;
 316
 317	return count;
 318}
 319static DEVICE_ATTR_RW(manage_shutdown);
 320
 321static ssize_t manage_restart_show(struct device *dev,
 322				   struct device_attribute *attr, char *buf)
 323{
 324	struct scsi_disk *sdkp = to_scsi_disk(dev);
 325	struct scsi_device *sdp = sdkp->device;
 326
 327	return sysfs_emit(buf, "%u\n", sdp->manage_restart);
 328}
 329
 330static ssize_t manage_restart_store(struct device *dev,
 331				    struct device_attribute *attr,
 332				    const char *buf, size_t count)
 333{
 334	struct scsi_disk *sdkp = to_scsi_disk(dev);
 335	struct scsi_device *sdp = sdkp->device;
 336	bool v;
 337
 338	if (!capable(CAP_SYS_ADMIN))
 339		return -EACCES;
 340
 341	if (kstrtobool(buf, &v))
 342		return -EINVAL;
 343
 344	sdp->manage_restart = v;
 345
 346	return count;
 347}
 348static DEVICE_ATTR_RW(manage_restart);
 349
 350static ssize_t
 351allow_restart_show(struct device *dev, struct device_attribute *attr, char *buf)
 352{
 353	struct scsi_disk *sdkp = to_scsi_disk(dev);
 354
 355	return sprintf(buf, "%u\n", sdkp->device->allow_restart);
 356}
 357
 358static ssize_t
 359allow_restart_store(struct device *dev, struct device_attribute *attr,
 360		    const char *buf, size_t count)
 361{
 362	bool v;
 363	struct scsi_disk *sdkp = to_scsi_disk(dev);
 364	struct scsi_device *sdp = sdkp->device;
 365
 366	if (!capable(CAP_SYS_ADMIN))
 367		return -EACCES;
 368
 369	if (sdp->type != TYPE_DISK && sdp->type != TYPE_ZBC)
 370		return -EINVAL;
 371
 372	if (kstrtobool(buf, &v))
 373		return -EINVAL;
 374
 375	sdp->allow_restart = v;
 376
 377	return count;
 378}
 379static DEVICE_ATTR_RW(allow_restart);
 380
 381static ssize_t
 382cache_type_show(struct device *dev, struct device_attribute *attr, char *buf)
 383{
 384	struct scsi_disk *sdkp = to_scsi_disk(dev);
 385	int ct = sdkp->RCD + 2*sdkp->WCE;
 386
 387	return sprintf(buf, "%s\n", sd_cache_types[ct]);
 388}
 389static DEVICE_ATTR_RW(cache_type);
 390
 391static ssize_t
 392FUA_show(struct device *dev, struct device_attribute *attr, char *buf)
 393{
 394	struct scsi_disk *sdkp = to_scsi_disk(dev);
 395
 396	return sprintf(buf, "%u\n", sdkp->DPOFUA);
 397}
 398static DEVICE_ATTR_RO(FUA);
 399
 400static ssize_t
 401protection_type_show(struct device *dev, struct device_attribute *attr,
 402		     char *buf)
 403{
 404	struct scsi_disk *sdkp = to_scsi_disk(dev);
 405
 406	return sprintf(buf, "%u\n", sdkp->protection_type);
 407}
 408
 409static ssize_t
 410protection_type_store(struct device *dev, struct device_attribute *attr,
 411		      const char *buf, size_t count)
 412{
 413	struct scsi_disk *sdkp = to_scsi_disk(dev);
 414	unsigned int val;
 415	int err;
 416
 417	if (!capable(CAP_SYS_ADMIN))
 418		return -EACCES;
 419
 420	err = kstrtouint(buf, 10, &val);
 421
 422	if (err)
 423		return err;
 424
 425	if (val <= T10_PI_TYPE3_PROTECTION)
 426		sdkp->protection_type = val;
 427
 428	return count;
 429}
 430static DEVICE_ATTR_RW(protection_type);
 431
 432static ssize_t
 433protection_mode_show(struct device *dev, struct device_attribute *attr,
 434		     char *buf)
 435{
 436	struct scsi_disk *sdkp = to_scsi_disk(dev);
 437	struct scsi_device *sdp = sdkp->device;
 438	unsigned int dif, dix;
 439
 440	dif = scsi_host_dif_capable(sdp->host, sdkp->protection_type);
 441	dix = scsi_host_dix_capable(sdp->host, sdkp->protection_type);
 442
 443	if (!dix && scsi_host_dix_capable(sdp->host, T10_PI_TYPE0_PROTECTION)) {
 444		dif = 0;
 445		dix = 1;
 446	}
 447
 448	if (!dif && !dix)
 449		return sprintf(buf, "none\n");
 450
 451	return sprintf(buf, "%s%u\n", dix ? "dix" : "dif", dif);
 452}
 453static DEVICE_ATTR_RO(protection_mode);
 454
 455static ssize_t
 456app_tag_own_show(struct device *dev, struct device_attribute *attr, char *buf)
 457{
 458	struct scsi_disk *sdkp = to_scsi_disk(dev);
 459
 460	return sprintf(buf, "%u\n", sdkp->ATO);
 461}
 462static DEVICE_ATTR_RO(app_tag_own);
 463
 464static ssize_t
 465thin_provisioning_show(struct device *dev, struct device_attribute *attr,
 466		       char *buf)
 467{
 468	struct scsi_disk *sdkp = to_scsi_disk(dev);
 469
 470	return sprintf(buf, "%u\n", sdkp->lbpme);
 471}
 472static DEVICE_ATTR_RO(thin_provisioning);
 473
 474/* sysfs_match_string() requires dense arrays */
 475static const char *lbp_mode[] = {
 476	[SD_LBP_FULL]		= "full",
 477	[SD_LBP_UNMAP]		= "unmap",
 478	[SD_LBP_WS16]		= "writesame_16",
 479	[SD_LBP_WS10]		= "writesame_10",
 480	[SD_LBP_ZERO]		= "writesame_zero",
 481	[SD_LBP_DISABLE]	= "disabled",
 482};
 483
 484static ssize_t
 485provisioning_mode_show(struct device *dev, struct device_attribute *attr,
 486		       char *buf)
 487{
 488	struct scsi_disk *sdkp = to_scsi_disk(dev);
 489
 490	return sprintf(buf, "%s\n", lbp_mode[sdkp->provisioning_mode]);
 491}
 492
 493static ssize_t
 494provisioning_mode_store(struct device *dev, struct device_attribute *attr,
 495			const char *buf, size_t count)
 496{
 497	struct scsi_disk *sdkp = to_scsi_disk(dev);
 498	struct scsi_device *sdp = sdkp->device;
 499	struct queue_limits lim;
 500	int mode, err;
 501
 502	if (!capable(CAP_SYS_ADMIN))
 503		return -EACCES;
 504
 505	if (sdp->type != TYPE_DISK)
 506		return -EINVAL;
 507
 508	mode = sysfs_match_string(lbp_mode, buf);
 509	if (mode < 0)
 510		return -EINVAL;
 511
 512	lim = queue_limits_start_update(sdkp->disk->queue);
 513	sd_config_discard(sdkp, &lim, mode);
 514	err = queue_limits_commit_update_frozen(sdkp->disk->queue, &lim);
 515	if (err)
 516		return err;
 517	return count;
 518}
 519static DEVICE_ATTR_RW(provisioning_mode);
 520
 521/* sysfs_match_string() requires dense arrays */
 522static const char *zeroing_mode[] = {
 523	[SD_ZERO_WRITE]		= "write",
 524	[SD_ZERO_WS]		= "writesame",
 525	[SD_ZERO_WS16_UNMAP]	= "writesame_16_unmap",
 526	[SD_ZERO_WS10_UNMAP]	= "writesame_10_unmap",
 527};
 528
 529static ssize_t
 530zeroing_mode_show(struct device *dev, struct device_attribute *attr,
 531		  char *buf)
 532{
 533	struct scsi_disk *sdkp = to_scsi_disk(dev);
 534
 535	return sprintf(buf, "%s\n", zeroing_mode[sdkp->zeroing_mode]);
 536}
 537
 538static ssize_t
 539zeroing_mode_store(struct device *dev, struct device_attribute *attr,
 540		   const char *buf, size_t count)
 541{
 542	struct scsi_disk *sdkp = to_scsi_disk(dev);
 543	int mode;
 544
 545	if (!capable(CAP_SYS_ADMIN))
 546		return -EACCES;
 547
 548	mode = sysfs_match_string(zeroing_mode, buf);
 549	if (mode < 0)
 550		return -EINVAL;
 551
 552	sdkp->zeroing_mode = mode;
 553
 554	return count;
 555}
 556static DEVICE_ATTR_RW(zeroing_mode);
 557
 558static ssize_t
 559max_medium_access_timeouts_show(struct device *dev,
 560				struct device_attribute *attr, char *buf)
 561{
 562	struct scsi_disk *sdkp = to_scsi_disk(dev);
 563
 564	return sprintf(buf, "%u\n", sdkp->max_medium_access_timeouts);
 565}
 566
 567static ssize_t
 568max_medium_access_timeouts_store(struct device *dev,
 569				 struct device_attribute *attr, const char *buf,
 570				 size_t count)
 571{
 572	struct scsi_disk *sdkp = to_scsi_disk(dev);
 573	int err;
 574
 575	if (!capable(CAP_SYS_ADMIN))
 576		return -EACCES;
 577
 578	err = kstrtouint(buf, 10, &sdkp->max_medium_access_timeouts);
 579
 580	return err ? err : count;
 581}
 582static DEVICE_ATTR_RW(max_medium_access_timeouts);
 583
 584static ssize_t
 585max_write_same_blocks_show(struct device *dev, struct device_attribute *attr,
 586			   char *buf)
 587{
 588	struct scsi_disk *sdkp = to_scsi_disk(dev);
 589
 590	return sprintf(buf, "%u\n", sdkp->max_ws_blocks);
 591}
 592
 593static ssize_t
 594max_write_same_blocks_store(struct device *dev, struct device_attribute *attr,
 595			    const char *buf, size_t count)
 596{
 597	struct scsi_disk *sdkp = to_scsi_disk(dev);
 598	struct scsi_device *sdp = sdkp->device;
 599	struct queue_limits lim;
 600	unsigned long max;
 601	int err;
 602
 603	if (!capable(CAP_SYS_ADMIN))
 604		return -EACCES;
 605
 606	if (sdp->type != TYPE_DISK && sdp->type != TYPE_ZBC)
 607		return -EINVAL;
 608
 609	err = kstrtoul(buf, 10, &max);
 610
 611	if (err)
 612		return err;
 613
 614	if (max == 0)
 615		sdp->no_write_same = 1;
 616	else if (max <= SD_MAX_WS16_BLOCKS) {
 617		sdp->no_write_same = 0;
 618		sdkp->max_ws_blocks = max;
 619	}
 620
 621	lim = queue_limits_start_update(sdkp->disk->queue);
 622	sd_config_write_same(sdkp, &lim);
 623	err = queue_limits_commit_update_frozen(sdkp->disk->queue, &lim);
 624	if (err)
 625		return err;
 626	return count;
 627}
 628static DEVICE_ATTR_RW(max_write_same_blocks);
 629
 630static ssize_t
 631zoned_cap_show(struct device *dev, struct device_attribute *attr, char *buf)
 632{
 633	struct scsi_disk *sdkp = to_scsi_disk(dev);
 634
 635	if (sdkp->device->type == TYPE_ZBC)
 636		return sprintf(buf, "host-managed\n");
 637	if (sdkp->zoned == 1)
 638		return sprintf(buf, "host-aware\n");
 639	if (sdkp->zoned == 2)
 640		return sprintf(buf, "drive-managed\n");
 641	return sprintf(buf, "none\n");
 642}
 643static DEVICE_ATTR_RO(zoned_cap);
 644
 645static ssize_t
 646max_retries_store(struct device *dev, struct device_attribute *attr,
 647		  const char *buf, size_t count)
 648{
 649	struct scsi_disk *sdkp = to_scsi_disk(dev);
 650	struct scsi_device *sdev = sdkp->device;
 651	int retries, err;
 652
 653	err = kstrtoint(buf, 10, &retries);
 654	if (err)
 655		return err;
 656
 657	if (retries == SCSI_CMD_RETRIES_NO_LIMIT || retries <= SD_MAX_RETRIES) {
 658		sdkp->max_retries = retries;
 659		return count;
 660	}
 661
 662	sdev_printk(KERN_ERR, sdev, "max_retries must be between -1 and %d\n",
 663		    SD_MAX_RETRIES);
 664	return -EINVAL;
 665}
 666
 667static ssize_t
 668max_retries_show(struct device *dev, struct device_attribute *attr,
 669		 char *buf)
 670{
 671	struct scsi_disk *sdkp = to_scsi_disk(dev);
 672
 673	return sprintf(buf, "%d\n", sdkp->max_retries);
 674}
 675
 676static DEVICE_ATTR_RW(max_retries);
 677
 678static struct attribute *sd_disk_attrs[] = {
 679	&dev_attr_cache_type.attr,
 680	&dev_attr_FUA.attr,
 681	&dev_attr_allow_restart.attr,
 682	&dev_attr_manage_start_stop.attr,
 683	&dev_attr_manage_system_start_stop.attr,
 684	&dev_attr_manage_runtime_start_stop.attr,
 685	&dev_attr_manage_shutdown.attr,
 686	&dev_attr_manage_restart.attr,
 687	&dev_attr_protection_type.attr,
 688	&dev_attr_protection_mode.attr,
 689	&dev_attr_app_tag_own.attr,
 690	&dev_attr_thin_provisioning.attr,
 691	&dev_attr_provisioning_mode.attr,
 692	&dev_attr_zeroing_mode.attr,
 693	&dev_attr_max_write_same_blocks.attr,
 694	&dev_attr_max_medium_access_timeouts.attr,
 695	&dev_attr_zoned_cap.attr,
 696	&dev_attr_max_retries.attr,
 697	NULL,
 698};
 699ATTRIBUTE_GROUPS(sd_disk);
 700
 701static struct class sd_disk_class = {
 702	.name		= "scsi_disk",
 703	.dev_release	= scsi_disk_release,
 704	.dev_groups	= sd_disk_groups,
 705};
 706
 707/*
 708 * Don't request a new module, as that could deadlock in multipath
 709 * environment.
 710 */
 711static void sd_default_probe(dev_t devt)
 712{
 713}
 714
 715/*
 716 * Device no to disk mapping:
 717 * 
 718 *       major         disc2     disc  p1
 719 *   |............|.............|....|....| <- dev_t
 720 *    31        20 19          8 7  4 3  0
 721 * 
 722 * Inside a major, we have 16k disks, however mapped non-
 723 * contiguously. The first 16 disks are for major0, the next
 724 * ones with major1, ... Disk 256 is for major0 again, disk 272 
 725 * for major1, ... 
 726 * As we stay compatible with our numbering scheme, we can reuse 
 727 * the well-know SCSI majors 8, 65--71, 136--143.
 728 */
 729static int sd_major(int major_idx)
 730{
 731	switch (major_idx) {
 732	case 0:
 733		return SCSI_DISK0_MAJOR;
 734	case 1 ... 7:
 735		return SCSI_DISK1_MAJOR + major_idx - 1;
 736	case 8 ... 15:
 737		return SCSI_DISK8_MAJOR + major_idx - 8;
 738	default:
 739		BUG();
 740		return 0;	/* shut up gcc */
 741	}
 742}
 743
 744#ifdef CONFIG_BLK_SED_OPAL
 745static int sd_sec_submit(void *data, u16 spsp, u8 secp, void *buffer,
 746		size_t len, bool send)
 747{
 748	struct scsi_disk *sdkp = data;
 749	struct scsi_device *sdev = sdkp->device;
 750	u8 cdb[12] = { 0, };
 751	const struct scsi_exec_args exec_args = {
 752		.req_flags = BLK_MQ_REQ_PM,
 753	};
 754	int ret;
 755
 756	cdb[0] = send ? SECURITY_PROTOCOL_OUT : SECURITY_PROTOCOL_IN;
 757	cdb[1] = secp;
 758	put_unaligned_be16(spsp, &cdb[2]);
 759	put_unaligned_be32(len, &cdb[6]);
 760
 761	ret = scsi_execute_cmd(sdev, cdb, send ? REQ_OP_DRV_OUT : REQ_OP_DRV_IN,
 762			       buffer, len, SD_TIMEOUT, sdkp->max_retries,
 763			       &exec_args);
 764	return ret <= 0 ? ret : -EIO;
 765}
 766#endif /* CONFIG_BLK_SED_OPAL */
 767
 768/*
 769 * Look up the DIX operation based on whether the command is read or
 770 * write and whether dix and dif are enabled.
 771 */
 772static unsigned int sd_prot_op(bool write, bool dix, bool dif)
 773{
 774	/* Lookup table: bit 2 (write), bit 1 (dix), bit 0 (dif) */
 775	static const unsigned int ops[] = {	/* wrt dix dif */
 776		SCSI_PROT_NORMAL,		/*  0	0   0  */
 777		SCSI_PROT_READ_STRIP,		/*  0	0   1  */
 778		SCSI_PROT_READ_INSERT,		/*  0	1   0  */
 779		SCSI_PROT_READ_PASS,		/*  0	1   1  */
 780		SCSI_PROT_NORMAL,		/*  1	0   0  */
 781		SCSI_PROT_WRITE_INSERT,		/*  1	0   1  */
 782		SCSI_PROT_WRITE_STRIP,		/*  1	1   0  */
 783		SCSI_PROT_WRITE_PASS,		/*  1	1   1  */
 784	};
 785
 786	return ops[write << 2 | dix << 1 | dif];
 787}
 788
 789/*
 790 * Returns a mask of the protection flags that are valid for a given DIX
 791 * operation.
 792 */
 793static unsigned int sd_prot_flag_mask(unsigned int prot_op)
 794{
 795	static const unsigned int flag_mask[] = {
 796		[SCSI_PROT_NORMAL]		= 0,
 797
 798		[SCSI_PROT_READ_STRIP]		= SCSI_PROT_TRANSFER_PI |
 799						  SCSI_PROT_GUARD_CHECK |
 800						  SCSI_PROT_REF_CHECK |
 801						  SCSI_PROT_REF_INCREMENT,
 802
 803		[SCSI_PROT_READ_INSERT]		= SCSI_PROT_REF_INCREMENT |
 804						  SCSI_PROT_IP_CHECKSUM,
 805
 806		[SCSI_PROT_READ_PASS]		= SCSI_PROT_TRANSFER_PI |
 807						  SCSI_PROT_GUARD_CHECK |
 808						  SCSI_PROT_REF_CHECK |
 809						  SCSI_PROT_REF_INCREMENT |
 810						  SCSI_PROT_IP_CHECKSUM,
 811
 812		[SCSI_PROT_WRITE_INSERT]	= SCSI_PROT_TRANSFER_PI |
 813						  SCSI_PROT_REF_INCREMENT,
 814
 815		[SCSI_PROT_WRITE_STRIP]		= SCSI_PROT_GUARD_CHECK |
 816						  SCSI_PROT_REF_CHECK |
 817						  SCSI_PROT_REF_INCREMENT |
 818						  SCSI_PROT_IP_CHECKSUM,
 819
 820		[SCSI_PROT_WRITE_PASS]		= SCSI_PROT_TRANSFER_PI |
 821						  SCSI_PROT_GUARD_CHECK |
 822						  SCSI_PROT_REF_CHECK |
 823						  SCSI_PROT_REF_INCREMENT |
 824						  SCSI_PROT_IP_CHECKSUM,
 825	};
 826
 827	return flag_mask[prot_op];
 828}
 829
 830static unsigned char sd_setup_protect_cmnd(struct scsi_cmnd *scmd,
 831					   unsigned int dix, unsigned int dif)
 832{
 833	struct request *rq = scsi_cmd_to_rq(scmd);
 834	struct bio *bio = rq->bio;
 835	unsigned int prot_op = sd_prot_op(rq_data_dir(rq), dix, dif);
 836	unsigned int protect = 0;
 837
 838	if (dix) {				/* DIX Type 0, 1, 2, 3 */
 839		if (bio_integrity_flagged(bio, BIP_IP_CHECKSUM))
 840			scmd->prot_flags |= SCSI_PROT_IP_CHECKSUM;
 841
 842		if (bio_integrity_flagged(bio, BIP_CHECK_GUARD))
 843			scmd->prot_flags |= SCSI_PROT_GUARD_CHECK;
 844	}
 845
 846	if (dif != T10_PI_TYPE3_PROTECTION) {	/* DIX/DIF Type 0, 1, 2 */
 847		scmd->prot_flags |= SCSI_PROT_REF_INCREMENT;
 848
 849		if (bio_integrity_flagged(bio, BIP_CHECK_REFTAG))
 850			scmd->prot_flags |= SCSI_PROT_REF_CHECK;
 851	}
 852
 853	if (dif) {				/* DIX/DIF Type 1, 2, 3 */
 854		scmd->prot_flags |= SCSI_PROT_TRANSFER_PI;
 855
 856		if (bio_integrity_flagged(bio, BIP_DISK_NOCHECK))
 857			protect = 3 << 5;	/* Disable target PI checking */
 858		else
 859			protect = 1 << 5;	/* Enable target PI checking */
 860	}
 861
 862	scsi_set_prot_op(scmd, prot_op);
 863	scsi_set_prot_type(scmd, dif);
 864	scmd->prot_flags &= sd_prot_flag_mask(prot_op);
 865
 866	return protect;
 867}
 868
 869static void sd_disable_discard(struct scsi_disk *sdkp)
 870{
 871	sdkp->provisioning_mode = SD_LBP_DISABLE;
 872	blk_queue_disable_discard(sdkp->disk->queue);
 873}
 874
 875static void sd_config_discard(struct scsi_disk *sdkp, struct queue_limits *lim,
 876		unsigned int mode)
 877{
 878	unsigned int logical_block_size = sdkp->device->sector_size;
 879	unsigned int max_blocks = 0;
 880
 881	lim->discard_alignment = sdkp->unmap_alignment * logical_block_size;
 882	lim->discard_granularity = max(sdkp->physical_block_size,
 883			sdkp->unmap_granularity * logical_block_size);
 884	sdkp->provisioning_mode = mode;
 885
 886	switch (mode) {
 887
 888	case SD_LBP_FULL:
 889	case SD_LBP_DISABLE:
 890		break;
 891
 892	case SD_LBP_UNMAP:
 893		max_blocks = min_not_zero(sdkp->max_unmap_blocks,
 894					  (u32)SD_MAX_WS16_BLOCKS);
 895		break;
 896
 897	case SD_LBP_WS16:
 898		if (sdkp->device->unmap_limit_for_ws)
 899			max_blocks = sdkp->max_unmap_blocks;
 900		else
 901			max_blocks = sdkp->max_ws_blocks;
 902
 903		max_blocks = min_not_zero(max_blocks, (u32)SD_MAX_WS16_BLOCKS);
 904		break;
 905
 906	case SD_LBP_WS10:
 907		if (sdkp->device->unmap_limit_for_ws)
 908			max_blocks = sdkp->max_unmap_blocks;
 909		else
 910			max_blocks = sdkp->max_ws_blocks;
 911
 912		max_blocks = min_not_zero(max_blocks, (u32)SD_MAX_WS10_BLOCKS);
 913		break;
 914
 915	case SD_LBP_ZERO:
 916		max_blocks = min_not_zero(sdkp->max_ws_blocks,
 917					  (u32)SD_MAX_WS10_BLOCKS);
 918		break;
 919	}
 920
 921	lim->max_hw_discard_sectors = max_blocks *
 922		(logical_block_size >> SECTOR_SHIFT);
 923}
 924
 925static void *sd_set_special_bvec(struct request *rq, unsigned int data_len)
 926{
 927	struct page *page;
 928
 929	page = mempool_alloc(sd_page_pool, GFP_ATOMIC);
 930	if (!page)
 931		return NULL;
 932	clear_highpage(page);
 933	bvec_set_page(&rq->special_vec, page, data_len, 0);
 934	rq->rq_flags |= RQF_SPECIAL_PAYLOAD;
 935	return bvec_virt(&rq->special_vec);
 936}
 937
 938static blk_status_t sd_setup_unmap_cmnd(struct scsi_cmnd *cmd)
 939{
 940	struct scsi_device *sdp = cmd->device;
 941	struct request *rq = scsi_cmd_to_rq(cmd);
 942	struct scsi_disk *sdkp = scsi_disk(rq->q->disk);
 943	u64 lba = sectors_to_logical(sdp, blk_rq_pos(rq));
 944	u32 nr_blocks = sectors_to_logical(sdp, blk_rq_sectors(rq));
 945	unsigned int data_len = 24;
 946	char *buf;
 947
 948	buf = sd_set_special_bvec(rq, data_len);
 949	if (!buf)
 950		return BLK_STS_RESOURCE;
 951
 952	cmd->cmd_len = 10;
 953	cmd->cmnd[0] = UNMAP;
 954	cmd->cmnd[8] = 24;
 955
 956	put_unaligned_be16(6 + 16, &buf[0]);
 957	put_unaligned_be16(16, &buf[2]);
 958	put_unaligned_be64(lba, &buf[8]);
 959	put_unaligned_be32(nr_blocks, &buf[16]);
 960
 961	cmd->allowed = sdkp->max_retries;
 962	cmd->transfersize = data_len;
 963	rq->timeout = SD_TIMEOUT;
 964
 965	return scsi_alloc_sgtables(cmd);
 966}
 967
 968static void sd_config_atomic(struct scsi_disk *sdkp, struct queue_limits *lim)
 969{
 970	unsigned int logical_block_size = sdkp->device->sector_size,
 971		physical_block_size_sectors, max_atomic, unit_min, unit_max;
 972
 973	if ((!sdkp->max_atomic && !sdkp->max_atomic_with_boundary) ||
 974	    sdkp->protection_type == T10_PI_TYPE2_PROTECTION)
 975		return;
 976
 977	physical_block_size_sectors = sdkp->physical_block_size /
 978					sdkp->device->sector_size;
 979
 980	unit_min = rounddown_pow_of_two(sdkp->atomic_granularity ?
 981					sdkp->atomic_granularity :
 982					physical_block_size_sectors);
 983
 984	/*
 985	 * Only use atomic boundary when we have the odd scenario of
 986	 * sdkp->max_atomic == 0, which the spec does permit.
 987	 */
 988	if (sdkp->max_atomic) {
 989		max_atomic = sdkp->max_atomic;
 990		unit_max = rounddown_pow_of_two(sdkp->max_atomic);
 991		sdkp->use_atomic_write_boundary = 0;
 992	} else {
 993		max_atomic = sdkp->max_atomic_with_boundary;
 994		unit_max = rounddown_pow_of_two(sdkp->max_atomic_boundary);
 995		sdkp->use_atomic_write_boundary = 1;
 996	}
 997
 998	/*
 999	 * Ensure compliance with granularity and alignment. For now, keep it
1000	 * simple and just don't support atomic writes for values mismatched
1001	 * with max_{boundary}atomic, physical block size, and
1002	 * atomic_granularity itself.
1003	 *
1004	 * We're really being distrustful by checking unit_max also...
1005	 */
1006	if (sdkp->atomic_granularity > 1) {
1007		if (unit_min > 1 && unit_min % sdkp->atomic_granularity)
1008			return;
1009		if (unit_max > 1 && unit_max % sdkp->atomic_granularity)
1010			return;
1011	}
1012
1013	if (sdkp->atomic_alignment > 1) {
1014		if (unit_min > 1 && unit_min % sdkp->atomic_alignment)
1015			return;
1016		if (unit_max > 1 && unit_max % sdkp->atomic_alignment)
1017			return;
1018	}
1019
1020	lim->atomic_write_hw_max = max_atomic * logical_block_size;
1021	lim->atomic_write_hw_boundary = 0;
1022	lim->atomic_write_hw_unit_min = unit_min * logical_block_size;
1023	lim->atomic_write_hw_unit_max = unit_max * logical_block_size;
1024	lim->features |= BLK_FEAT_ATOMIC_WRITES;
1025}
1026
1027static blk_status_t sd_setup_write_same16_cmnd(struct scsi_cmnd *cmd,
1028		bool unmap)
1029{
1030	struct scsi_device *sdp = cmd->device;
1031	struct request *rq = scsi_cmd_to_rq(cmd);
1032	struct scsi_disk *sdkp = scsi_disk(rq->q->disk);
1033	u64 lba = sectors_to_logical(sdp, blk_rq_pos(rq));
1034	u32 nr_blocks = sectors_to_logical(sdp, blk_rq_sectors(rq));
1035	u32 data_len = sdp->sector_size;
1036
1037	if (!sd_set_special_bvec(rq, data_len))
1038		return BLK_STS_RESOURCE;
1039
1040	cmd->cmd_len = 16;
1041	cmd->cmnd[0] = WRITE_SAME_16;
1042	if (unmap)
1043		cmd->cmnd[1] = 0x8; /* UNMAP */
1044	put_unaligned_be64(lba, &cmd->cmnd[2]);
1045	put_unaligned_be32(nr_blocks, &cmd->cmnd[10]);
1046
1047	cmd->allowed = sdkp->max_retries;
1048	cmd->transfersize = data_len;
1049	rq->timeout = unmap ? SD_TIMEOUT : SD_WRITE_SAME_TIMEOUT;
1050
1051	return scsi_alloc_sgtables(cmd);
1052}
1053
1054static blk_status_t sd_setup_write_same10_cmnd(struct scsi_cmnd *cmd,
1055		bool unmap)
1056{
1057	struct scsi_device *sdp = cmd->device;
1058	struct request *rq = scsi_cmd_to_rq(cmd);
1059	struct scsi_disk *sdkp = scsi_disk(rq->q->disk);
1060	u64 lba = sectors_to_logical(sdp, blk_rq_pos(rq));
1061	u32 nr_blocks = sectors_to_logical(sdp, blk_rq_sectors(rq));
1062	u32 data_len = sdp->sector_size;
1063
1064	if (!sd_set_special_bvec(rq, data_len))
1065		return BLK_STS_RESOURCE;
1066
1067	cmd->cmd_len = 10;
1068	cmd->cmnd[0] = WRITE_SAME;
1069	if (unmap)
1070		cmd->cmnd[1] = 0x8; /* UNMAP */
1071	put_unaligned_be32(lba, &cmd->cmnd[2]);
1072	put_unaligned_be16(nr_blocks, &cmd->cmnd[7]);
1073
1074	cmd->allowed = sdkp->max_retries;
1075	cmd->transfersize = data_len;
1076	rq->timeout = unmap ? SD_TIMEOUT : SD_WRITE_SAME_TIMEOUT;
1077
1078	return scsi_alloc_sgtables(cmd);
1079}
1080
1081static blk_status_t sd_setup_write_zeroes_cmnd(struct scsi_cmnd *cmd)
1082{
1083	struct request *rq = scsi_cmd_to_rq(cmd);
1084	struct scsi_device *sdp = cmd->device;
1085	struct scsi_disk *sdkp = scsi_disk(rq->q->disk);
1086	u64 lba = sectors_to_logical(sdp, blk_rq_pos(rq));
1087	u32 nr_blocks = sectors_to_logical(sdp, blk_rq_sectors(rq));
1088
1089	if (!(rq->cmd_flags & REQ_NOUNMAP)) {
1090		switch (sdkp->zeroing_mode) {
1091		case SD_ZERO_WS16_UNMAP:
1092			return sd_setup_write_same16_cmnd(cmd, true);
1093		case SD_ZERO_WS10_UNMAP:
1094			return sd_setup_write_same10_cmnd(cmd, true);
1095		}
1096	}
1097
1098	if (sdp->no_write_same) {
1099		rq->rq_flags |= RQF_QUIET;
1100		return BLK_STS_TARGET;
1101	}
1102
1103	if (sdkp->ws16 || lba > 0xffffffff || nr_blocks > 0xffff)
1104		return sd_setup_write_same16_cmnd(cmd, false);
1105
1106	return sd_setup_write_same10_cmnd(cmd, false);
1107}
1108
1109static void sd_disable_write_same(struct scsi_disk *sdkp)
1110{
1111	sdkp->device->no_write_same = 1;
1112	sdkp->max_ws_blocks = 0;
1113	blk_queue_disable_write_zeroes(sdkp->disk->queue);
1114}
1115
1116static void sd_config_write_same(struct scsi_disk *sdkp,
1117		struct queue_limits *lim)
1118{
1119	unsigned int logical_block_size = sdkp->device->sector_size;
1120
1121	if (sdkp->device->no_write_same) {
1122		sdkp->max_ws_blocks = 0;
1123		goto out;
1124	}
1125
1126	/* Some devices can not handle block counts above 0xffff despite
1127	 * supporting WRITE SAME(16). Consequently we default to 64k
1128	 * blocks per I/O unless the device explicitly advertises a
1129	 * bigger limit.
1130	 */
1131	if (sdkp->max_ws_blocks > SD_MAX_WS10_BLOCKS)
1132		sdkp->max_ws_blocks = min_not_zero(sdkp->max_ws_blocks,
1133						   (u32)SD_MAX_WS16_BLOCKS);
1134	else if (sdkp->ws16 || sdkp->ws10 || sdkp->device->no_report_opcodes)
1135		sdkp->max_ws_blocks = min_not_zero(sdkp->max_ws_blocks,
1136						   (u32)SD_MAX_WS10_BLOCKS);
1137	else {
1138		sdkp->device->no_write_same = 1;
1139		sdkp->max_ws_blocks = 0;
1140	}
1141
1142	if (sdkp->lbprz && sdkp->lbpws)
1143		sdkp->zeroing_mode = SD_ZERO_WS16_UNMAP;
1144	else if (sdkp->lbprz && sdkp->lbpws10)
1145		sdkp->zeroing_mode = SD_ZERO_WS10_UNMAP;
1146	else if (sdkp->max_ws_blocks)
1147		sdkp->zeroing_mode = SD_ZERO_WS;
1148	else
1149		sdkp->zeroing_mode = SD_ZERO_WRITE;
1150
1151	if (sdkp->max_ws_blocks &&
1152	    sdkp->physical_block_size > logical_block_size) {
1153		/*
1154		 * Reporting a maximum number of blocks that is not aligned
1155		 * on the device physical size would cause a large write same
1156		 * request to be split into physically unaligned chunks by
1157		 * __blkdev_issue_write_zeroes() even if the caller of this
1158		 * functions took care to align the large request. So make sure
1159		 * the maximum reported is aligned to the device physical block
1160		 * size. This is only an optional optimization for regular
1161		 * disks, but this is mandatory to avoid failure of large write
1162		 * same requests directed at sequential write required zones of
1163		 * host-managed ZBC disks.
1164		 */
1165		sdkp->max_ws_blocks =
1166			round_down(sdkp->max_ws_blocks,
1167				   bytes_to_logical(sdkp->device,
1168						    sdkp->physical_block_size));
1169	}
1170
1171out:
1172	lim->max_write_zeroes_sectors =
1173		sdkp->max_ws_blocks * (logical_block_size >> SECTOR_SHIFT);
1174
1175	if (sdkp->zeroing_mode == SD_ZERO_WS16_UNMAP ||
1176	    sdkp->zeroing_mode == SD_ZERO_WS10_UNMAP)
1177		lim->max_hw_wzeroes_unmap_sectors =
1178				lim->max_write_zeroes_sectors;
1179}
1180
1181static blk_status_t sd_setup_flush_cmnd(struct scsi_cmnd *cmd)
1182{
1183	struct request *rq = scsi_cmd_to_rq(cmd);
1184	struct scsi_disk *sdkp = scsi_disk(rq->q->disk);
1185
1186	/* flush requests don't perform I/O, zero the S/G table */
1187	memset(&cmd->sdb, 0, sizeof(cmd->sdb));
1188
1189	if (cmd->device->use_16_for_sync) {
1190		cmd->cmnd[0] = SYNCHRONIZE_CACHE_16;
1191		cmd->cmd_len = 16;
1192	} else {
1193		cmd->cmnd[0] = SYNCHRONIZE_CACHE;
1194		cmd->cmd_len = 10;
1195	}
1196	cmd->transfersize = 0;
1197	cmd->allowed = sdkp->max_retries;
1198
1199	rq->timeout = rq->q->rq_timeout * SD_FLUSH_TIMEOUT_MULTIPLIER;
1200	return BLK_STS_OK;
1201}
1202
1203/**
1204 * sd_group_number() - Compute the GROUP NUMBER field
1205 * @cmd: SCSI command for which to compute the value of the six-bit GROUP NUMBER
1206 *	field.
1207 *
1208 * From SBC-5 r05 (https://www.t10.org/cgi-bin/ac.pl?t=f&f=sbc5r05.pdf):
1209 * 0: no relative lifetime.
1210 * 1: shortest relative lifetime.
1211 * 2: second shortest relative lifetime.
1212 * 3 - 0x3d: intermediate relative lifetimes.
1213 * 0x3e: second longest relative lifetime.
1214 * 0x3f: longest relative lifetime.
1215 */
1216static u8 sd_group_number(struct scsi_cmnd *cmd)
1217{
1218	const struct request *rq = scsi_cmd_to_rq(cmd);
1219	struct scsi_disk *sdkp = scsi_disk(rq->q->disk);
1220
1221	if (!sdkp->rscs)
1222		return 0;
1223
1224	return min3((u32)rq->bio->bi_write_hint,
1225		    (u32)sdkp->permanent_stream_count, 0x3fu);
1226}
1227
1228static blk_status_t sd_setup_rw32_cmnd(struct scsi_cmnd *cmd, bool write,
1229				       sector_t lba, unsigned int nr_blocks,
1230				       unsigned char flags, unsigned int dld)
1231{
1232	cmd->cmd_len = SD_EXT_CDB_SIZE;
1233	cmd->cmnd[0]  = VARIABLE_LENGTH_CMD;
1234	cmd->cmnd[6]  = sd_group_number(cmd);
1235	cmd->cmnd[7]  = 0x18; /* Additional CDB len */
1236	cmd->cmnd[9]  = write ? WRITE_32 : READ_32;
1237	cmd->cmnd[10] = flags;
1238	cmd->cmnd[11] = dld & 0x07;
1239	put_unaligned_be64(lba, &cmd->cmnd[12]);
1240	put_unaligned_be32(lba, &cmd->cmnd[20]); /* Expected Indirect LBA */
1241	put_unaligned_be32(nr_blocks, &cmd->cmnd[28]);
1242
1243	return BLK_STS_OK;
1244}
1245
1246static blk_status_t sd_setup_rw16_cmnd(struct scsi_cmnd *cmd, bool write,
1247				       sector_t lba, unsigned int nr_blocks,
1248				       unsigned char flags, unsigned int dld)
1249{
1250	cmd->cmd_len  = 16;
1251	cmd->cmnd[0]  = write ? WRITE_16 : READ_16;
1252	cmd->cmnd[1]  = flags | ((dld >> 2) & 0x01);
1253	cmd->cmnd[14] = ((dld & 0x03) << 6) | sd_group_number(cmd);
1254	cmd->cmnd[15] = 0;
1255	put_unaligned_be64(lba, &cmd->cmnd[2]);
1256	put_unaligned_be32(nr_blocks, &cmd->cmnd[10]);
1257
1258	return BLK_STS_OK;
1259}
1260
1261static blk_status_t sd_setup_rw10_cmnd(struct scsi_cmnd *cmd, bool write,
1262				       sector_t lba, unsigned int nr_blocks,
1263				       unsigned char flags)
1264{
1265	cmd->cmd_len = 10;
1266	cmd->cmnd[0] = write ? WRITE_10 : READ_10;
1267	cmd->cmnd[1] = flags;
1268	cmd->cmnd[6] = sd_group_number(cmd);
1269	cmd->cmnd[9] = 0;
1270	put_unaligned_be32(lba, &cmd->cmnd[2]);
1271	put_unaligned_be16(nr_blocks, &cmd->cmnd[7]);
1272
1273	return BLK_STS_OK;
1274}
1275
1276static blk_status_t sd_setup_rw6_cmnd(struct scsi_cmnd *cmd, bool write,
1277				      sector_t lba, unsigned int nr_blocks,
1278				      unsigned char flags)
1279{
1280	/* Avoid that 0 blocks gets translated into 256 blocks. */
1281	if (WARN_ON_ONCE(nr_blocks == 0))
1282		return BLK_STS_IOERR;
1283
1284	if (unlikely(flags & 0x8)) {
1285		/*
1286		 * This happens only if this drive failed 10byte rw
1287		 * command with ILLEGAL_REQUEST during operation and
1288		 * thus turned off use_10_for_rw.
1289		 */
1290		scmd_printk(KERN_ERR, cmd, "FUA write on READ/WRITE(6) drive\n");
1291		return BLK_STS_IOERR;
1292	}
1293
1294	cmd->cmd_len = 6;
1295	cmd->cmnd[0] = write ? WRITE_6 : READ_6;
1296	cmd->cmnd[1] = (lba >> 16) & 0x1f;
1297	cmd->cmnd[2] = (lba >> 8) & 0xff;
1298	cmd->cmnd[3] = lba & 0xff;
1299	cmd->cmnd[4] = nr_blocks;
1300	cmd->cmnd[5] = 0;
1301
1302	return BLK_STS_OK;
1303}
1304
1305/*
1306 * Check if a command has a duration limit set. If it does, and the target
1307 * device supports CDL and the feature is enabled, return the limit
1308 * descriptor index to use. Return 0 (no limit) otherwise.
1309 */
1310static int sd_cdl_dld(struct scsi_disk *sdkp, struct scsi_cmnd *scmd)
1311{
1312	struct scsi_device *sdp = sdkp->device;
1313	int hint;
1314
1315	if (!sdp->cdl_supported || !sdp->cdl_enable)
1316		return 0;
1317
1318	/*
1319	 * Use "no limit" if the request ioprio does not specify a duration
1320	 * limit hint.
1321	 */
1322	hint = IOPRIO_PRIO_HINT(req_get_ioprio(scsi_cmd_to_rq(scmd)));
1323	if (hint < IOPRIO_HINT_DEV_DURATION_LIMIT_1 ||
1324	    hint > IOPRIO_HINT_DEV_DURATION_LIMIT_7)
1325		return 0;
1326
1327	return (hint - IOPRIO_HINT_DEV_DURATION_LIMIT_1) + 1;
1328}
1329
1330static blk_status_t sd_setup_atomic_cmnd(struct scsi_cmnd *cmd,
1331					sector_t lba, unsigned int nr_blocks,
1332					bool boundary, unsigned char flags)
1333{
1334	cmd->cmd_len  = 16;
1335	cmd->cmnd[0]  = WRITE_ATOMIC_16;
1336	cmd->cmnd[1]  = flags;
1337	put_unaligned_be64(lba, &cmd->cmnd[2]);
1338	put_unaligned_be16(nr_blocks, &cmd->cmnd[12]);
1339	if (boundary)
1340		put_unaligned_be16(nr_blocks, &cmd->cmnd[10]);
1341	else
1342		put_unaligned_be16(0, &cmd->cmnd[10]);
1343	put_unaligned_be16(nr_blocks, &cmd->cmnd[12]);
1344	cmd->cmnd[14] = 0;
1345	cmd->cmnd[15] = 0;
1346
1347	return BLK_STS_OK;
1348}
1349
1350static blk_status_t sd_setup_read_write_cmnd(struct scsi_cmnd *cmd)
1351{
1352	struct request *rq = scsi_cmd_to_rq(cmd);
1353	struct scsi_device *sdp = cmd->device;
1354	struct scsi_disk *sdkp = scsi_disk(rq->q->disk);
1355	sector_t lba = sectors_to_logical(sdp, blk_rq_pos(rq));
1356	sector_t threshold;
1357	unsigned int nr_blocks = sectors_to_logical(sdp, blk_rq_sectors(rq));
1358	unsigned int mask = logical_to_sectors(sdp, 1) - 1;
1359	bool write = rq_data_dir(rq) == WRITE;
1360	unsigned char protect, fua;
1361	unsigned int dld;
1362	blk_status_t ret;
1363	unsigned int dif;
1364	bool dix;
1365
1366	ret = scsi_alloc_sgtables(cmd);
1367	if (ret != BLK_STS_OK)
1368		return ret;
1369
1370	ret = BLK_STS_IOERR;
1371	if (!scsi_device_online(sdp) || sdp->changed) {
1372		scmd_printk(KERN_ERR, cmd, "device offline or changed\n");
1373		goto fail;
1374	}
1375
1376	if (blk_rq_pos(rq) + blk_rq_sectors(rq) > get_capacity(rq->q->disk)) {
1377		scmd_printk(KERN_ERR, cmd, "access beyond end of device\n");
1378		goto fail;
1379	}
1380
1381	if ((blk_rq_pos(rq) & mask) || (blk_rq_sectors(rq) & mask)) {
1382		scmd_printk(KERN_ERR, cmd, "request not aligned to the logical block size\n");
1383		goto fail;
1384	}
1385
1386	/*
1387	 * Some SD card readers can't handle accesses which touch the
1388	 * last one or two logical blocks. Split accesses as needed.
1389	 */
1390	threshold = sdkp->capacity - SD_LAST_BUGGY_SECTORS;
1391
1392	if (unlikely(sdp->last_sector_bug && lba + nr_blocks > threshold)) {
1393		if (lba < threshold) {
1394			/* Access up to the threshold but not beyond */
1395			nr_blocks = threshold - lba;
1396		} else {
1397			/* Access only a single logical block */
1398			nr_blocks = 1;
1399		}
1400	}
1401
1402	fua = rq->cmd_flags & REQ_FUA ? 0x8 : 0;
1403	dix = scsi_prot_sg_count(cmd);
1404	dif = scsi_host_dif_capable(cmd->device->host, sdkp->protection_type);
1405	dld = sd_cdl_dld(sdkp, cmd);
1406
1407	if (dif || dix)
1408		protect = sd_setup_protect_cmnd(cmd, dix, dif);
1409	else
1410		protect = 0;
1411
1412	if (protect && sdkp->protection_type == T10_PI_TYPE2_PROTECTION) {
1413		ret = sd_setup_rw32_cmnd(cmd, write, lba, nr_blocks,
1414					 protect | fua, dld);
1415	} else if (rq->cmd_flags & REQ_ATOMIC) {
1416		ret = sd_setup_atomic_cmnd(cmd, lba, nr_blocks,
1417				sdkp->use_atomic_write_boundary,
1418				protect | fua);
1419	} else if (sdp->use_16_for_rw || (nr_blocks > 0xffff)) {
1420		ret = sd_setup_rw16_cmnd(cmd, write, lba, nr_blocks,
1421					 protect | fua, dld);
1422	} else if ((nr_blocks > 0xff) || (lba > 0x1fffff) ||
1423		   sdp->use_10_for_rw || protect || rq->bio->bi_write_hint) {
1424		ret = sd_setup_rw10_cmnd(cmd, write, lba, nr_blocks,
1425					 protect | fua);
1426	} else {
1427		ret = sd_setup_rw6_cmnd(cmd, write, lba, nr_blocks,
1428					protect | fua);
1429	}
1430
1431	if (unlikely(ret != BLK_STS_OK))
1432		goto fail;
1433
1434	/*
1435	 * We shouldn't disconnect in the middle of a sector, so with a dumb
1436	 * host adapter, it's safe to assume that we can at least transfer
1437	 * this many bytes between each connect / disconnect.
1438	 */
1439	cmd->transfersize = sdp->sector_size;
1440	cmd->underflow = nr_blocks << 9;
1441	cmd->allowed = sdkp->max_retries;
1442	cmd->sdb.length = nr_blocks * sdp->sector_size;
1443
1444	SCSI_LOG_HLQUEUE(1,
1445			 scmd_printk(KERN_INFO, cmd,
1446				     "%s: block=%llu, count=%d\n", __func__,
1447				     (unsigned long long)blk_rq_pos(rq),
1448				     blk_rq_sectors(rq)));
1449	SCSI_LOG_HLQUEUE(2,
1450			 scmd_printk(KERN_INFO, cmd,
1451				     "%s %d/%u 512 byte blocks.\n",
1452				     write ? "writing" : "reading", nr_blocks,
1453				     blk_rq_sectors(rq)));
1454
1455	/*
1456	 * This indicates that the command is ready from our end to be queued.
1457	 */
1458	return BLK_STS_OK;
1459fail:
1460	scsi_free_sgtables(cmd);
1461	return ret;
1462}
1463
1464static blk_status_t sd_init_command(struct scsi_cmnd *cmd)
1465{
1466	struct request *rq = scsi_cmd_to_rq(cmd);
1467
1468	switch (req_op(rq)) {
1469	case REQ_OP_DISCARD:
1470		switch (scsi_disk(rq->q->disk)->provisioning_mode) {
1471		case SD_LBP_UNMAP:
1472			return sd_setup_unmap_cmnd(cmd);
1473		case SD_LBP_WS16:
1474			return sd_setup_write_same16_cmnd(cmd, true);
1475		case SD_LBP_WS10:
1476			return sd_setup_write_same10_cmnd(cmd, true);
1477		case SD_LBP_ZERO:
1478			return sd_setup_write_same10_cmnd(cmd, false);
1479		default:
1480			return BLK_STS_TARGET;
1481		}
1482	case REQ_OP_WRITE_ZEROES:
1483		return sd_setup_write_zeroes_cmnd(cmd);
1484	case REQ_OP_FLUSH:
1485		return sd_setup_flush_cmnd(cmd);
1486	case REQ_OP_READ:
1487	case REQ_OP_WRITE:
1488		return sd_setup_read_write_cmnd(cmd);
1489	case REQ_OP_ZONE_RESET:
1490		return sd_zbc_setup_zone_mgmt_cmnd(cmd, ZO_RESET_WRITE_POINTER,
1491						   false);
1492	case REQ_OP_ZONE_RESET_ALL:
1493		return sd_zbc_setup_zone_mgmt_cmnd(cmd, ZO_RESET_WRITE_POINTER,
1494						   true);
1495	case REQ_OP_ZONE_OPEN:
1496		return sd_zbc_setup_zone_mgmt_cmnd(cmd, ZO_OPEN_ZONE, false);
1497	case REQ_OP_ZONE_CLOSE:
1498		return sd_zbc_setup_zone_mgmt_cmnd(cmd, ZO_CLOSE_ZONE, false);
1499	case REQ_OP_ZONE_FINISH:
1500		return sd_zbc_setup_zone_mgmt_cmnd(cmd, ZO_FINISH_ZONE, false);
1501	default:
1502		WARN_ON_ONCE(1);
1503		return BLK_STS_NOTSUPP;
1504	}
1505}
1506
1507static void sd_uninit_command(struct scsi_cmnd *SCpnt)
1508{
1509	struct request *rq = scsi_cmd_to_rq(SCpnt);
1510
1511	if (rq->rq_flags & RQF_SPECIAL_PAYLOAD)
1512		mempool_free(rq->special_vec.bv_page, sd_page_pool);
1513}
1514
1515static bool sd_need_revalidate(struct gendisk *disk, struct scsi_disk *sdkp)
1516{
1517	if (sdkp->device->removable || sdkp->write_prot) {
1518		if (disk_check_media_change(disk))
1519			return true;
1520	}
1521
1522	/*
1523	 * Force a full rescan after ioctl(BLKRRPART).  While the disk state has
1524	 * nothing to do with partitions, BLKRRPART is used to force a full
1525	 * revalidate after things like a format for historical reasons.
1526	 */
1527	return test_bit(GD_NEED_PART_SCAN, &disk->state);
1528}
1529
1530/**
1531 *	sd_open - open a scsi disk device
1532 *	@disk: disk to open
1533 *	@mode: open mode
1534 *
1535 *	Returns 0 if successful. Returns a negated errno value in case 
1536 *	of error.
1537 *
1538 *	Note: This can be called from a user context (e.g. fsck(1) )
1539 *	or from within the kernel (e.g. as a result of a mount(1) ).
1540 *	In the latter case @inode and @filp carry an abridged amount
1541 *	of information as noted above.
1542 *
1543 *	Locking: called with disk->open_mutex held.
1544 **/
1545static int sd_open(struct gendisk *disk, blk_mode_t mode)
1546{
1547	struct scsi_disk *sdkp = scsi_disk(disk);
1548	struct scsi_device *sdev = sdkp->device;
1549	int retval;
1550
1551	if (scsi_device_get(sdev))
1552		return -ENXIO;
1553
1554	SCSI_LOG_HLQUEUE(3, sd_printk(KERN_INFO, sdkp, "sd_open\n"));
1555
1556	/*
1557	 * If the device is in error recovery, wait until it is done.
1558	 * If the device is offline, then disallow any access to it.
1559	 */
1560	retval = -ENXIO;
1561	if (!scsi_block_when_processing_errors(sdev))
1562		goto error_out;
1563
1564	if (sd_need_revalidate(disk, sdkp))
1565		sd_revalidate_disk(disk);
1566
1567	/*
1568	 * If the drive is empty, just let the open fail.
1569	 */
1570	retval = -ENOMEDIUM;
1571	if (sdev->removable && !sdkp->media_present &&
1572	    !(mode & BLK_OPEN_NDELAY))
1573		goto error_out;
1574
1575	/*
1576	 * If the device has the write protect tab set, have the open fail
1577	 * if the user expects to be able to write to the thing.
1578	 */
1579	retval = -EROFS;
1580	if (sdkp->write_prot && (mode & BLK_OPEN_WRITE))
1581		goto error_out;
1582
1583	/*
1584	 * It is possible that the disk changing stuff resulted in
1585	 * the device being taken offline.  If this is the case,
1586	 * report this to the user, and don't pretend that the
1587	 * open actually succeeded.
1588	 */
1589	retval = -ENXIO;
1590	if (!scsi_device_online(sdev))
1591		goto error_out;
1592
1593	if ((atomic_inc_return(&sdkp->openers) == 1) && sdev->removable) {
1594		if (scsi_block_when_processing_errors(sdev))
1595			scsi_set_medium_removal(sdev, SCSI_REMOVAL_PREVENT);
1596	}
1597
1598	return 0;
1599
1600error_out:
1601	scsi_device_put(sdev);
1602	return retval;	
1603}
1604
1605/**
1606 *	sd_release - invoked when the (last) close(2) is called on this
1607 *	scsi disk.
1608 *	@disk: disk to release
1609 *
1610 *	Returns 0. 
1611 *
1612 *	Note: may block (uninterruptible) if error recovery is underway
1613 *	on this disk.
1614 *
1615 *	Locking: called with disk->open_mutex held.
1616 **/
1617static void sd_release(struct gendisk *disk)
1618{
1619	struct scsi_disk *sdkp = scsi_disk(disk);
1620	struct scsi_device *sdev = sdkp->device;
1621
1622	SCSI_LOG_HLQUEUE(3, sd_printk(KERN_INFO, sdkp, "sd_release\n"));
1623
1624	if (atomic_dec_return(&sdkp->openers) == 0 && sdev->removable) {
1625		if (scsi_block_when_processing_errors(sdev))
1626			scsi_set_medium_removal(sdev, SCSI_REMOVAL_ALLOW);
1627	}
1628
1629	scsi_device_put(sdev);
1630}
1631
1632static int sd_getgeo(struct gendisk *disk, struct hd_geometry *geo)
1633{
1634	struct scsi_disk *sdkp = scsi_disk(disk);
1635	struct scsi_device *sdp = sdkp->device;
1636	struct Scsi_Host *host = sdp->host;
1637	sector_t capacity = logical_to_sectors(sdp, sdkp->capacity);
1638	int diskinfo[4];
1639
1640	/* default to most commonly used values */
1641	diskinfo[0] = 0x40;	/* 1 << 6 */
1642	diskinfo[1] = 0x20;	/* 1 << 5 */
1643	diskinfo[2] = capacity >> 11;
1644
1645	/* override with calculated, extended default, or driver values */
1646	if (host->hostt->bios_param)
1647		host->hostt->bios_param(sdp, disk, capacity, diskinfo);
1648	else
1649		scsicam_bios_param(disk, capacity, diskinfo);
1650
1651	geo->heads = diskinfo[0];
1652	geo->sectors = diskinfo[1];
1653	geo->cylinders = diskinfo[2];
1654	return 0;
1655}
1656
1657/**
1658 *	sd_ioctl - process an ioctl
1659 *	@bdev: target block device
1660 *	@mode: open mode
1661 *	@cmd: ioctl command number
1662 *	@arg: this is third argument given to ioctl(2) system call.
1663 *	Often contains a pointer.
1664 *
1665 *	Returns 0 if successful (some ioctls return positive numbers on
1666 *	success as well). Returns a negated errno value in case of error.
1667 *
1668 *	Note: most ioctls are forward onto the block subsystem or further
1669 *	down in the scsi subsystem.
1670 **/
1671static int sd_ioctl(struct block_device *bdev, blk_mode_t mode,
1672		    unsigned int cmd, unsigned long arg)
1673{
1674	struct gendisk *disk = bdev->bd_disk;
1675	struct scsi_disk *sdkp = scsi_disk(disk);
1676	struct scsi_device *sdp = sdkp->device;
1677	void __user *p = (void __user *)arg;
1678	int error;
1679    
1680	SCSI_LOG_IOCTL(1, sd_printk(KERN_INFO, sdkp, "sd_ioctl: disk=%s, "
1681				    "cmd=0x%x\n", disk->disk_name, cmd));
1682
1683	if (bdev_is_partition(bdev) && !capable(CAP_SYS_RAWIO))
1684		return -ENOIOCTLCMD;
1685
1686	/*
1687	 * If we are in the middle of error recovery, don't let anyone
1688	 * else try and use this device.  Also, if error recovery fails, it
1689	 * may try and take the device offline, in which case all further
1690	 * access to the device is prohibited.
1691	 */
1692	error = scsi_ioctl_block_when_processing_errors(sdp, cmd,
1693			(mode & BLK_OPEN_NDELAY));
1694	if (error)
1695		return error;
1696
1697	if (is_sed_ioctl(cmd))
1698		return sed_ioctl(sdkp->opal_dev, cmd, p);
1699	return scsi_ioctl(sdp, mode & BLK_OPEN_WRITE, cmd, p);
1700}
1701
1702static void set_media_not_present(struct scsi_disk *sdkp)
1703{
1704	if (sdkp->media_present)
1705		sdkp->device->changed = 1;
1706
1707	if (sdkp->device->removable) {
1708		sdkp->media_present = 0;
1709		sdkp->capacity = 0;
1710	}
1711}
1712
1713static int media_not_present(struct scsi_disk *sdkp,
1714			     struct scsi_sense_hdr *sshdr)
1715{
1716	if (!scsi_sense_valid(sshdr))
1717		return 0;
1718
1719	/* not invoked for commands that could return deferred errors */
1720	switch (sshdr->sense_key) {
1721	case UNIT_ATTENTION:
1722	case NOT_READY:
1723		/* medium not present */
1724		if (sshdr->asc == 0x3A) {
1725			set_media_not_present(sdkp);
1726			return 1;
1727		}
1728	}
1729	return 0;
1730}
1731
1732/**
1733 *	sd_check_events - check media events
1734 *	@disk: kernel device descriptor
1735 *	@clearing: disk events currently being cleared
1736 *
1737 *	Returns mask of DISK_EVENT_*.
1738 *
1739 *	Note: this function is invoked from the block subsystem.
1740 **/
1741static unsigned int sd_check_events(struct gendisk *disk, unsigned int clearing)
1742{
1743	struct scsi_disk *sdkp = disk->private_data;
1744	struct scsi_device *sdp;
1745	int retval;
1746	bool disk_changed;
1747
1748	if (!sdkp)
1749		return 0;
1750
1751	sdp = sdkp->device;
1752	SCSI_LOG_HLQUEUE(3, sd_printk(KERN_INFO, sdkp, "sd_check_events\n"));
1753
1754	/*
1755	 * If the device is offline, don't send any commands - just pretend as
1756	 * if the command failed.  If the device ever comes back online, we
1757	 * can deal with it then.  It is only because of unrecoverable errors
1758	 * that we would ever take a device offline in the first place.
1759	 */
1760	if (!scsi_device_online(sdp)) {
1761		set_media_not_present(sdkp);
1762		goto out;
1763	}
1764
1765	/*
1766	 * Using TEST_UNIT_READY enables differentiation between drive with
1767	 * no cartridge loaded - NOT READY, drive with changed cartridge -
1768	 * UNIT ATTENTION, or with same cartridge - GOOD STATUS.
1769	 *
1770	 * Drives that auto spin down. eg iomega jaz 1G, will be started
1771	 * by sd_spinup_disk() from sd_revalidate_disk(), which happens whenever
1772	 * sd_revalidate() is called.
1773	 */
1774	if (scsi_block_when_processing_errors(sdp)) {
1775		struct scsi_sense_hdr sshdr = { 0, };
1776
1777		retval = scsi_test_unit_ready(sdp, SD_TIMEOUT, sdkp->max_retries,
1778					      &sshdr);
1779
1780		/* failed to execute TUR, assume media not present */
1781		if (retval < 0 || host_byte(retval)) {
1782			set_media_not_present(sdkp);
1783			goto out;
1784		}
1785
1786		if (media_not_present(sdkp, &sshdr))
1787			goto out;
1788	}
1789
1790	/*
1791	 * For removable scsi disk we have to recognise the presence
1792	 * of a disk in the drive.
1793	 */
1794	if (!sdkp->media_present)
1795		sdp->changed = 1;
1796	sdkp->media_present = 1;
1797out:
1798	/*
1799	 * sdp->changed is set under the following conditions:
1800	 *
1801	 *	Medium present state has changed in either direction.
1802	 *	Device has indicated UNIT_ATTENTION.
1803	 */
1804	disk_changed = sdp->changed;
1805	sdp->changed = 0;
1806	return disk_changed ? DISK_EVENT_MEDIA_CHANGE : 0;
1807}
1808
1809static int sd_sync_cache(struct scsi_disk *sdkp)
1810{
1811	int res;
1812	struct scsi_device *sdp = sdkp->device;
1813	const int timeout = sdp->request_queue->rq_timeout
1814		* SD_FLUSH_TIMEOUT_MULTIPLIER;
1815	/* Leave the rest of the command zero to indicate flush everything. */
1816	const unsigned char cmd[16] = { sdp->use_16_for_sync ?
1817				SYNCHRONIZE_CACHE_16 : SYNCHRONIZE_CACHE };
1818	struct scsi_sense_hdr sshdr;
1819	struct scsi_failure failure_defs[] = {
1820		{
1821			.allowed = 3,
1822			.result = SCMD_FAILURE_RESULT_ANY,
1823		},
1824		{}
1825	};
1826	struct scsi_failures failures = {
1827		.failure_definitions = failure_defs,
1828	};
1829	const struct scsi_exec_args exec_args = {
1830		.req_flags = BLK_MQ_REQ_PM,
1831		.sshdr = &sshdr,
1832		.failures = &failures,
1833	};
1834
1835	if (!scsi_device_online(sdp))
1836		return -ENODEV;
1837
1838	res = scsi_execute_cmd(sdp, cmd, REQ_OP_DRV_IN, NULL, 0, timeout,
1839			       sdkp->max_retries, &exec_args);
1840	if (res) {
1841		sd_print_result(sdkp, "Synchronize Cache(10) failed", res);
1842
1843		if (res < 0)
1844			return res;
1845
1846		if (scsi_status_is_check_condition(res) &&
1847		    scsi_sense_valid(&sshdr)) {
1848			sd_print_sense_hdr(sdkp, &sshdr);
1849
1850			/* we need to evaluate the error return  */
1851			if (sshdr.asc == 0x3a ||	/* medium not present */
1852			    sshdr.asc == 0x20 ||	/* invalid command */
1853			    (sshdr.asc == 0x74 && sshdr.ascq == 0x71))	/* drive is password locked */
1854				/* this is no error here */
1855				return 0;
1856
1857			/*
1858			 * If a format is in progress or if the drive does not
1859			 * support sync, there is not much we can do because
1860			 * this is called during shutdown or suspend so just
1861			 * return success so those operations can proceed.
1862			 */
1863			if ((sshdr.asc == 0x04 && sshdr.ascq == 0x04) ||
1864			    sshdr.sense_key == ILLEGAL_REQUEST)
1865				return 0;
1866		}
1867
1868		switch (host_byte(res)) {
1869		/* ignore errors due to racing a disconnection */
1870		case DID_BAD_TARGET:
1871		case DID_NO_CONNECT:
1872			return 0;
1873		/* signal the upper layer it might try again */
1874		case DID_BUS_BUSY:
1875		case DID_IMM_RETRY:
1876		case DID_REQUEUE:
1877		case DID_SOFT_ERROR:
1878			return -EBUSY;
1879		default:
1880			return -EIO;
1881		}
1882	}
1883	return 0;
1884}
1885
1886static void sd_rescan(struct device *dev)
1887{
1888	struct scsi_disk *sdkp = dev_get_drvdata(dev);
1889
1890	sd_revalidate_disk(sdkp->disk);
1891}
1892
1893static int sd_get_unique_id(struct gendisk *disk, u8 id[16],
1894		enum blk_unique_id type)
1895{
1896	struct scsi_device *sdev = scsi_disk(disk)->device;
1897	const struct scsi_vpd *vpd;
1898	const unsigned char *d;
1899	int ret = -ENXIO, len;
1900
1901	rcu_read_lock();
1902	vpd = rcu_dereference(sdev->vpd_pg83);
1903	if (!vpd)
1904		goto out_unlock;
1905
1906	ret = -EINVAL;
1907	for (d = vpd->data + 4; d < vpd->data + vpd->len; d += d[3] + 4) {
1908		/* we only care about designators with LU association */
1909		if (((d[1] >> 4) & 0x3) != 0x00)
1910			continue;
1911		if ((d[1] & 0xf) != type)
1912			continue;
1913
1914		/*
1915		 * Only exit early if a 16-byte descriptor was found.  Otherwise
1916		 * keep looking as one with more entropy might still show up.
1917		 */
1918		len = d[3];
1919		if (len != 8 && len != 12 && len != 16)
1920			continue;
1921		ret = len;
1922		memcpy(id, d + 4, len);
1923		if (len == 16)
1924			break;
1925	}
1926out_unlock:
1927	rcu_read_unlock();
1928	return ret;
1929}
1930
1931static int sd_scsi_to_pr_err(struct scsi_sense_hdr *sshdr, int result)
1932{
1933	switch (host_byte(result)) {
1934	case DID_TRANSPORT_MARGINAL:
1935	case DID_TRANSPORT_DISRUPTED:
1936	case DID_BUS_BUSY:
1937		return PR_STS_RETRY_PATH_FAILURE;
1938	case DID_NO_CONNECT:
1939		return PR_STS_PATH_FAILED;
1940	case DID_TRANSPORT_FAILFAST:
1941		return PR_STS_PATH_FAST_FAILED;
1942	}
1943
1944	switch (status_byte(result)) {
1945	case SAM_STAT_RESERVATION_CONFLICT:
1946		return PR_STS_RESERVATION_CONFLICT;
1947	case SAM_STAT_CHECK_CONDITION:
1948		if (!scsi_sense_valid(sshdr))
1949			return PR_STS_IOERR;
1950
1951		if (sshdr->sense_key == ILLEGAL_REQUEST &&
1952		    (sshdr->asc == 0x26 || sshdr->asc == 0x24))
1953			return -EINVAL;
1954
1955		fallthrough;
1956	default:
1957		return PR_STS_IOERR;
1958	}
1959}
1960
1961static int sd_pr_in_command(struct block_device *bdev, u8 sa,
1962			    unsigned char *data, int data_len)
1963{
1964	struct scsi_disk *sdkp = scsi_disk(bdev->bd_disk);
1965	struct scsi_device *sdev = sdkp->device;
1966	struct scsi_sense_hdr sshdr;
1967	u8 cmd[10] = { PERSISTENT_RESERVE_IN, sa };
1968	struct scsi_failure failure_defs[] = {
1969		{
1970			.sense = UNIT_ATTENTION,
1971			.asc = SCMD_FAILURE_ASC_ANY,
1972			.ascq = SCMD_FAILURE_ASCQ_ANY,
1973			.allowed = 5,
1974			.result = SAM_STAT_CHECK_CONDITION,
1975		},
1976		{}
1977	};
1978	struct scsi_failures failures = {
1979		.failure_definitions = failure_defs,
1980	};
1981	const struct scsi_exec_args exec_args = {
1982		.sshdr = &sshdr,
1983		.failures = &failures,
1984	};
1985	int result;
1986
1987	put_unaligned_be16(data_len, &cmd[7]);
1988
1989	result = scsi_execute_cmd(sdev, cmd, REQ_OP_DRV_IN, data, data_len,
1990				  SD_TIMEOUT, sdkp->max_retries, &exec_args);
1991	if (scsi_status_is_check_condition(result) &&
1992	    scsi_sense_valid(&sshdr)) {
1993		sdev_printk(KERN_INFO, sdev, "PR command failed: %d\n", result);
1994		scsi_print_sense_hdr(sdev, NULL, &sshdr);
1995	}
1996
1997	if (result <= 0)
1998		return result;
1999
2000	return sd_scsi_to_pr_err(&sshdr, result);
2001}
2002
2003static int sd_pr_read_keys(struct block_device *bdev, struct pr_keys *keys_info)
2004{
2005	int result, i, data_offset, num_copy_keys;
2006	u32 num_keys = keys_info->num_keys;
2007	int data_len;
2008	u8 *data;
2009
2010	/*
2011	 * Each reservation key takes 8 bytes and there is an 8-byte header
2012	 * before the reservation key list. The total size must fit into the
2013	 * 16-bit ALLOCATION LENGTH field.
2014	 */
2015	if (check_mul_overflow(num_keys, 8, &data_len) ||
2016	    check_add_overflow(data_len, 8, &data_len) ||
2017	    data_len > USHRT_MAX)
2018		return -EINVAL;
2019
2020	data = kzalloc(data_len, GFP_KERNEL);
2021	if (!data)
2022		return -ENOMEM;
2023
2024	result = sd_pr_in_command(bdev, READ_KEYS, data, data_len);
2025	if (result)
2026		goto free_data;
2027
2028	keys_info->generation = get_unaligned_be32(&data[0]);
2029	keys_info->num_keys = get_unaligned_be32(&data[4]) / 8;
2030
2031	data_offset = 8;
2032	num_copy_keys = min(num_keys, keys_info->num_keys);
2033
2034	for (i = 0; i < num_copy_keys; i++) {
2035		keys_info->keys[i] = get_unaligned_be64(&data[data_offset]);
2036		data_offset += 8;
2037	}
2038
2039free_data:
2040	kfree(data);
2041	return result;
2042}
2043
2044static int sd_pr_read_reservation(struct block_device *bdev,
2045				  struct pr_held_reservation *rsv)
2046{
2047	struct scsi_disk *sdkp = scsi_disk(bdev->bd_disk);
2048	struct scsi_device *sdev = sdkp->device;
2049	u8 data[24] = { };
2050	int result, len;
2051
2052	result = sd_pr_in_command(bdev, READ_RESERVATION, data, sizeof(data));
2053	if (result)
2054		return result;
2055
2056	len = get_unaligned_be32(&data[4]);
2057	if (!len)
2058		return 0;
2059
2060	/* Make sure we have at least the key and type */
2061	if (len < 14) {
2062		sdev_printk(KERN_INFO, sdev,
2063			    "READ RESERVATION failed due to short return buffer of %d bytes\n",
2064			    len);
2065		return -EINVAL;
2066	}
2067
2068	rsv->generation = get_unaligned_be32(&data[0]);
2069	rsv->key = get_unaligned_be64(&data[8]);
2070	rsv->type = scsi_pr_type_to_block(data[21] & 0x0f);
2071	return 0;
2072}
2073
2074static int sd_pr_out_command(struct block_device *bdev, u8 sa, u64 key,
2075			     u64 sa_key, enum scsi_pr_type type, u8 flags)
2076{
2077	struct scsi_disk *sdkp = scsi_disk(bdev->bd_disk);
2078	struct scsi_device *sdev = sdkp->device;
2079	struct scsi_sense_hdr sshdr;
2080	struct scsi_failure failure_defs[] = {
2081		{
2082			.sense = UNIT_ATTENTION,
2083			.asc = SCMD_FAILURE_ASC_ANY,
2084			.ascq = SCMD_FAILURE_ASCQ_ANY,
2085			.allowed = 5,
2086			.result = SAM_STAT_CHECK_CONDITION,
2087		},
2088		{}
2089	};
2090	struct scsi_failures failures = {
2091		.failure_definitions = failure_defs,
2092	};
2093	const struct scsi_exec_args exec_args = {
2094		.sshdr = &sshdr,
2095		.failures = &failures,
2096	};
2097	int result;
2098	u8 cmd[16] = { 0, };
2099	u8 data[24] = { 0, };
2100
2101	cmd[0] = PERSISTENT_RESERVE_OUT;
2102	cmd[1] = sa;
2103	cmd[2] = type;
2104	put_unaligned_be32(sizeof(data), &cmd[5]);
2105
2106	put_unaligned_be64(key, &data[0]);
2107	put_unaligned_be64(sa_key, &data[8]);
2108	data[20] = flags;
2109
2110	result = scsi_execute_cmd(sdev, cmd, REQ_OP_DRV_OUT, &data,
2111				  sizeof(data), SD_TIMEOUT, sdkp->max_retries,
2112				  &exec_args);
2113
2114	if (scsi_status_is_check_condition(result) &&
2115	    scsi_sense_valid(&sshdr)) {
2116		sdev_printk(KERN_INFO, sdev, "PR command failed: %d\n", result);
2117		scsi_print_sense_hdr(sdev, NULL, &sshdr);
2118	}
2119
2120	if (result <= 0)
2121		return result;
2122
2123	return sd_scsi_to_pr_err(&sshdr, result);
2124}
2125
2126static int sd_pr_register(struct block_device *bdev, u64 old_key, u64 new_key,
2127		u32 flags)
2128{
2129	if (flags & ~PR_FL_IGNORE_KEY)
2130		return -EOPNOTSUPP;
2131	return sd_pr_out_command(bdev, (flags & PR_FL_IGNORE_KEY) ? 0x06 : 0x00,
2132			old_key, new_key, 0,
2133			(1 << 0) /* APTPL */);
2134}
2135
2136static int sd_pr_reserve(struct block_device *bdev, u64 key, enum pr_type type,
2137		u32 flags)
2138{
2139	if (flags)
2140		return -EOPNOTSUPP;
2141	return sd_pr_out_command(bdev, 0x01, key, 0,
2142				 block_pr_type_to_scsi(type), 0);
2143}
2144
2145static int sd_pr_release(struct block_device *bdev, u64 key, enum pr_type type)
2146{
2147	return sd_pr_out_command(bdev, 0x02, key, 0,
2148				 block_pr_type_to_scsi(type), 0);
2149}
2150
2151static int sd_pr_preempt(struct block_device *bdev, u64 old_key, u64 new_key,
2152		enum pr_type type, bool abort)
2153{
2154	return sd_pr_out_command(bdev, abort ? 0x05 : 0x04, old_key, new_key,
2155				 block_pr_type_to_scsi(type), 0);
2156}
2157
2158static int sd_pr_clear(struct block_device *bdev, u64 key)
2159{
2160	return sd_pr_out_command(bdev, 0x03, key, 0, 0, 0);
2161}
2162
2163static const struct pr_ops sd_pr_ops = {
2164	.pr_register	= sd_pr_register,
2165	.pr_reserve	= sd_pr_reserve,
2166	.pr_release	= sd_pr_release,
2167	.pr_preempt	= sd_pr_preempt,
2168	.pr_clear	= sd_pr_clear,
2169	.pr_read_keys	= sd_pr_read_keys,
2170	.pr_read_reservation = sd_pr_read_reservation,
2171};
2172
2173static void scsi_disk_free_disk(struct gendisk *disk)
2174{
2175	struct scsi_disk *sdkp = scsi_disk(disk);
2176
2177	put_device(&sdkp->disk_dev);
2178}
2179
2180static const struct block_device_operations sd_fops = {
2181	.owner			= THIS_MODULE,
2182	.open			= sd_open,
2183	.release		= sd_release,
2184	.ioctl			= sd_ioctl,
2185	.getgeo			= sd_getgeo,
2186	.compat_ioctl		= blkdev_compat_ptr_ioctl,
2187	.check_events		= sd_check_events,
2188	.unlock_native_capacity	= sd_unlock_native_capacity,
2189	.report_zones		= sd_zbc_report_zones,
2190	.get_unique_id		= sd_get_unique_id,
2191	.free_disk		= scsi_disk_free_disk,
2192	.pr_ops			= &sd_pr_ops,
2193};
2194
2195/**
2196 *	sd_eh_reset - reset error handling callback
2197 *	@scmd:		sd-issued command that has failed
2198 *
2199 *	This function is called by the SCSI midlayer before starting
2200 *	SCSI EH. When counting medium access failures we have to be
2201 *	careful to register it only only once per device and SCSI EH run;
2202 *	there might be several timed out commands which will cause the
2203 *	'max_medium_access_timeouts' counter to trigger after the first
2204 *	SCSI EH run already and set the device to offline.
2205 *	So this function resets the internal counter before starting SCSI EH.
2206 **/
2207static void sd_eh_reset(struct scsi_cmnd *scmd)
2208{
2209	struct scsi_disk *sdkp = scsi_disk(scsi_cmd_to_rq(scmd)->q->disk);
2210
2211	/* New SCSI EH run, reset gate variable */
2212	sdkp->ignore_medium_access_errors = false;
2213}
2214
2215/**
2216 *	sd_eh_action - error handling callback
2217 *	@scmd:		sd-issued command that has failed
2218 *	@eh_disp:	The recovery disposition suggested by the midlayer
2219 *
2220 *	This function is called by the SCSI midlayer upon completion of an
2221 *	error test command (currently TEST UNIT READY). The result of sending
2222 *	the eh command is passed in eh_disp.  We're looking for devices that
2223 *	fail medium access commands but are OK with non access commands like
2224 *	test unit ready (so wrongly see the device as having a successful
2225 *	recovery)
2226 **/
2227static int sd_eh_action(struct scsi_cmnd *scmd, int eh_disp)
2228{
2229	struct scsi_disk *sdkp = scsi_disk(scsi_cmd_to_rq(scmd)->q->disk);
2230	struct scsi_device *sdev = scmd->device;
2231
2232	if (!scsi_device_online(sdev) ||
2233	    !scsi_medium_access_command(scmd) ||
2234	    host_byte(scmd->result) != DID_TIME_OUT ||
2235	    eh_disp != SUCCESS)
2236		return eh_disp;
2237
2238	/*
2239	 * The device has timed out executing a medium access command.
2240	 * However, the TEST UNIT READY command sent during error
2241	 * handling completed successfully. Either the device is in the
2242	 * process of recovering or has it suffered an internal failure
2243	 * that prevents access to the storage medium.
2244	 */
2245	if (!sdkp->ignore_medium_access_errors) {
2246		sdkp->medium_access_timed_out++;
2247		sdkp->ignore_medium_access_errors = true;
2248	}
2249
2250	/*
2251	 * If the device keeps failing read/write commands but TEST UNIT
2252	 * READY always completes successfully we assume that medium
2253	 * access is no longer possible and take the device offline.
2254	 */
2255	if (sdkp->medium_access_timed_out >= sdkp->max_medium_access_timeouts) {
2256		scmd_printk(KERN_ERR, scmd,
2257			    "Medium access timeout failure. Offlining disk!\n");
2258		mutex_lock(&sdev->state_mutex);
2259		scsi_device_set_state(sdev, SDEV_OFFLINE);
2260		mutex_unlock(&sdev->state_mutex);
2261
2262		return SUCCESS;
2263	}
2264
2265	return eh_disp;
2266}
2267
2268static unsigned int sd_completed_bytes(struct scsi_cmnd *scmd)
2269{
2270	struct request *req = scsi_cmd_to_rq(scmd);
2271	struct scsi_device *sdev = scmd->device;
2272	unsigned int transferred, good_bytes;
2273	u64 start_lba, end_lba, bad_lba;
2274
2275	/*
2276	 * Some commands have a payload smaller than the device logical
2277	 * block size (e.g. INQUIRY on a 4K disk).
2278	 */
2279	if (scsi_bufflen(scmd) <= sdev->sector_size)
2280		return 0;
2281
2282	/* Check if we have a 'bad_lba' information */
2283	if (!scsi_get_sense_info_fld(scmd->sense_buffer,
2284				     SCSI_SENSE_BUFFERSIZE,
2285				     &bad_lba))
2286		return 0;
2287
2288	/*
2289	 * If the bad lba was reported incorrectly, we have no idea where
2290	 * the error is.
2291	 */
2292	start_lba = sectors_to_logical(sdev, blk_rq_pos(req));
2293	end_lba = start_lba + bytes_to_logical(sdev, scsi_bufflen(scmd));
2294	if (bad_lba < start_lba || bad_lba >= end_lba)
2295		return 0;
2296
2297	/*
2298	 * resid is optional but mostly filled in.  When it's unused,
2299	 * its value is zero, so we assume the whole buffer transferred
2300	 */
2301	transferred = scsi_bufflen(scmd) - scsi_get_resid(scmd);
2302
2303	/* This computation should always be done in terms of the
2304	 * resolution of the device's medium.
2305	 */
2306	good_bytes = logical_to_bytes(sdev, bad_lba - start_lba);
2307
2308	return min(good_bytes, transferred);
2309}
2310
2311/**
2312 *	sd_done - bottom half handler: called when the lower level
2313 *	driver has completed (successfully or otherwise) a scsi command.
2314 *	@SCpnt: mid-level's per command structure.
2315 *
2316 *	Note: potentially run from within an ISR. Must not block.
2317 **/
2318static int sd_done(struct scsi_cmnd *SCpnt)
2319{
2320	int result = SCpnt->result;
2321	unsigned int good_bytes = result ? 0 : scsi_bufflen(SCpnt);
2322	unsigned int sector_size = SCpnt->device->sector_size;
2323	unsigned int resid;
2324	struct scsi_sense_hdr sshdr;
2325	struct request *req = scsi_cmd_to_rq(SCpnt);
2326	struct scsi_disk *sdkp = scsi_disk(req->q->disk);
2327	int sense_valid = 0;
2328	int sense_deferred = 0;
2329
2330	switch (req_op(req)) {
2331	case REQ_OP_DISCARD:
2332	case REQ_OP_WRITE_ZEROES:
2333	case REQ_OP_ZONE_RESET:
2334	case REQ_OP_ZONE_RESET_ALL:
2335	case REQ_OP_ZONE_OPEN:
2336	case REQ_OP_ZONE_CLOSE:
2337	case REQ_OP_ZONE_FINISH:
2338		if (!result) {
2339			good_bytes = blk_rq_bytes(req);
2340			scsi_set_resid(SCpnt, 0);
2341		} else {
2342			good_bytes = 0;
2343			scsi_set_resid(SCpnt, blk_rq_bytes(req));
2344		}
2345		break;
2346	default:
2347		/*
2348		 * In case of bogus fw or device, we could end up having
2349		 * an unaligned partial completion. Check this here and force
2350		 * alignment.
2351		 */
2352		resid = scsi_get_resid(SCpnt);
2353		if (resid & (sector_size - 1)) {
2354			sd_printk(KERN_INFO, sdkp,
2355				"Unaligned partial completion (resid=%u, sector_sz=%u)\n",
2356				resid, sector_size);
2357			scsi_print_command(SCpnt);
2358			resid = min(scsi_bufflen(SCpnt),
2359				    round_up(resid, sector_size));
2360			scsi_set_resid(SCpnt, resid);
2361		}
2362	}
2363
2364	if (result) {
2365		sense_valid = scsi_command_normalize_sense(SCpnt, &sshdr);
2366		if (sense_valid)
2367			sense_deferred = scsi_sense_is_deferred(&sshdr);
2368	}
2369	sdkp->medium_access_timed_out = 0;
2370
2371	if (!scsi_status_is_check_condition(result) &&
2372	    (!sense_valid || sense_deferred))
2373		goto out;
2374
2375	switch (sshdr.sense_key) {
2376	case HARDWARE_ERROR:
2377	case MEDIUM_ERROR:
2378		good_bytes = sd_completed_bytes(SCpnt);
2379		break;
2380	case RECOVERED_ERROR:
2381		good_bytes = scsi_bufflen(SCpnt);
2382		break;
2383	case NO_SENSE:
2384		/* This indicates a false check condition, so ignore it.  An
2385		 * unknown amount of data was transferred so treat it as an
2386		 * error.
2387		 */
2388		SCpnt->result = 0;
2389		memset(SCpnt->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);
2390		break;
2391	case ABORTED_COMMAND:
2392		if (sshdr.asc == 0x10)  /* DIF: Target detected corruption */
2393			good_bytes = sd_completed_bytes(SCpnt);
2394		break;
2395	case ILLEGAL_REQUEST:
2396		switch (sshdr.asc) {
2397		case 0x10:	/* DIX: Host detected corruption */
2398			good_bytes = sd_completed_bytes(SCpnt);
2399			break;
2400		case 0x20:	/* INVALID COMMAND OPCODE */
2401		case 0x24:	/* INVALID FIELD IN CDB */
2402			switch (SCpnt->cmnd[0]) {
2403			case UNMAP:
2404				sd_disable_discard(sdkp);
2405				break;
2406			case WRITE_SAME_16:
2407			case WRITE_SAME:
2408				if (SCpnt->cmnd[1] & 8) { /* UNMAP */
2409					sd_disable_discard(sdkp);
2410				} else {
2411					sd_disable_write_same(sdkp);
2412					req->rq_flags |= RQF_QUIET;
2413				}
2414				break;
2415			}
2416		}
2417		break;
2418	default:
2419		break;
2420	}
2421
2422 out:
2423	if (sdkp->device->type == TYPE_ZBC)
2424		good_bytes = sd_zbc_complete(SCpnt, good_bytes, &sshdr);
2425
2426	SCSI_LOG_HLCOMPLETE(1, scmd_printk(KERN_INFO, SCpnt,
2427					   "sd_done: completed %d of %d bytes\n",
2428					   good_bytes, scsi_bufflen(SCpnt)));
2429
2430	return good_bytes;
2431}
2432
2433/*
2434 * spinup disk - called only in sd_revalidate_disk()
2435 */
2436static void
2437sd_spinup_disk(struct scsi_disk *sdkp)
2438{
2439	static const u8 cmd[10] = { TEST_UNIT_READY };
2440	unsigned long spintime_expire = 0;
2441	int spintime, sense_valid = 0;
2442	unsigned int the_result;
2443	struct scsi_sense_hdr sshdr;
2444	struct scsi_failure failure_defs[] = {
2445		/* Do not retry Medium Not Present */
2446		{
2447			.sense = UNIT_ATTENTION,
2448			.asc = 0x3A,
2449			.ascq = SCMD_FAILURE_ASCQ_ANY,
2450			.result = SAM_STAT_CHECK_CONDITION,
2451		},
2452		{
2453			.sense = NOT_READY,
2454			.asc = 0x3A,
2455			.ascq = SCMD_FAILURE_ASCQ_ANY,
2456			.result = SAM_STAT_CHECK_CONDITION,
2457		},
2458		/* Retry when scsi_status_is_good would return false 3 times */
2459		{
2460			.result = SCMD_FAILURE_STAT_ANY,
2461			.allowed = 3,
2462		},
2463		{}
2464	};
2465	struct scsi_failures failures = {
2466		.failure_definitions = failure_defs,
2467	};
2468	const struct scsi_exec_args exec_args = {
2469		.sshdr = &sshdr,
2470		.failures = &failures,
2471	};
2472
2473	spintime = 0;
2474
2475	/* Spin up drives, as required.  Only do this at boot time */
2476	/* Spinup needs to be done for module loads too. */
2477	do {
2478		bool media_was_present = sdkp->media_present;
2479
2480		scsi_failures_reset_retries(&failures);
2481
2482		the_result = scsi_execute_cmd(sdkp->device, cmd, REQ_OP_DRV_IN,
2483					      NULL, 0, SD_TIMEOUT,
2484					      sdkp->max_retries, &exec_args);
2485
2486
2487		if (the_result > 0) {
2488			/*
2489			 * If the drive has indicated to us that it doesn't
2490			 * have any media in it, don't bother with any more
2491			 * polling.
2492			 */
2493			if (media_not_present(sdkp, &sshdr)) {
2494				if (media_was_present)
2495					sd_printk(KERN_NOTICE, sdkp,
2496						  "Media removed, stopped polling\n");
2497				return;
2498			}
2499			sense_valid = scsi_sense_valid(&sshdr);
2500		}
2501
2502		if (!scsi_status_is_check_condition(the_result)) {
2503			/* no sense, TUR either succeeded or failed
2504			 * with a status error */
2505			if(!spintime && !scsi_status_is_good(the_result)) {
2506				sd_print_result(sdkp, "Test Unit Ready failed",
2507						the_result);
2508			}
2509			break;
2510		}
2511
2512		/*
2513		 * The device does not want the automatic start to be issued.
2514		 */
2515		if (sdkp->device->no_start_on_add)
2516			break;
2517
2518		if (sense_valid && sshdr.sense_key == NOT_READY) {
2519			if (sshdr.asc == 4 && sshdr.ascq == 3)
2520				break;	/* manual intervention required */
2521			if (sshdr.asc == 4 && sshdr.ascq == 0xb)
2522				break;	/* standby */
2523			if (sshdr.asc == 4 && sshdr.ascq == 0xc)
2524				break;	/* unavailable */
2525			if (sshdr.asc == 4 && sshdr.ascq == 0x1b)
2526				break;	/* sanitize in progress */
2527			if (sshdr.asc == 4 && sshdr.ascq == 0x24)
2528				break;	/* depopulation in progress */
2529			if (sshdr.asc == 4 && sshdr.ascq == 0x25)
2530				break;	/* depopulation restoration in progress */
2531			/*
2532			 * Issue command to spin up drive when not ready
2533			 */
2534			if (!spintime) {
2535				/* Return immediately and start spin cycle */
2536				const u8 start_cmd[10] = {
2537					[0] = START_STOP,
2538					[1] = 1,
2539					[4] = sdkp->device->start_stop_pwr_cond ?
2540						0x11 : 1,
2541				};
2542
2543				sd_printk(KERN_NOTICE, sdkp, "Spinning up disk...");
2544				scsi_execute_cmd(sdkp->device, start_cmd,
2545						 REQ_OP_DRV_IN, NULL, 0,
2546						 SD_TIMEOUT, sdkp->max_retries,
2547						 &exec_args);
2548				spintime_expire = jiffies + 100 * HZ;
2549				spintime = 1;
2550			}
2551			/* Wait 1 second for next try */
2552			msleep(1000);
2553			printk(KERN_CONT ".");
2554
2555		/*
2556		 * Wait for USB flash devices with slow firmware.
2557		 * Yes, this sense key/ASC combination shouldn't
2558		 * occur here.  It's characteristic of these devices.
2559		 */
2560		} else if (sense_valid &&
2561				sshdr.sense_key == UNIT_ATTENTION &&
2562				sshdr.asc == 0x28) {
2563			if (!spintime) {
2564				spintime_expire = jiffies + 5 * HZ;
2565				spintime = 1;
2566			}
2567			/* Wait 1 second for next try */
2568			msleep(1000);
2569		} else {
2570			/* we don't understand the sense code, so it's
2571			 * probably pointless to loop */
2572			if(!spintime) {
2573				sd_printk(KERN_NOTICE, sdkp, "Unit Not Ready\n");
2574				sd_print_sense_hdr(sdkp, &sshdr);
2575			}
2576			break;
2577		}
2578				
2579	} while (spintime && time_before_eq(jiffies, spintime_expire));
2580
2581	if (spintime) {
2582		if (scsi_status_is_good(the_result))
2583			printk(KERN_CONT "ready\n");
2584		else
2585			printk(KERN_CONT "not responding...\n");
2586	}
2587}
2588
2589/*
2590 * Determine whether disk supports Data Integrity Field.
2591 */
2592static int sd_read_protection_type(struct scsi_disk *sdkp, unsigned char *buffer)
2593{
2594	struct scsi_device *sdp = sdkp->device;
2595	u8 type;
2596
2597	if (scsi_device_protection(sdp) == 0 || (buffer[12] & 1) == 0) {
2598		sdkp->protection_type = 0;
2599		return 0;
2600	}
2601
2602	type = ((buffer[12] >> 1) & 7) + 1; /* P_TYPE 0 = Type 1 */
2603
2604	if (type > T10_PI_TYPE3_PROTECTION) {
2605		sd_printk(KERN_ERR, sdkp, "formatted with unsupported"	\
2606			  " protection type %u. Disabling disk!\n",
2607			  type);
2608		sdkp->protection_type = 0;
2609		return -ENODEV;
2610	}
2611
2612	sdkp->protection_type = type;
2613
2614	return 0;
2615}
2616
2617static void sd_config_protection(struct scsi_disk *sdkp,
2618		struct queue_limits *lim)
2619{
2620	struct scsi_device *sdp = sdkp->device;
2621
2622	if (IS_ENABLED(CONFIG_BLK_DEV_INTEGRITY))
2623		sd_dif_config_host(sdkp, lim);
2624
2625	if (!sdkp->protection_type)
2626		return;
2627
2628	if (!scsi_host_dif_capable(sdp->host, sdkp->protection_type)) {
2629		sd_first_printk(KERN_NOTICE, sdkp,
2630				"Disabling DIF Type %u protection\n",
2631				sdkp->protection_type);
2632		sdkp->protection_type = 0;
2633	}
2634
2635	sd_first_printk(KERN_NOTICE, sdkp, "Enabling DIF Type %u protection\n",
2636			sdkp->protection_type);
2637}
2638
2639static void read_capacity_error(struct scsi_disk *sdkp, struct scsi_device *sdp,
2640			struct scsi_sense_hdr *sshdr, int sense_valid,
2641			int the_result)
2642{
2643	if (sense_valid)
2644		sd_print_sense_hdr(sdkp, sshdr);
2645	else
2646		sd_printk(KERN_NOTICE, sdkp, "Sense not available.\n");
2647
2648	/*
2649	 * Set dirty bit for removable devices if not ready -
2650	 * sometimes drives will not report this properly.
2651	 */
2652	if (sdp->removable &&
2653	    sense_valid && sshdr->sense_key == NOT_READY)
2654		set_media_not_present(sdkp);
2655
2656	/*
2657	 * We used to set media_present to 0 here to indicate no media
2658	 * in the drive, but some drives fail read capacity even with
2659	 * media present, so we can't do that.
2660	 */
2661	sdkp->capacity = 0; /* unknown mapped to zero - as usual */
2662}
2663
2664#define RC16_LEN 32
2665#if RC16_LEN > SD_BUF_SIZE
2666#error RC16_LEN must not be more than SD_BUF_SIZE
2667#endif
2668
2669#define READ_CAPACITY_RETRIES_ON_RESET	10
2670
2671static int read_capacity_16(struct scsi_disk *sdkp, struct scsi_device *sdp,
2672		struct queue_limits *lim, unsigned char *buffer)
2673{
2674	unsigned char cmd[16];
2675	struct scsi_sense_hdr sshdr;
2676	const struct scsi_exec_args exec_args = {
2677		.sshdr = &sshdr,
2678	};
2679	int sense_valid = 0;
2680	int the_result;
2681	int retries = 3, reset_retries = READ_CAPACITY_RETRIES_ON_RESET;
2682	unsigned int alignment;
2683	unsigned long long lba;
2684	unsigned sector_size;
2685
2686	if (sdp->no_read_capacity_16)
2687		return -EINVAL;
2688
2689	do {
2690		memset(cmd, 0, 16);
2691		cmd[0] = SERVICE_ACTION_IN_16;
2692		cmd[1] = SAI_READ_CAPACITY_16;
2693		cmd[13] = RC16_LEN;
2694		memset(buffer, 0, RC16_LEN);
2695
2696		the_result = scsi_execute_cmd(sdp, cmd, REQ_OP_DRV_IN,
2697					      buffer, RC16_LEN, SD_TIMEOUT,
2698					      sdkp->max_retries, &exec_args);
2699		if (the_result > 0) {
2700			if (media_not_present(sdkp, &sshdr))
2701				return -ENODEV;
2702
2703			sense_valid = scsi_sense_valid(&sshdr);
2704			if (sense_valid &&
2705			    sshdr.sense_key == ILLEGAL_REQUEST &&
2706			    (sshdr.asc == 0x20 || sshdr.asc == 0x24) &&
2707			    sshdr.ascq == 0x00)
2708				/* Invalid Command Operation Code or
2709				 * Invalid Field in CDB, just retry
2710				 * silently with RC10 */
2711				return -EINVAL;
2712			if (sense_valid &&
2713			    sshdr.sense_key == UNIT_ATTENTION &&
2714			    sshdr.asc == 0x29 && sshdr.ascq == 0x00)
2715				/* Device reset might occur several times,
2716				 * give it one more chance */
2717				if (--reset_retries > 0)
2718					continue;
2719		}
2720		retries--;
2721
2722	} while (the_result && retries);
2723
2724	if (the_result) {
2725		sd_print_result(sdkp, "Read Capacity(16) failed", the_result);
2726		read_capacity_error(sdkp, sdp, &sshdr, sense_valid, the_result);
2727		return -EINVAL;
2728	}
2729
2730	sector_size = get_unaligned_be32(&buffer[8]);
2731	lba = get_unaligned_be64(&buffer[0]);
2732
2733	if (sd_read_protection_type(sdkp, buffer) < 0) {
2734		sdkp->capacity = 0;
2735		return -ENODEV;
2736	}
2737
2738	/* Logical blocks per physical block exponent */
2739	sdkp->physical_block_size = (1 << (buffer[13] & 0xf)) * sector_size;
2740
2741	/* RC basis */
2742	sdkp->rc_basis = (buffer[12] >> 4) & 0x3;
2743
2744	/* Lowest aligned logical block */
2745	alignment = ((buffer[14] & 0x3f) << 8 | buffer[15]) * sector_size;
2746	lim->alignment_offset = alignment;
2747	if (alignment && sdkp->first_scan)
2748		sd_printk(KERN_NOTICE, sdkp,
2749			  "physical block alignment offset: %u\n", alignment);
2750
2751	if (buffer[14] & 0x80) { /* LBPME */
2752		sdkp->lbpme = 1;
2753
2754		if (buffer[14] & 0x40) /* LBPRZ */
2755			sdkp->lbprz = 1;
2756	}
2757
2758	sdkp->capacity = lba + 1;
2759	return sector_size;
2760}
2761
2762static int read_capacity_10(struct scsi_disk *sdkp, struct scsi_device *sdp,
2763						unsigned char *buffer)
2764{
2765	static const u8 cmd[10] = { READ_CAPACITY };
2766	struct scsi_sense_hdr sshdr;
2767	struct scsi_failure failure_defs[] = {
2768		/* Do not retry Medium Not Present */
2769		{
2770			.sense = UNIT_ATTENTION,
2771			.asc = 0x3A,
2772			.result = SAM_STAT_CHECK_CONDITION,
2773		},
2774		{
2775			.sense = NOT_READY,
2776			.asc = 0x3A,
2777			.result = SAM_STAT_CHECK_CONDITION,
2778		},
2779		 /* Device reset might occur several times so retry a lot */
2780		{
2781			.sense = UNIT_ATTENTION,
2782			.asc = 0x29,
2783			.allowed = READ_CAPACITY_RETRIES_ON_RESET,
2784			.result = SAM_STAT_CHECK_CONDITION,
2785		},
2786		/* Any other error not listed above retry 3 times */
2787		{
2788			.result = SCMD_FAILURE_RESULT_ANY,
2789			.allowed = 3,
2790		},
2791		{}
2792	};
2793	struct scsi_failures failures = {
2794		.failure_definitions = failure_defs,
2795	};
2796	const struct scsi_exec_args exec_args = {
2797		.sshdr = &sshdr,
2798		.failures = &failures,
2799	};
2800	int sense_valid = 0;
2801	int the_result;
2802	sector_t lba;
2803	unsigned sector_size;
2804
2805	memset(buffer, 0, 8);
2806
2807	the_result = scsi_execute_cmd(sdp, cmd, REQ_OP_DRV_IN, buffer,
2808				      8, SD_TIMEOUT, sdkp->max_retries,
2809				      &exec_args);
2810
2811	if (the_result > 0) {
2812		sense_valid = scsi_sense_valid(&sshdr);
2813
2814		if (media_not_present(sdkp, &sshdr))
2815			return -ENODEV;
2816	}
2817
2818	if (the_result) {
2819		sd_print_result(sdkp, "Read Capacity(10) failed", the_result);
2820		read_capacity_error(sdkp, sdp, &sshdr, sense_valid, the_result);
2821		return -EINVAL;
2822	}
2823
2824	sector_size = get_unaligned_be32(&buffer[4]);
2825	lba = get_unaligned_be32(&buffer[0]);
2826
2827	if (sdp->no_read_capacity_16 && (lba == 0xffffffff)) {
2828		/* Some buggy (usb cardreader) devices return an lba of
2829		   0xffffffff when the want to report a size of 0 (with
2830		   which they really mean no media is present) */
2831		sdkp->capacity = 0;
2832		sdkp->physical_block_size = sector_size;
2833		return sector_size;
2834	}
2835
2836	sdkp->capacity = lba + 1;
2837	sdkp->physical_block_size = sector_size;
2838	return sector_size;
2839}
2840
2841static int sd_try_rc16_first(struct scsi_device *sdp)
2842{
2843	if (sdp->host->max_cmd_len < 16)
2844		return 0;
2845	if (sdp->try_rc_10_first)
2846		return 0;
2847	if (sdp->scsi_level > SCSI_SPC_2)
2848		return 1;
2849	if (scsi_device_protection(sdp))
2850		return 1;
2851	return 0;
2852}
2853
2854/*
2855 * read disk capacity
2856 */
2857static void
2858sd_read_capacity(struct scsi_disk *sdkp, struct queue_limits *lim,
2859		unsigned char *buffer)
2860{
2861	int sector_size;
2862	struct scsi_device *sdp = sdkp->device;
2863
2864	if (sd_try_rc16_first(sdp)) {
2865		sector_size = read_capacity_16(sdkp, sdp, lim, buffer);
2866		if (sector_size == -EOVERFLOW)
2867			goto got_data;
2868		if (sector_size == -ENODEV)
2869			return;
2870		if (sector_size < 0)
2871			sector_size = read_capacity_10(sdkp, sdp, buffer);
2872		if (sector_size < 0)
2873			return;
2874	} else {
2875		sector_size = read_capacity_10(sdkp, sdp, buffer);
2876		if (sector_size == -EOVERFLOW)
2877			goto got_data;
2878		if (sector_size < 0)
2879			return;
2880		if ((sizeof(sdkp->capacity) > 4) &&
2881		    (sdkp->capacity > 0xffffffffULL)) {
2882			int old_sector_size = sector_size;
2883			sd_printk(KERN_NOTICE, sdkp, "Very big device. "
2884					"Trying to use READ CAPACITY(16).\n");
2885			sector_size = read_capacity_16(sdkp, sdp, lim, buffer);
2886			if (sector_size < 0) {
2887				sd_printk(KERN_NOTICE, sdkp,
2888					"Using 0xffffffff as device size\n");
2889				sdkp->capacity = 1 + (sector_t) 0xffffffff;
2890				sector_size = old_sector_size;
2891				goto got_data;
2892			}
2893			/* Remember that READ CAPACITY(16) succeeded */
2894			sdp->try_rc_10_first = 0;
2895		}
2896	}
2897
2898	/* Some devices are known to return the total number of blocks,
2899	 * not the highest block number.  Some devices have versions
2900	 * which do this and others which do not.  Some devices we might
2901	 * suspect of doing this but we don't know for certain.
2902	 *
2903	 * If we know the reported capacity is wrong, decrement it.  If
2904	 * we can only guess, then assume the number of blocks is even
2905	 * (usually true but not always) and err on the side of lowering
2906	 * the capacity.
2907	 */
2908	if (sdp->fix_capacity ||
2909	    (sdp->guess_capacity && (sdkp->capacity & 0x01))) {
2910		sd_printk(KERN_INFO, sdkp, "Adjusting the sector count "
2911				"from its reported value: %llu\n",
2912				(unsigned long long) sdkp->capacity);
2913		--sdkp->capacity;
2914	}
2915
2916got_data:
2917	if (sector_size == 0) {
2918		sector_size = 512;
2919		sd_printk(KERN_NOTICE, sdkp, "Sector size 0 reported, "
2920			  "assuming 512.\n");
2921	}
2922
2923	if (sector_size != 512 &&
2924	    sector_size != 1024 &&
2925	    sector_size != 2048 &&
2926	    sector_size != 4096) {
2927		sd_printk(KERN_NOTICE, sdkp, "Unsupported sector size %d.\n",
2928			  sector_size);
2929		/*
2930		 * The user might want to re-format the drive with
2931		 * a supported sectorsize.  Once this happens, it
2932		 * would be relatively trivial to set the thing up.
2933		 * For this reason, we leave the thing in the table.
2934		 */
2935		sdkp->capacity = 0;
2936		/*
2937		 * set a bogus sector size so the normal read/write
2938		 * logic in the block layer will eventually refuse any
2939		 * request on this device without tripping over power
2940		 * of two sector size assumptions
2941		 */
2942		sector_size = 512;
2943	}
2944	lim->logical_block_size = sector_size;
2945	lim->physical_block_size = sdkp->physical_block_size;
2946	sdkp->device->sector_size = sector_size;
2947
2948	if (sdkp->capacity > 0xffffffff)
2949		sdp->use_16_for_rw = 1;
2950
2951}
2952
2953/*
2954 * Print disk capacity
2955 */
2956static void
2957sd_print_capacity(struct scsi_disk *sdkp,
2958		  sector_t old_capacity)
2959{
2960	int sector_size = sdkp->device->sector_size;
2961	char cap_str_2[10], cap_str_10[10];
2962
2963	if (!sdkp->first_scan && old_capacity == sdkp->capacity)
2964		return;
2965
2966	string_get_size(sdkp->capacity, sector_size,
2967			STRING_UNITS_2, cap_str_2, sizeof(cap_str_2));
2968	string_get_size(sdkp->capacity, sector_size,
2969			STRING_UNITS_10, cap_str_10, sizeof(cap_str_10));
2970
2971	sd_printk(KERN_NOTICE, sdkp,
2972		  "%llu %d-byte logical blocks: (%s/%s)\n",
2973		  (unsigned long long)sdkp->capacity,
2974		  sector_size, cap_str_10, cap_str_2);
2975
2976	if (sdkp->physical_block_size != sector_size)
2977		sd_printk(KERN_NOTICE, sdkp,
2978			  "%u-byte physical blocks\n",
2979			  sdkp->physical_block_size);
2980}
2981
2982/* called with buffer of length 512 */
2983static inline int
2984sd_do_mode_sense(struct scsi_disk *sdkp, int dbd, int modepage,
2985		 unsigned char *buffer, int len, struct scsi_mode_data *data,
2986		 struct scsi_sense_hdr *sshdr)
2987{
2988	/*
2989	 * If we must use MODE SENSE(10), make sure that the buffer length
2990	 * is at least 8 bytes so that the mode sense header fits.
2991	 */
2992	if (sdkp->device->use_10_for_ms && len < 8)
2993		len = 8;
2994
2995	return scsi_mode_sense(sdkp->device, dbd, modepage, 0, buffer, len,
2996			       SD_TIMEOUT, sdkp->max_retries, data, sshdr);
2997}
2998
2999/*
3000 * read write protect setting, if possible - called only in sd_revalidate_disk()
3001 * called with buffer of length SD_BUF_SIZE
3002 */
3003static void
3004sd_read_write_protect_flag(struct scsi_disk *sdkp, unsigned char *buffer)
3005{
3006	int res;
3007	struct scsi_device *sdp = sdkp->device;
3008	struct scsi_mode_data data;
3009	int old_wp = sdkp->write_prot;
3010
3011	set_disk_ro(sdkp->disk, 0);
3012	if (sdp->skip_ms_page_3f) {
3013		sd_first_printk(KERN_NOTICE, sdkp, "Assuming Write Enabled\n");
3014		return;
3015	}
3016
3017	if (sdp->use_192_bytes_for_3f) {
3018		res = sd_do_mode_sense(sdkp, 0, 0x3F, buffer, 192, &data, NULL);
3019	} else {
3020		/*
3021		 * First attempt: ask for all pages (0x3F), but only 4 bytes.
3022		 * We have to start carefully: some devices hang if we ask
3023		 * for more than is available.
3024		 */
3025		res = sd_do_mode_sense(sdkp, 0, 0x3F, buffer, 4, &data, NULL);
3026
3027		/*
3028		 * Second attempt: ask for page 0 When only page 0 is
3029		 * implemented, a request for page 3F may return Sense Key
3030		 * 5: Illegal Request, Sense Code 24: Invalid field in
3031		 * CDB.
3032		 */
3033		if (res < 0)
3034			res = sd_do_mode_sense(sdkp, 0, 0, buffer, 4, &data, NULL);
3035
3036		/*
3037		 * Third attempt: ask 255 bytes, as we did earlier.
3038		 */
3039		if (res < 0)
3040			res = sd_do_mode_sense(sdkp, 0, 0x3F, buffer, 255,
3041					       &data, NULL);
3042	}
3043
3044	if (res < 0) {
3045		sd_first_printk(KERN_WARNING, sdkp,
3046			  "Test WP failed, assume Write Enabled\n");
3047	} else {
3048		sdkp->write_prot = ((data.device_specific & 0x80) != 0);
3049		set_disk_ro(sdkp->disk, sdkp->write_prot);
3050		if (sdkp->first_scan || old_wp != sdkp->write_prot) {
3051			sd_printk(KERN_NOTICE, sdkp, "Write Protect is %s\n",
3052				  sdkp->write_prot ? "on" : "off");
3053			sd_printk(KERN_DEBUG, sdkp, "Mode Sense: %4ph\n", buffer);
3054		}
3055	}
3056}
3057
3058/*
3059 * sd_read_cache_type - called only from sd_revalidate_disk()
3060 * called with buffer of length SD_BUF_SIZE
3061 */
3062static void
3063sd_read_cache_type(struct scsi_disk *sdkp, unsigned char *buffer)
3064{
3065	int len = 0, res;
3066	struct scsi_device *sdp = sdkp->device;
3067
3068	int dbd;
3069	int modepage;
3070	int first_len;
3071	struct scsi_mode_data data;
3072	struct scsi_sense_hdr sshdr;
3073	int old_wce = sdkp->WCE;
3074	int old_rcd = sdkp->RCD;
3075	int old_dpofua = sdkp->DPOFUA;
3076
3077
3078	if (sdkp->cache_override)
3079		return;
3080
3081	first_len = 4;
3082	if (sdp->skip_ms_page_8) {
3083		if (sdp->type == TYPE_RBC)
3084			goto defaults;
3085		else {
3086			if (sdp->skip_ms_page_3f)
3087				goto defaults;
3088			modepage = 0x3F;
3089			if (sdp->use_192_bytes_for_3f)
3090				first_len = 192;
3091			dbd = 0;
3092		}
3093	} else if (sdp->type == TYPE_RBC) {
3094		modepage = 6;
3095		dbd = 8;
3096	} else {
3097		modepage = 8;
3098		dbd = 0;
3099	}
3100
3101	/* cautiously ask */
3102	res = sd_do_mode_sense(sdkp, dbd, modepage, buffer, first_len,
3103			&data, &sshdr);
3104
3105	if (res < 0)
3106		goto bad_sense;
3107
3108	if (!data.header_length) {
3109		modepage = 6;
3110		first_len = 0;
3111		sd_first_printk(KERN_ERR, sdkp,
3112				"Missing header in MODE_SENSE response\n");
3113	}
3114
3115	/* that went OK, now ask for the proper length */
3116	len = data.length;
3117
3118	/*
3119	 * We're only interested in the first three bytes, actually.
3120	 * But the data cache page is defined for the first 20.
3121	 */
3122	if (len < 3)
3123		goto bad_sense;
3124	else if (len > SD_BUF_SIZE) {
3125		sd_first_printk(KERN_NOTICE, sdkp, "Truncating mode parameter "
3126			  "data from %d to %d bytes\n", len, SD_BUF_SIZE);
3127		len = SD_BUF_SIZE;
3128	}
3129	if (modepage == 0x3F && sdp->use_192_bytes_for_3f)
3130		len = 192;
3131
3132	/* Get the data */
3133	if (len > first_len)
3134		res = sd_do_mode_sense(sdkp, dbd, modepage, buffer, len,
3135				&data, &sshdr);
3136
3137	if (!res) {
3138		int offset = data.header_length + data.block_descriptor_length;
3139
3140		while (offset < len) {
3141			u8 page_code = buffer[offset] & 0x3F;
3142			u8 spf       = buffer[offset] & 0x40;
3143
3144			if (page_code == 8 || page_code == 6) {
3145				/* We're interested only in the first 3 bytes.
3146				 */
3147				if (len - offset <= 2) {
3148					sd_first_printk(KERN_ERR, sdkp,
3149						"Incomplete mode parameter "
3150							"data\n");
3151					goto defaults;
3152				} else {
3153					modepage = page_code;
3154					goto Page_found;
3155				}
3156			} else {
3157				/* Go to the next page */
3158				if (spf && len - offset > 3)
3159					offset += 4 + (buffer[offset+2] << 8) +
3160						buffer[offset+3];
3161				else if (!spf && len - offset > 1)
3162					offset += 2 + buffer[offset+1];
3163				else {
3164					sd_first_printk(KERN_ERR, sdkp,
3165							"Incomplete mode "
3166							"parameter data\n");
3167					goto defaults;
3168				}
3169			}
3170		}
3171
3172		sd_first_printk(KERN_WARNING, sdkp,
3173				"No Caching mode page found\n");
3174		goto defaults;
3175
3176	Page_found:
3177		if (modepage == 8) {
3178			sdkp->WCE = ((buffer[offset + 2] & 0x04) != 0);
3179			sdkp->RCD = ((buffer[offset + 2] & 0x01) != 0);
3180		} else {
3181			sdkp->WCE = ((buffer[offset + 2] & 0x01) == 0);
3182			sdkp->RCD = 0;
3183		}
3184
3185		sdkp->DPOFUA = (data.device_specific & 0x10) != 0;
3186		if (sdp->broken_fua) {
3187			sd_first_printk(KERN_NOTICE, sdkp, "Disabling FUA\n");
3188			sdkp->DPOFUA = 0;
3189		} else if (sdkp->DPOFUA && !sdkp->device->use_10_for_rw &&
3190			   !sdkp->device->use_16_for_rw) {
3191			sd_first_printk(KERN_NOTICE, sdkp,
3192				  "Uses READ/WRITE(6), disabling FUA\n");
3193			sdkp->DPOFUA = 0;
3194		}
3195
3196		/* No cache flush allowed for write protected devices */
3197		if (sdkp->WCE && sdkp->write_prot)
3198			sdkp->WCE = 0;
3199
3200		if (sdkp->first_scan || old_wce != sdkp->WCE ||
3201		    old_rcd != sdkp->RCD || old_dpofua != sdkp->DPOFUA)
3202			sd_printk(KERN_NOTICE, sdkp,
3203				  "Write cache: %s, read cache: %s, %s\n",
3204				  sdkp->WCE ? "enabled" : "disabled",
3205				  sdkp->RCD ? "disabled" : "enabled",
3206				  sdkp->DPOFUA ? "supports DPO and FUA"
3207				  : "doesn't support DPO or FUA");
3208
3209		return;
3210	}
3211
3212bad_sense:
3213	if (res == -EIO && scsi_sense_valid(&sshdr) &&
3214	    sshdr.sense_key == ILLEGAL_REQUEST &&
3215	    sshdr.asc == 0x24 && sshdr.ascq == 0x0)
3216		/* Invalid field in CDB */
3217		sd_first_printk(KERN_NOTICE, sdkp, "Cache data unavailable\n");
3218	else
3219		sd_first_printk(KERN_ERR, sdkp,
3220				"Asking for cache data failed\n");
3221
3222defaults:
3223	if (sdp->wce_default_on) {
3224		sd_first_printk(KERN_NOTICE, sdkp,
3225				"Assuming drive cache: write back\n");
3226		sdkp->WCE = 1;
3227	} else {
3228		sd_first_printk(KERN_WARNING, sdkp,
3229				"Assuming drive cache: write through\n");
3230		sdkp->WCE = 0;
3231	}
3232	sdkp->RCD = 0;
3233	sdkp->DPOFUA = 0;
3234}
3235
3236static bool sd_is_perm_stream(struct scsi_disk *sdkp, unsigned int stream_id)
3237{
3238	u8 cdb[16] = { SERVICE_ACTION_IN_16, SAI_GET_STREAM_STATUS };
3239	struct {
3240		struct scsi_stream_status_header h;
3241		struct scsi_stream_status s;
3242	} buf;
3243	struct scsi_device *sdev = sdkp->device;
3244	struct scsi_sense_hdr sshdr;
3245	const struct scsi_exec_args exec_args = {
3246		.sshdr = &sshdr,
3247	};
3248	int res;
3249
3250	put_unaligned_be16(stream_id, &cdb[4]);
3251	put_unaligned_be32(sizeof(buf), &cdb[10]);
3252
3253	res = scsi_execute_cmd(sdev, cdb, REQ_OP_DRV_IN, &buf, sizeof(buf),
3254			       SD_TIMEOUT, sdkp->max_retries, &exec_args);
3255	if (res < 0)
3256		return false;
3257	if (scsi_status_is_check_condition(res) && scsi_sense_valid(&sshdr))
3258		sd_print_sense_hdr(sdkp, &sshdr);
3259	if (res)
3260		return false;
3261	if (get_unaligned_be32(&buf.h.len) < sizeof(struct scsi_stream_status))
3262		return false;
3263	return buf.s.perm;
3264}
3265
3266static void sd_read_io_hints(struct scsi_disk *sdkp, unsigned char *buffer)
3267{
3268	struct scsi_device *sdp = sdkp->device;
3269	const struct scsi_io_group_descriptor *desc, *start, *end;
3270	u16 permanent_stream_count_old;
3271	struct scsi_sense_hdr sshdr;
3272	struct scsi_mode_data data;
3273	int res;
3274
3275	if (sdp->sdev_bflags & BLIST_SKIP_IO_HINTS)
3276		return;
3277
3278	res = scsi_mode_sense(sdp, /*dbd=*/0x8, /*modepage=*/0x0a,
3279			      /*subpage=*/0x05, buffer, SD_BUF_SIZE, SD_TIMEOUT,
3280			      sdkp->max_retries, &data, &sshdr);
3281	if (res < 0)
3282		return;
3283	start = (void *)buffer + data.header_length + 16;
3284	end = (void *)buffer + ALIGN_DOWN(data.header_length + data.length,
3285					  sizeof(*end));
3286	/*
3287	 * From "SBC-5 Constrained Streams with Data Lifetimes": Device severs
3288	 * should assign the lowest numbered stream identifiers to permanent
3289	 * streams.
3290	 */
3291	for (desc = start; desc < end; desc++)
3292		if (!desc->st_enble || !sd_is_perm_stream(sdkp, desc - start))
3293			break;
3294	permanent_stream_count_old = sdkp->permanent_stream_count;
3295	sdkp->permanent_stream_count = desc - start;
3296	if (sdkp->rscs && sdkp->permanent_stream_count < 2)
3297		sd_printk(KERN_INFO, sdkp,
3298			  "Unexpected: RSCS has been set and the permanent stream count is %u\n",
3299			  sdkp->permanent_stream_count);
3300	else if (sdkp->permanent_stream_count != permanent_stream_count_old)
3301		sd_printk(KERN_INFO, sdkp, "permanent stream count = %d\n",
3302			  sdkp->permanent_stream_count);
3303}
3304
3305/*
3306 * The ATO bit indicates whether the DIF application tag is available
3307 * for use by the operating system.
3308 */
3309static void sd_read_app_tag_own(struct scsi_disk *sdkp, unsigned char *buffer)
3310{
3311	int res, offset;
3312	struct scsi_device *sdp = sdkp->device;
3313	struct scsi_mode_data data;
3314	struct scsi_sense_hdr sshdr;
3315
3316	if (sdp->type != TYPE_DISK && sdp->type != TYPE_ZBC)
3317		return;
3318
3319	if (sdkp->protection_type == 0)
3320		return;
3321
3322	res = scsi_mode_sense(sdp, 1, 0x0a, 0, buffer, 36, SD_TIMEOUT,
3323			      sdkp->max_retries, &data, &sshdr);
3324
3325	if (res < 0 || !data.header_length ||
3326	    data.length < 6) {
3327		sd_first_printk(KERN_WARNING, sdkp,
3328			  "getting Control mode page failed, assume no ATO\n");
3329
3330		if (res == -EIO && scsi_sense_valid(&sshdr))
3331			sd_print_sense_hdr(sdkp, &sshdr);
3332
3333		return;
3334	}
3335
3336	offset = data.header_length + data.block_descriptor_length;
3337
3338	if ((buffer[offset] & 0x3f) != 0x0a) {
3339		sd_first_printk(KERN_ERR, sdkp, "ATO Got wrong page\n");
3340		return;
3341	}
3342
3343	if ((buffer[offset + 5] & 0x80) == 0)
3344		return;
3345
3346	sdkp->ATO = 1;
3347
3348	return;
3349}
3350
3351static unsigned int sd_discard_mode(struct scsi_disk *sdkp)
3352{
3353	if (!sdkp->lbpme)
3354		return SD_LBP_FULL;
3355
3356	if (!sdkp->lbpvpd) {
3357		/* LBP VPD page not provided */
3358		if (sdkp->max_unmap_blocks)
3359			return SD_LBP_UNMAP;
3360		return SD_LBP_WS16;
3361	}
3362
3363	/* LBP VPD page tells us what to use */
3364	if (sdkp->lbpu && sdkp->max_unmap_blocks)
3365		return SD_LBP_UNMAP;
3366	if (sdkp->lbpws)
3367		return SD_LBP_WS16;
3368	if (sdkp->lbpws10)
3369		return SD_LBP_WS10;
3370	return SD_LBP_DISABLE;
3371}
3372
3373/*
3374 * Query disk device for preferred I/O sizes.
3375 */
3376static void sd_read_block_limits(struct scsi_disk *sdkp,
3377		struct queue_limits *lim)
3378{
3379	struct scsi_vpd *vpd;
3380
3381	rcu_read_lock();
3382
3383	vpd = rcu_dereference(sdkp->device->vpd_pgb0);
3384	if (!vpd || vpd->len < 16)
3385		goto out;
3386
3387	sdkp->min_xfer_blocks = get_unaligned_be16(&vpd->data[6]);
3388	sdkp->max_xfer_blocks = get_unaligned_be32(&vpd->data[8]);
3389	sdkp->opt_xfer_blocks = get_unaligned_be32(&vpd->data[12]);
3390
3391	if (vpd->len >= 64) {
3392		unsigned int lba_count, desc_count;
3393
3394		sdkp->max_ws_blocks = (u32)get_unaligned_be64(&vpd->data[36]);
3395
3396		if (!sdkp->lbpme)
3397			goto config_atomic;
3398
3399		lba_count = get_unaligned_be32(&vpd->data[20]);
3400		desc_count = get_unaligned_be32(&vpd->data[24]);
3401
3402		if (lba_count && desc_count)
3403			sdkp->max_unmap_blocks = lba_count;
3404
3405		sdkp->unmap_granularity = get_unaligned_be32(&vpd->data[28]);
3406
3407		if (vpd->data[32] & 0x80)
3408			sdkp->unmap_alignment =
3409				get_unaligned_be32(&vpd->data[32]) & ~(1 << 31);
3410
3411config_atomic:
3412		sdkp->max_atomic = get_unaligned_be32(&vpd->data[44]);
3413		sdkp->atomic_alignment = get_unaligned_be32(&vpd->data[48]);
3414		sdkp->atomic_granularity = get_unaligned_be32(&vpd->data[52]);
3415		sdkp->max_atomic_with_boundary = get_unaligned_be32(&vpd->data[56]);
3416		sdkp->max_atomic_boundary = get_unaligned_be32(&vpd->data[60]);
3417
3418		sd_config_atomic(sdkp, lim);
3419	}
3420
3421 out:
3422	rcu_read_unlock();
3423}
3424
3425/* Parse the Block Limits Extension VPD page (0xb7) */
3426static void sd_read_block_limits_ext(struct scsi_disk *sdkp)
3427{
3428	struct scsi_vpd *vpd;
3429
3430	rcu_read_lock();
3431	vpd = rcu_dereference(sdkp->device->vpd_pgb7);
3432	if (vpd && vpd->len >= 6)
3433		sdkp->rscs = vpd->data[5] & 1;
3434	rcu_read_unlock();
3435}
3436
3437/* Query block device characteristics */
3438static void sd_read_block_characteristics(struct scsi_disk *sdkp,
3439		struct queue_limits *lim)
3440{
3441	struct scsi_vpd *vpd;
3442	u16 rot;
3443
3444	rcu_read_lock();
3445	vpd = rcu_dereference(sdkp->device->vpd_pgb1);
3446
3447	if (!vpd || vpd->len <= 8) {
3448		rcu_read_unlock();
3449	        return;
3450	}
3451
3452	rot = get_unaligned_be16(&vpd->data[4]);
3453	sdkp->zoned = (vpd->data[8] >> 4) & 3;
3454	rcu_read_unlock();
3455
3456	if (rot == 1)
3457		lim->features &= ~(BLK_FEAT_ROTATIONAL | BLK_FEAT_ADD_RANDOM);
3458
3459	if (!sdkp->first_scan)
3460		return;
3461
3462	if (sdkp->device->type == TYPE_ZBC)
3463		sd_printk(KERN_NOTICE, sdkp, "Host-managed zoned block device\n");
3464	else if (sdkp->zoned == 1)
3465		sd_printk(KERN_NOTICE, sdkp, "Host-aware SMR disk used as regular disk\n");
3466	else if (sdkp->zoned == 2)
3467		sd_printk(KERN_NOTICE, sdkp, "Drive-managed SMR disk\n");
3468}
3469
3470/**
3471 * sd_read_block_provisioning - Query provisioning VPD page
3472 * @sdkp: disk to query
3473 */
3474static void sd_read_block_provisioning(struct scsi_disk *sdkp)
3475{
3476	struct scsi_vpd *vpd;
3477
3478	if (sdkp->lbpme == 0)
3479		return;
3480
3481	rcu_read_lock();
3482	vpd = rcu_dereference(sdkp->device->vpd_pgb2);
3483
3484	if (!vpd || vpd->len < 8) {
3485		rcu_read_unlock();
3486		return;
3487	}
3488
3489	sdkp->lbpvpd	= 1;
3490	sdkp->lbpu	= (vpd->data[5] >> 7) & 1; /* UNMAP */
3491	sdkp->lbpws	= (vpd->data[5] >> 6) & 1; /* WRITE SAME(16) w/ UNMAP */
3492	sdkp->lbpws10	= (vpd->data[5] >> 5) & 1; /* WRITE SAME(10) w/ UNMAP */
3493	rcu_read_unlock();
3494}
3495
3496static void sd_read_write_same(struct scsi_disk *sdkp, unsigned char *buffer)
3497{
3498	struct scsi_device *sdev = sdkp->device;
3499
3500	if (sdev->host->no_write_same) {
3501		sdev->no_write_same = 1;
3502
3503		return;
3504	}
3505
3506	if (scsi_report_opcode(sdev, buffer, SD_BUF_SIZE, INQUIRY, 0) < 0) {
3507		sdev->no_report_opcodes = 1;
3508
3509		/*
3510		 * Disable WRITE SAME if REPORT SUPPORTED OPERATION CODES is
3511		 * unsupported and this is an ATA device.
3512		 */
3513		if (sdev->is_ata)
3514			sdev->no_write_same = 1;
3515	}
3516
3517	if (scsi_report_opcode(sdev, buffer, SD_BUF_SIZE, WRITE_SAME_16, 0) == 1)
3518		sdkp->ws16 = 1;
3519
3520	if (scsi_report_opcode(sdev, buffer, SD_BUF_SIZE, WRITE_SAME, 0) == 1)
3521		sdkp->ws10 = 1;
3522}
3523
3524static void sd_read_security(struct scsi_disk *sdkp, unsigned char *buffer)
3525{
3526	struct scsi_device *sdev = sdkp->device;
3527
3528	if (!sdev->security_supported)
3529		return;
3530
3531	if (scsi_report_opcode(sdev, buffer, SD_BUF_SIZE,
3532			SECURITY_PROTOCOL_IN, 0) == 1 &&
3533	    scsi_report_opcode(sdev, buffer, SD_BUF_SIZE,
3534			SECURITY_PROTOCOL_OUT, 0) == 1)
3535		sdkp->security = 1;
3536}
3537
3538static inline sector_t sd64_to_sectors(struct scsi_disk *sdkp, u8 *buf)
3539{
3540	return logical_to_sectors(sdkp->device, get_unaligned_be64(buf));
3541}
3542
3543/**
3544 * sd_read_cpr - Query concurrent positioning ranges
3545 * @sdkp:	disk to query
3546 */
3547static void sd_read_cpr(struct scsi_disk *sdkp)
3548{
3549	struct blk_independent_access_ranges *iars = NULL;
3550	unsigned char *buffer = NULL;
3551	unsigned int nr_cpr = 0;
3552	int i, vpd_len, buf_len = SD_BUF_SIZE;
3553	u8 *desc;
3554
3555	/*
3556	 * We need to have the capacity set first for the block layer to be
3557	 * able to check the ranges.
3558	 */
3559	if (sdkp->first_scan)
3560		return;
3561
3562	if (!sdkp->capacity)
3563		goto out;
3564
3565	/*
3566	 * Concurrent Positioning Ranges VPD: there can be at most 256 ranges,
3567	 * leading to a maximum page size of 64 + 256*32 bytes.
3568	 */
3569	buf_len = 64 + 256*32;
3570	buffer = kmalloc(buf_len, GFP_KERNEL);
3571	if (!buffer || scsi_get_vpd_page(sdkp->device, 0xb9, buffer, buf_len))
3572		goto out;
3573
3574	/* We must have at least a 64B header and one 32B range descriptor */
3575	vpd_len = get_unaligned_be16(&buffer[2]) + 4;
3576	if (vpd_len > buf_len || vpd_len < 64 + 32 || (vpd_len & 31)) {
3577		sd_printk(KERN_ERR, sdkp,
3578			  "Invalid Concurrent Positioning Ranges VPD page\n");
3579		goto out;
3580	}
3581
3582	nr_cpr = (vpd_len - 64) / 32;
3583	if (nr_cpr == 1) {
3584		nr_cpr = 0;
3585		goto out;
3586	}
3587
3588	iars = disk_alloc_independent_access_ranges(sdkp->disk, nr_cpr);
3589	if (!iars) {
3590		nr_cpr = 0;
3591		goto out;
3592	}
3593
3594	desc = &buffer[64];
3595	for (i = 0; i < nr_cpr; i++, desc += 32) {
3596		if (desc[0] != i) {
3597			sd_printk(KERN_ERR, sdkp,
3598				"Invalid Concurrent Positioning Range number\n");
3599			nr_cpr = 0;
3600			break;
3601		}
3602
3603		iars->ia_range[i].sector = sd64_to_sectors(sdkp, desc + 8);
3604		iars->ia_range[i].nr_sectors = sd64_to_sectors(sdkp, desc + 16);
3605	}
3606
3607out:
3608	disk_set_independent_access_ranges(sdkp->disk, iars);
3609	if (nr_cpr && sdkp->nr_actuators != nr_cpr) {
3610		sd_printk(KERN_NOTICE, sdkp,
3611			  "%u concurrent positioning ranges\n", nr_cpr);
3612		sdkp->nr_actuators = nr_cpr;
3613	}
3614
3615	kfree(buffer);
3616}
3617
3618static bool sd_validate_min_xfer_size(struct scsi_disk *sdkp)
3619{
3620	struct scsi_device *sdp = sdkp->device;
3621	unsigned int min_xfer_bytes =
3622		logical_to_bytes(sdp, sdkp->min_xfer_blocks);
3623
3624	if (sdkp->min_xfer_blocks == 0)
3625		return false;
3626
3627	if (min_xfer_bytes & (sdkp->physical_block_size - 1)) {
3628		sd_first_printk(KERN_WARNING, sdkp,
3629				"Preferred minimum I/O size %u bytes not a " \
3630				"multiple of physical block size (%u bytes)\n",
3631				min_xfer_bytes, sdkp->physical_block_size);
3632		sdkp->min_xfer_blocks = 0;
3633		return false;
3634	}
3635
3636	sd_first_printk(KERN_INFO, sdkp, "Preferred minimum I/O size %u bytes\n",
3637			min_xfer_bytes);
3638	return true;
3639}
3640
3641/*
3642 * Determine the device's preferred I/O size for reads and writes
3643 * unless the reported value is unreasonably small, large, not a
3644 * multiple of the physical block size, or simply garbage.
3645 */
3646static bool sd_validate_opt_xfer_size(struct scsi_disk *sdkp,
3647				      unsigned int dev_max)
3648{
3649	struct scsi_device *sdp = sdkp->device;
3650	unsigned int opt_xfer_bytes =
3651		logical_to_bytes(sdp, sdkp->opt_xfer_blocks);
3652	unsigned int min_xfer_bytes =
3653		logical_to_bytes(sdp, sdkp->min_xfer_blocks);
3654
3655	if (sdkp->opt_xfer_blocks == 0)
3656		return false;
3657
3658	if (sdkp->opt_xfer_blocks > dev_max) {
3659		sd_first_printk(KERN_WARNING, sdkp,
3660				"Optimal transfer size %u logical blocks " \
3661				"> dev_max (%u logical blocks)\n",
3662				sdkp->opt_xfer_blocks, dev_max);
3663		return false;
3664	}
3665
3666	if (sdkp->opt_xfer_blocks > SD_DEF_XFER_BLOCKS) {
3667		sd_first_printk(KERN_WARNING, sdkp,
3668				"Optimal transfer size %u logical blocks " \
3669				"> sd driver limit (%u logical blocks)\n",
3670				sdkp->opt_xfer_blocks, SD_DEF_XFER_BLOCKS);
3671		return false;
3672	}
3673
3674	if (opt_xfer_bytes < PAGE_SIZE) {
3675		sd_first_printk(KERN_WARNING, sdkp,
3676				"Optimal transfer size %u bytes < " \
3677				"PAGE_SIZE (%u bytes)\n",
3678				opt_xfer_bytes, (unsigned int)PAGE_SIZE);
3679		return false;
3680	}
3681
3682	if (min_xfer_bytes && opt_xfer_bytes % min_xfer_bytes) {
3683		sd_first_printk(KERN_WARNING, sdkp,
3684				"Optimal transfer size %u bytes not a " \
3685				"multiple of preferred minimum block " \
3686				"size (%u bytes)\n",
3687				opt_xfer_bytes, min_xfer_bytes);
3688		return false;
3689	}
3690
3691	if (opt_xfer_bytes & (sdkp->physical_block_size - 1)) {
3692		sd_first_printk(KERN_WARNING, sdkp,
3693				"Optimal transfer size %u bytes not a " \
3694				"multiple of physical block size (%u bytes)\n",
3695				opt_xfer_bytes, sdkp->physical_block_size);
3696		return false;
3697	}
3698
3699	sd_first_printk(KERN_INFO, sdkp, "Optimal transfer size %u bytes\n",
3700			opt_xfer_bytes);
3701	return true;
3702}
3703
3704static void sd_read_block_zero(struct scsi_disk *sdkp)
3705{
3706	struct scsi_device *sdev = sdkp->device;
3707	unsigned int buf_len = sdev->sector_size;
3708	u8 *buffer, cmd[16] = { };
3709
3710	buffer = kmalloc(buf_len, GFP_KERNEL);
3711	if (!buffer)
3712		return;
3713
3714	if (sdev->use_16_for_rw) {
3715		cmd[0] = READ_16;
3716		put_unaligned_be64(0, &cmd[2]); /* Logical block address 0 */
3717		put_unaligned_be32(1, &cmd[10]);/* Transfer 1 logical block */
3718	} else {
3719		cmd[0] = READ_10;
3720		put_unaligned_be32(0, &cmd[2]); /* Logical block address 0 */
3721		put_unaligned_be16(1, &cmd[7]);	/* Transfer 1 logical block */
3722	}
3723
3724	scsi_execute_cmd(sdkp->device, cmd, REQ_OP_DRV_IN, buffer, buf_len,
3725			 SD_TIMEOUT, sdkp->max_retries, NULL);
3726	kfree(buffer);
3727}
3728
3729/**
3730 *	sd_revalidate_disk - called the first time a new disk is seen,
3731 *	performs disk spin up, read_capacity, etc.
3732 *	@disk: struct gendisk we care about
3733 **/
3734static void sd_revalidate_disk(struct gendisk *disk)
3735{
3736	struct scsi_disk *sdkp = scsi_disk(disk);
3737	struct scsi_device *sdp = sdkp->device;
3738	sector_t old_capacity = sdkp->capacity;
3739	struct queue_limits *lim = NULL;
3740	unsigned char *buffer = NULL;
3741	unsigned int dev_max;
3742	int err;
3743
3744	SCSI_LOG_HLQUEUE(3, sd_printk(KERN_INFO, sdkp,
3745				      "sd_revalidate_disk\n"));
3746
3747	/*
3748	 * If the device is offline, don't try and read capacity or any
3749	 * of the other niceties.
3750	 */
3751	if (!scsi_device_online(sdp))
3752		return;
3753
3754	lim = kmalloc(sizeof(*lim), GFP_KERNEL);
3755	if (!lim)
3756		return;
3757
3758	buffer = kmalloc(SD_BUF_SIZE, GFP_KERNEL);
3759	if (!buffer)
3760		goto out;
3761
3762	sd_spinup_disk(sdkp);
3763
3764	*lim = queue_limits_start_update(sdkp->disk->queue);
3765
3766	/*
3767	 * Without media there is no reason to ask; moreover, some devices
3768	 * react badly if we do.
3769	 */
3770	if (sdkp->media_present) {
3771		sd_read_capacity(sdkp, lim, buffer);
3772		/*
3773		 * Some USB/UAS devices return generic values for mode pages
3774		 * until the media has been accessed. Trigger a READ operation
3775		 * to force the device to populate mode pages.
3776		 */
3777		if (sdp->read_before_ms)
3778			sd_read_block_zero(sdkp);
3779		/*
3780		 * set the default to rotational.  All non-rotational devices
3781		 * support the block characteristics VPD page, which will
3782		 * cause this to be updated correctly and any device which
3783		 * doesn't support it should be treated as rotational.
3784		 */
3785		lim->features |= (BLK_FEAT_ROTATIONAL | BLK_FEAT_ADD_RANDOM);
3786
3787		if (scsi_device_supports_vpd(sdp)) {
3788			sd_read_block_provisioning(sdkp);
3789			sd_read_block_limits(sdkp, lim);
3790			sd_read_block_limits_ext(sdkp);
3791			sd_read_block_characteristics(sdkp, lim);
3792			sd_zbc_read_zones(sdkp, lim, buffer);
3793		}
3794
3795		sd_config_discard(sdkp, lim, sd_discard_mode(sdkp));
3796
3797		sd_print_capacity(sdkp, old_capacity);
3798
3799		sd_read_write_protect_flag(sdkp, buffer);
3800		sd_read_cache_type(sdkp, buffer);
3801		sd_read_io_hints(sdkp, buffer);
3802		sd_read_app_tag_own(sdkp, buffer);
3803		sd_read_write_same(sdkp, buffer);
3804		sd_read_security(sdkp, buffer);
3805		sd_config_protection(sdkp, lim);
3806	}
3807
3808	/*
3809	 * We now have all cache related info, determine how we deal
3810	 * with flush requests.
3811	 */
3812	sd_set_flush_flag(sdkp, lim);
3813
3814	/* Initial block count limit based on CDB TRANSFER LENGTH field size. */
3815	dev_max = sdp->use_16_for_rw ? SD_MAX_XFER_BLOCKS : SD_DEF_XFER_BLOCKS;
3816
3817	/* Some devices report a maximum block count for READ/WRITE requests. */
3818	dev_max = min_not_zero(dev_max, sdkp->max_xfer_blocks);
3819	lim->max_dev_sectors = logical_to_sectors(sdp, dev_max);
3820
3821	if (sd_validate_min_xfer_size(sdkp))
3822		lim->io_min = logical_to_bytes(sdp, sdkp->min_xfer_blocks);
3823	else
3824		lim->io_min = 0;
3825
3826	/*
3827	 * Limit default to SCSI host optimal sector limit if set. There may be
3828	 * an impact on performance for when the size of a request exceeds this
3829	 * host limit.
3830	 */
3831	lim->io_opt = sdp->host->opt_sectors << SECTOR_SHIFT;
3832	if (sd_validate_opt_xfer_size(sdkp, dev_max)) {
3833		lim->io_opt = min_not_zero(lim->io_opt,
3834				logical_to_bytes(sdp, sdkp->opt_xfer_blocks));
3835	}
3836
3837	sdkp->first_scan = 0;
3838
3839	set_capacity_and_notify(disk, logical_to_sectors(sdp, sdkp->capacity));
3840	sd_config_write_same(sdkp, lim);
3841
3842	err = queue_limits_commit_update_frozen(sdkp->disk->queue, lim);
3843	if (err)
3844		goto out;
3845
3846	/*
3847	 * Query concurrent positioning ranges after
3848	 * queue_limits_commit_update() unlocked q->limits_lock to avoid
3849	 * deadlock with q->sysfs_dir_lock and q->sysfs_lock.
3850	 */
3851	if (sdkp->media_present && scsi_device_supports_vpd(sdp))
3852		sd_read_cpr(sdkp);
3853
3854	/*
3855	 * For a zoned drive, revalidating the zones can be done only once
3856	 * the gendisk capacity is set. So if this fails, set back the gendisk
3857	 * capacity to 0.
3858	 */
3859	if (sd_zbc_revalidate_zones(sdkp))
3860		set_capacity_and_notify(disk, 0);
3861
3862 out:
3863	kfree(buffer);
3864	kfree(lim);
3865
3866}
3867
3868/**
3869 *	sd_unlock_native_capacity - unlock native capacity
3870 *	@disk: struct gendisk to set capacity for
3871 *
3872 *	Block layer calls this function if it detects that partitions
3873 *	on @disk reach beyond the end of the device.  If the SCSI host
3874 *	implements ->unlock_native_capacity() method, it's invoked to
3875 *	give it a chance to adjust the device capacity.
3876 *
3877 *	CONTEXT:
3878 *	Defined by block layer.  Might sleep.
3879 */
3880static void sd_unlock_native_capacity(struct gendisk *disk)
3881{
3882	struct scsi_device *sdev = scsi_disk(disk)->device;
3883
3884	if (sdev->host->hostt->unlock_native_capacity)
3885		sdev->host->hostt->unlock_native_capacity(sdev);
3886}
3887
3888/**
3889 *	sd_format_disk_name - format disk name
3890 *	@prefix: name prefix - ie. "sd" for SCSI disks
3891 *	@index: index of the disk to format name for
3892 *	@buf: output buffer
3893 *	@buflen: length of the output buffer
3894 *
3895 *	SCSI disk names starts at sda.  The 26th device is sdz and the
3896 *	27th is sdaa.  The last one for two lettered suffix is sdzz
3897 *	which is followed by sdaaa.
3898 *
3899 *	This is basically 26 base counting with one extra 'nil' entry
3900 *	at the beginning from the second digit on and can be
3901 *	determined using similar method as 26 base conversion with the
3902 *	index shifted -1 after each digit is computed.
3903 *
3904 *	CONTEXT:
3905 *	Don't care.
3906 *
3907 *	RETURNS:
3908 *	0 on success, -errno on failure.
3909 */
3910static int sd_format_disk_name(char *prefix, int index, char *buf, int buflen)
3911{
3912	const int base = 'z' - 'a' + 1;
3913	char *begin = buf + strlen(prefix);
3914	char *end = buf + buflen;
3915	char *p;
3916	int unit;
3917
3918	p = end - 1;
3919	*p = '\0';
3920	unit = base;
3921	do {
3922		if (p == begin)
3923			return -EINVAL;
3924		*--p = 'a' + (index % unit);
3925		index = (index / unit) - 1;
3926	} while (index >= 0);
3927
3928	memmove(begin, p, end - p);
3929	memcpy(buf, prefix, strlen(prefix));
3930
3931	return 0;
3932}
3933
3934/**
3935 *	sd_probe - called during driver initialization and whenever a
3936 *	new scsi device is attached to the system. It is called once
3937 *	for each scsi device (not just disks) present.
3938 *	@dev: pointer to device object
3939 *
3940 *	Returns 0 if successful (or not interested in this scsi device 
3941 *	(e.g. scanner)); 1 when there is an error.
3942 *
3943 *	Note: this function is invoked from the scsi mid-level.
3944 *	This function sets up the mapping between a given 
3945 *	<host,channel,id,lun> (found in sdp) and new device name 
3946 *	(e.g. /dev/sda). More precisely it is the block device major 
3947 *	and minor number that is chosen here.
3948 *
3949 *	Assume sd_probe is not re-entrant (for time being)
3950 *	Also think about sd_probe() and sd_remove() running coincidentally.
3951 **/
3952static int sd_probe(struct device *dev)
3953{
3954	struct scsi_device *sdp = to_scsi_device(dev);
3955	struct scsi_disk *sdkp;
3956	struct gendisk *gd;
3957	int index;
3958	int error;
3959
3960	scsi_autopm_get_device(sdp);
3961	error = -ENODEV;
3962	if (sdp->type != TYPE_DISK &&
3963	    sdp->type != TYPE_ZBC &&
3964	    sdp->type != TYPE_MOD &&
3965	    sdp->type != TYPE_RBC)
3966		goto out;
3967
3968	if (!IS_ENABLED(CONFIG_BLK_DEV_ZONED) && sdp->type == TYPE_ZBC) {
3969		sdev_printk(KERN_WARNING, sdp,
3970			    "Unsupported ZBC host-managed device.\n");
3971		goto out;
3972	}
3973
3974	SCSI_LOG_HLQUEUE(3, sdev_printk(KERN_INFO, sdp,
3975					"sd_probe\n"));
3976
3977	error = -ENOMEM;
3978	sdkp = kzalloc(sizeof(*sdkp), GFP_KERNEL);
3979	if (!sdkp)
3980		goto out;
3981
3982	gd = blk_mq_alloc_disk_for_queue(sdp->request_queue,
3983					 &sd_bio_compl_lkclass);
3984	if (!gd)
3985		goto out_free;
3986
3987	index = ida_alloc(&sd_index_ida, GFP_KERNEL);
3988	if (index < 0) {
3989		sdev_printk(KERN_WARNING, sdp, "sd_probe: memory exhausted.\n");
3990		goto out_put;
3991	}
3992
3993	error = sd_format_disk_name("sd", index, gd->disk_name, DISK_NAME_LEN);
3994	if (error) {
3995		sdev_printk(KERN_WARNING, sdp, "SCSI disk (sd) name length exceeded.\n");
3996		goto out_free_index;
3997	}
3998
3999	sdkp->device = sdp;
4000	sdkp->disk = gd;
4001	sdkp->index = index;
4002	sdkp->max_retries = SD_MAX_RETRIES;
4003	atomic_set(&sdkp->openers, 0);
4004	atomic_set(&sdkp->device->ioerr_cnt, 0);
4005
4006	if (!sdp->request_queue->rq_timeout) {
4007		if (sdp->type != TYPE_MOD)
4008			blk_queue_rq_timeout(sdp->request_queue, SD_TIMEOUT);
4009		else
4010			blk_queue_rq_timeout(sdp->request_queue,
4011					     SD_MOD_TIMEOUT);
4012	}
4013
4014	device_initialize(&sdkp->disk_dev);
4015	sdkp->disk_dev.parent = get_device(dev);
4016	sdkp->disk_dev.class = &sd_disk_class;
4017	dev_set_name(&sdkp->disk_dev, "%s", dev_name(dev));
4018
4019	error = device_add(&sdkp->disk_dev);
4020	if (error) {
4021		put_device(&sdkp->disk_dev);
4022		goto out;
4023	}
4024
4025	dev_set_drvdata(dev, sdkp);
4026
4027	gd->major = sd_major((index & 0xf0) >> 4);
4028	gd->first_minor = ((index & 0xf) << 4) | (index & 0xfff00);
4029	gd->minors = SD_MINORS;
4030
4031	gd->fops = &sd_fops;
4032	gd->private_data = sdkp;
4033
4034	/* defaults, until the device tells us otherwise */
4035	sdp->sector_size = 512;
4036	sdkp->capacity = 0;
4037	sdkp->media_present = 1;
4038	sdkp->write_prot = 0;
4039	sdkp->cache_override = 0;
4040	sdkp->WCE = 0;
4041	sdkp->RCD = 0;
4042	sdkp->ATO = 0;
4043	sdkp->first_scan = 1;
4044	sdkp->max_medium_access_timeouts = SD_MAX_MEDIUM_TIMEOUTS;
4045
4046	sd_revalidate_disk(gd);
4047
4048	if (sdp->removable) {
4049		gd->flags |= GENHD_FL_REMOVABLE;
4050		gd->events |= DISK_EVENT_MEDIA_CHANGE;
4051		gd->event_flags = DISK_EVENT_FLAG_POLL | DISK_EVENT_FLAG_UEVENT;
4052	}
4053
4054	blk_pm_runtime_init(sdp->request_queue, dev);
4055	if (sdp->rpm_autosuspend) {
4056		pm_runtime_set_autosuspend_delay(dev,
4057			sdp->host->rpm_autosuspend_delay);
4058	}
4059
4060	error = device_add_disk(dev, gd, NULL);
4061	if (error) {
4062		device_unregister(&sdkp->disk_dev);
4063		put_disk(gd);
4064		goto out;
4065	}
4066
4067	if (sdkp->security) {
4068		sdkp->opal_dev = init_opal_dev(sdkp, &sd_sec_submit);
4069		if (sdkp->opal_dev)
4070			sd_printk(KERN_NOTICE, sdkp, "supports TCG Opal\n");
4071	}
4072
4073	sd_printk(KERN_NOTICE, sdkp, "Attached SCSI %sdisk\n",
4074		  sdp->removable ? "removable " : "");
4075	scsi_autopm_put_device(sdp);
4076
4077	return 0;
4078
4079 out_free_index:
4080	ida_free(&sd_index_ida, index);
4081 out_put:
4082	put_disk(gd);
4083 out_free:
4084	kfree(sdkp);
4085 out:
4086	scsi_autopm_put_device(sdp);
4087	return error;
4088}
4089
4090/**
4091 *	sd_remove - called whenever a scsi disk (previously recognized by
4092 *	sd_probe) is detached from the system. It is called (potentially
4093 *	multiple times) during sd module unload.
4094 *	@dev: pointer to device object
4095 *
4096 *	Note: this function is invoked from the scsi mid-level.
4097 *	This function potentially frees up a device name (e.g. /dev/sdc)
4098 *	that could be re-used by a subsequent sd_probe().
4099 *	This function is not called when the built-in sd driver is "exit-ed".
4100 **/
4101static int sd_remove(struct device *dev)
4102{
4103	struct scsi_disk *sdkp = dev_get_drvdata(dev);
4104
4105	scsi_autopm_get_device(sdkp->device);
4106
4107	device_del(&sdkp->disk_dev);
4108	del_gendisk(sdkp->disk);
4109	if (!sdkp->suspended)
4110		sd_shutdown(dev);
4111
4112	put_disk(sdkp->disk);
4113	return 0;
4114}
4115
4116static void scsi_disk_release(struct device *dev)
4117{
4118	struct scsi_disk *sdkp = to_scsi_disk(dev);
4119
4120	ida_free(&sd_index_ida, sdkp->index);
4121	put_device(&sdkp->device->sdev_gendev);
4122	free_opal_dev(sdkp->opal_dev);
4123
4124	kfree(sdkp);
4125}
4126
4127static int sd_start_stop_device(struct scsi_disk *sdkp, int start)
4128{
4129	unsigned char cmd[6] = { START_STOP };	/* START_VALID */
4130	struct scsi_sense_hdr sshdr;
4131	struct scsi_failure failure_defs[] = {
4132		{
4133			/* Power on, reset, or bus device reset occurred */
4134			.sense = UNIT_ATTENTION,
4135			.asc = 0x29,
4136			.ascq = 0,
4137			.result = SAM_STAT_CHECK_CONDITION,
4138		},
4139		{
4140			/* Power on occurred */
4141			.sense = UNIT_ATTENTION,
4142			.asc = 0x29,
4143			.ascq = 1,
4144			.result = SAM_STAT_CHECK_CONDITION,
4145		},
4146		{
4147			/* SCSI bus reset */
4148			.sense = UNIT_ATTENTION,
4149			.asc = 0x29,
4150			.ascq = 2,
4151			.result = SAM_STAT_CHECK_CONDITION,
4152		},
4153		{}
4154	};
4155	struct scsi_failures failures = {
4156		.total_allowed = 3,
4157		.failure_definitions = failure_defs,
4158	};
4159	const struct scsi_exec_args exec_args = {
4160		.sshdr = &sshdr,
4161		.req_flags = BLK_MQ_REQ_PM,
4162		.failures = &failures,
4163	};
4164	struct scsi_device *sdp = sdkp->device;
4165	int res;
4166
4167	if (start)
4168		cmd[4] |= 1;	/* START */
4169
4170	if (sdp->start_stop_pwr_cond)
4171		cmd[4] |= start ? 1 << 4 : 3 << 4;	/* Active or Standby */
4172
4173	if (!scsi_device_online(sdp))
4174		return -ENODEV;
4175
4176	res = scsi_execute_cmd(sdp, cmd, REQ_OP_DRV_IN, NULL, 0, SD_TIMEOUT,
4177			       sdkp->max_retries, &exec_args);
4178	if (res) {
4179		sd_print_result(sdkp, "Start/Stop Unit failed", res);
4180		if (res > 0 && scsi_sense_valid(&sshdr)) {
4181			sd_print_sense_hdr(sdkp, &sshdr);
4182			/* 0x3a is medium not present */
4183			if (sshdr.asc == 0x3a)
4184				res = 0;
4185		}
4186	}
4187
4188	/* SCSI error codes must not go to the generic layer */
4189	if (res)
4190		return -EIO;
4191
4192	return 0;
4193}
4194
4195/*
4196 * Send a SYNCHRONIZE CACHE instruction down to the device through
4197 * the normal SCSI command structure.  Wait for the command to
4198 * complete.
4199 */
4200static void sd_shutdown(struct device *dev)
4201{
4202	struct scsi_disk *sdkp = dev_get_drvdata(dev);
4203
4204	if (!sdkp)
4205		return;         /* this can happen */
4206
4207	if (pm_runtime_suspended(dev))
4208		return;
4209
4210	if (sdkp->WCE && sdkp->media_present) {
4211		sd_printk(KERN_NOTICE, sdkp, "Synchronizing SCSI cache\n");
4212		sd_sync_cache(sdkp);
4213	}
4214
4215	if ((system_state != SYSTEM_RESTART &&
4216	     sdkp->device->manage_system_start_stop) ||
4217	    (system_state == SYSTEM_POWER_OFF &&
4218	     sdkp->device->manage_shutdown) ||
4219	    (system_state == SYSTEM_RUNNING &&
4220	     sdkp->device->manage_runtime_start_stop) ||
4221	    (system_state == SYSTEM_RESTART &&
4222	     sdkp->device->manage_restart)) {
4223		sd_printk(KERN_NOTICE, sdkp, "Stopping disk\n");
4224		sd_start_stop_device(sdkp, 0);
4225	}
4226}
4227
4228static inline bool sd_do_start_stop(struct scsi_device *sdev, bool runtime)
4229{
4230	return (sdev->manage_system_start_stop && !runtime) ||
4231		(sdev->manage_runtime_start_stop && runtime);
4232}
4233
4234static int sd_suspend_common(struct device *dev, bool runtime)
4235{
4236	struct scsi_disk *sdkp = dev_get_drvdata(dev);
4237	int ret = 0;
4238
4239	if (!sdkp)	/* E.g.: runtime suspend following sd_remove() */
4240		return 0;
4241
4242	if (sdkp->WCE && sdkp->media_present) {
4243		if (!sdkp->device->silence_suspend)
4244			sd_printk(KERN_NOTICE, sdkp, "Synchronizing SCSI cache\n");
4245		ret = sd_sync_cache(sdkp);
4246		/* ignore OFFLINE device */
4247		if (ret == -ENODEV)
4248			return 0;
4249
4250		if (ret)
4251			return ret;
4252	}
4253
4254	if (sd_do_start_stop(sdkp->device, runtime)) {
4255		if (!sdkp->device->silence_suspend)
4256			sd_printk(KERN_NOTICE, sdkp, "Stopping disk\n");
4257		/* an error is not worth aborting a system sleep */
4258		ret = sd_start_stop_device(sdkp, 0);
4259		if (!runtime)
4260			ret = 0;
4261	}
4262
4263	if (!ret)
4264		sdkp->suspended = true;
4265
4266	return ret;
4267}
4268
4269static int sd_suspend_system(struct device *dev)
4270{
4271	if (pm_runtime_suspended(dev))
4272		return 0;
4273
4274	return sd_suspend_common(dev, false);
4275}
4276
4277static int sd_suspend_runtime(struct device *dev)
4278{
4279	return sd_suspend_common(dev, true);
4280}
4281
4282static int sd_resume(struct device *dev)
4283{
4284	struct scsi_disk *sdkp = dev_get_drvdata(dev);
4285
4286	sd_printk(KERN_NOTICE, sdkp, "Starting disk\n");
4287
4288	if (opal_unlock_from_suspend(sdkp->opal_dev)) {
4289		sd_printk(KERN_NOTICE, sdkp, "OPAL unlock failed\n");
4290		return -EIO;
4291	}
4292
4293	return 0;
4294}
4295
4296static int sd_resume_common(struct device *dev, bool runtime)
4297{
4298	struct scsi_disk *sdkp = dev_get_drvdata(dev);
4299	int ret;
4300
4301	if (!sdkp)	/* E.g.: runtime resume at the start of sd_probe() */
4302		return 0;
4303
4304	if (!sd_do_start_stop(sdkp->device, runtime)) {
4305		sdkp->suspended = false;
4306		return 0;
4307	}
4308
4309	sd_printk(KERN_NOTICE, sdkp, "Starting disk\n");
4310	ret = sd_start_stop_device(sdkp, 1);
4311	if (!ret) {
4312		sd_resume(dev);
4313		sdkp->suspended = false;
4314	}
4315
4316	return ret;
4317}
4318
4319static int sd_resume_system(struct device *dev)
4320{
4321	if (pm_runtime_suspended(dev)) {
4322		struct scsi_disk *sdkp = dev_get_drvdata(dev);
4323		struct scsi_device *sdp = sdkp ? sdkp->device : NULL;
4324
4325		if (sdp && sdp->force_runtime_start_on_system_start)
4326			pm_request_resume(dev);
4327
4328		return 0;
4329	}
4330
4331	return sd_resume_common(dev, false);
4332}
4333
4334static int sd_resume_runtime(struct device *dev)
4335{
4336	struct scsi_disk *sdkp = dev_get_drvdata(dev);
4337	struct scsi_device *sdp;
4338
4339	if (!sdkp)	/* E.g.: runtime resume at the start of sd_probe() */
4340		return 0;
4341
4342	sdp = sdkp->device;
4343
4344	if (sdp->ignore_media_change) {
4345		/* clear the device's sense data */
4346		static const u8 cmd[10] = { REQUEST_SENSE };
4347		const struct scsi_exec_args exec_args = {
4348			.req_flags = BLK_MQ_REQ_PM,
4349		};
4350
4351		if (scsi_execute_cmd(sdp, cmd, REQ_OP_DRV_IN, NULL, 0,
4352				     sdp->request_queue->rq_timeout, 1,
4353				     &exec_args))
4354			sd_printk(KERN_NOTICE, sdkp,
4355				  "Failed to clear sense data\n");
4356	}
4357
4358	return sd_resume_common(dev, true);
4359}
4360
4361static const struct dev_pm_ops sd_pm_ops = {
4362	.suspend		= sd_suspend_system,
4363	.resume			= sd_resume_system,
4364	.poweroff		= sd_suspend_system,
4365	.restore		= sd_resume_system,
4366	.runtime_suspend	= sd_suspend_runtime,
4367	.runtime_resume		= sd_resume_runtime,
4368};
4369
4370static struct scsi_driver sd_template = {
4371	.gendrv = {
4372		.name		= "sd",
4373		.probe		= sd_probe,
4374		.probe_type	= PROBE_PREFER_ASYNCHRONOUS,
4375		.remove		= sd_remove,
4376		.shutdown	= sd_shutdown,
4377		.pm		= &sd_pm_ops,
4378	},
4379	.rescan			= sd_rescan,
4380	.resume			= sd_resume,
4381	.init_command		= sd_init_command,
4382	.uninit_command		= sd_uninit_command,
4383	.done			= sd_done,
4384	.eh_action		= sd_eh_action,
4385	.eh_reset		= sd_eh_reset,
4386};
4387
4388/**
4389 *	init_sd - entry point for this driver (both when built in or when
4390 *	a module).
4391 *
4392 *	Note: this function registers this driver with the scsi mid-level.
4393 **/
4394static int __init init_sd(void)
4395{
4396	int majors = 0, i, err;
4397
4398	SCSI_LOG_HLQUEUE(3, printk("init_sd: sd driver entry point\n"));
4399
4400	for (i = 0; i < SD_MAJORS; i++) {
4401		if (__register_blkdev(sd_major(i), "sd", sd_default_probe))
4402			continue;
4403		majors++;
4404	}
4405
4406	if (!majors)
4407		return -ENODEV;
4408
4409	err = class_register(&sd_disk_class);
4410	if (err)
4411		goto err_out;
4412
4413	sd_page_pool = mempool_create_page_pool(SD_MEMPOOL_SIZE, 0);
4414	if (!sd_page_pool) {
4415		printk(KERN_ERR "sd: can't init discard page pool\n");
4416		err = -ENOMEM;
4417		goto err_out_class;
4418	}
4419
4420	err = scsi_register_driver(&sd_template.gendrv);
4421	if (err)
4422		goto err_out_driver;
4423
4424	return 0;
4425
4426err_out_driver:
4427	mempool_destroy(sd_page_pool);
4428err_out_class:
4429	class_unregister(&sd_disk_class);
4430err_out:
4431	for (i = 0; i < SD_MAJORS; i++)
4432		unregister_blkdev(sd_major(i), "sd");
4433	return err;
4434}
4435
4436/**
4437 *	exit_sd - exit point for this driver (when it is a module).
4438 *
4439 *	Note: this function unregisters this driver from the scsi mid-level.
4440 **/
4441static void __exit exit_sd(void)
4442{
4443	int i;
4444
4445	SCSI_LOG_HLQUEUE(3, printk("exit_sd: exiting sd driver\n"));
4446
4447	scsi_unregister_driver(&sd_template.gendrv);
4448	mempool_destroy(sd_page_pool);
4449
4450	class_unregister(&sd_disk_class);
4451
4452	for (i = 0; i < SD_MAJORS; i++)
4453		unregister_blkdev(sd_major(i), "sd");
4454}
4455
4456module_init(init_sd);
4457module_exit(exit_sd);
4458
4459void sd_print_sense_hdr(struct scsi_disk *sdkp, struct scsi_sense_hdr *sshdr)
4460{
4461	scsi_print_sense_hdr(sdkp->device,
4462			     sdkp->disk ? sdkp->disk->disk_name : NULL, sshdr);
4463}
4464
4465void sd_print_result(const struct scsi_disk *sdkp, const char *msg, int result)
4466{
4467	const char *hb_string = scsi_hostbyte_string(result);
4468
4469	if (hb_string)
4470		sd_printk(KERN_INFO, sdkp,
4471			  "%s: Result: hostbyte=%s driverbyte=%s\n", msg,
4472			  hb_string ? hb_string : "invalid",
4473			  "DRIVER_OK");
4474	else
4475		sd_printk(KERN_INFO, sdkp,
4476			  "%s: Result: hostbyte=0x%02x driverbyte=%s\n",
4477			  msg, host_byte(result), "DRIVER_OK");
4478}