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