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