linux - drivers/scsi/sd.c

4538 lines · 118.2 KiB

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