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