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