Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
sd.c
Go to the documentation of this file.
1 /*
2  * sd.c Copyright (C) 1992 Drew Eckhardt
3  * Copyright (C) 1993, 1994, 1995, 1999 Eric Youngdale
4  *
5  * Linux scsi disk driver
6  * Initial versions: Drew Eckhardt
7  * Subsequent revisions: Eric Youngdale
8  * Modification history:
9  * - Drew Eckhardt <[email protected]> original
10  * - Eric Youngdale <[email protected]> add scatter-gather, multiple
11  * outstanding request, and other enhancements.
12  * Support loadable low-level scsi drivers.
13  * - Jirka Hanika <[email protected]> support more scsi disks using
14  * eight major numbers.
15  * - Richard Gooch <[email protected]> support devfs.
16  * - Torben Mathiasen <[email protected]> Resource allocation fixes in
17  * sd_init and cleanups.
18  * - Alex Davis <[email protected]> Fix problem where partition info
19  * not being read in sd_open. Fix problem where removable media
20  * could be ejected after sd_open.
21  * - Douglas Gilbert <[email protected]> cleanup for lk 2.5.x
22  * - Badari Pulavarty <[email protected]>, Matthew Wilcox
23  * <[email protected]>, Kurt Garloff <[email protected]>:
24  * Support 32k/1M disks.
25  *
26  * Logging policy (needs CONFIG_SCSI_LOGGING defined):
27  * - setting up transfer: SCSI_LOG_HLQUEUE levels 1 and 2
28  * - end of transfer (bh + scsi_lib): SCSI_LOG_HLCOMPLETE level 1
29  * - entering sd_ioctl: SCSI_LOG_IOCTL level 1
30  * - entering other commands: SCSI_LOG_HLQUEUE level 3
31  * Note: when the logging level is set by the user, it must be greater
32  * than the level indicated above to trigger output.
33  */
34 
35 #include <linux/module.h>
36 #include <linux/fs.h>
37 #include <linux/kernel.h>
38 #include <linux/mm.h>
39 #include <linux/bio.h>
40 #include <linux/genhd.h>
41 #include <linux/hdreg.h>
42 #include <linux/errno.h>
43 #include <linux/idr.h>
44 #include <linux/interrupt.h>
45 #include <linux/init.h>
46 #include <linux/blkdev.h>
47 #include <linux/blkpg.h>
48 #include <linux/delay.h>
49 #include <linux/mutex.h>
50 #include <linux/string_helpers.h>
51 #include <linux/async.h>
52 #include <linux/slab.h>
53 #include <linux/pm_runtime.h>
54 #include <asm/uaccess.h>
55 #include <asm/unaligned.h>
56 
57 #include <scsi/scsi.h>
58 #include <scsi/scsi_cmnd.h>
59 #include <scsi/scsi_dbg.h>
60 #include <scsi/scsi_device.h>
61 #include <scsi/scsi_driver.h>
62 #include <scsi/scsi_eh.h>
63 #include <scsi/scsi_host.h>
64 #include <scsi/scsi_ioctl.h>
65 #include <scsi/scsicam.h>
66 
67 #include "sd.h"
68 #include "scsi_priv.h"
69 #include "scsi_logging.h"
70 
71 MODULE_AUTHOR("Eric Youngdale");
72 MODULE_DESCRIPTION("SCSI disk (sd) driver");
73 MODULE_LICENSE("GPL");
74 
75 MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK0_MAJOR);
76 MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK1_MAJOR);
77 MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK2_MAJOR);
78 MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK3_MAJOR);
79 MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK4_MAJOR);
80 MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK5_MAJOR);
81 MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK6_MAJOR);
82 MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK7_MAJOR);
83 MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK8_MAJOR);
84 MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK9_MAJOR);
85 MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK10_MAJOR);
86 MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK11_MAJOR);
87 MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK12_MAJOR);
88 MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK13_MAJOR);
89 MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK14_MAJOR);
90 MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK15_MAJOR);
91 MODULE_ALIAS_SCSI_DEVICE(TYPE_DISK);
92 MODULE_ALIAS_SCSI_DEVICE(TYPE_MOD);
93 MODULE_ALIAS_SCSI_DEVICE(TYPE_RBC);
94 
95 #if !defined(CONFIG_DEBUG_BLOCK_EXT_DEVT)
96 #define SD_MINORS 16
97 #else
98 #define SD_MINORS 0
99 #endif
100 
101 static void sd_config_discard(struct scsi_disk *, unsigned int);
102 static void sd_config_write_same(struct scsi_disk *);
103 static int sd_revalidate_disk(struct gendisk *);
104 static void sd_unlock_native_capacity(struct gendisk *disk);
105 static int sd_probe(struct device *);
106 static int sd_remove(struct device *);
107 static void sd_shutdown(struct device *);
108 static int sd_suspend(struct device *, pm_message_t state);
109 static int sd_resume(struct device *);
110 static void sd_rescan(struct device *);
111 static int sd_done(struct scsi_cmnd *);
112 static int sd_eh_action(struct scsi_cmnd *, unsigned char *, int, int);
113 static void sd_read_capacity(struct scsi_disk *sdkp, unsigned char *buffer);
114 static void scsi_disk_release(struct device *cdev);
115 static void sd_print_sense_hdr(struct scsi_disk *, struct scsi_sense_hdr *);
116 static void sd_print_result(struct scsi_disk *, int);
117 
118 static DEFINE_SPINLOCK(sd_index_lock);
119 static DEFINE_IDA(sd_index_ida);
120 
121 /* This semaphore is used to mediate the 0->1 reference get in the
122  * face of object destruction (i.e. we can't allow a get on an
123  * object after last put) */
124 static DEFINE_MUTEX(sd_ref_mutex);
125 
126 static struct kmem_cache *sd_cdb_cache;
127 static mempool_t *sd_cdb_pool;
128 
129 static const char *sd_cache_types[] = {
130  "write through", "none", "write back",
131  "write back, no read (daft)"
132 };
133 
134 static ssize_t
135 sd_store_cache_type(struct device *dev, struct device_attribute *attr,
136  const char *buf, size_t count)
137 {
138  int i, ct = -1, rcd, wce, sp;
139  struct scsi_disk *sdkp = to_scsi_disk(dev);
140  struct scsi_device *sdp = sdkp->device;
141  char buffer[64];
142  char *buffer_data;
143  struct scsi_mode_data data;
144  struct scsi_sense_hdr sshdr;
145  int len;
146 
147  if (sdp->type != TYPE_DISK)
148  /* no cache control on RBC devices; theoretically they
149  * can do it, but there's probably so many exceptions
150  * it's not worth the risk */
151  return -EINVAL;
152 
153  for (i = 0; i < ARRAY_SIZE(sd_cache_types); i++) {
154  len = strlen(sd_cache_types[i]);
155  if (strncmp(sd_cache_types[i], buf, len) == 0 &&
156  buf[len] == '\n') {
157  ct = i;
158  break;
159  }
160  }
161  if (ct < 0)
162  return -EINVAL;
163  rcd = ct & 0x01 ? 1 : 0;
164  wce = ct & 0x02 ? 1 : 0;
165  if (scsi_mode_sense(sdp, 0x08, 8, buffer, sizeof(buffer), SD_TIMEOUT,
166  SD_MAX_RETRIES, &data, NULL))
167  return -EINVAL;
168  len = min_t(size_t, sizeof(buffer), data.length - data.header_length -
169  data.block_descriptor_length);
170  buffer_data = buffer + data.header_length +
171  data.block_descriptor_length;
172  buffer_data[2] &= ~0x05;
173  buffer_data[2] |= wce << 2 | rcd;
174  sp = buffer_data[0] & 0x80 ? 1 : 0;
175 
176  if (scsi_mode_select(sdp, 1, sp, 8, buffer_data, len, SD_TIMEOUT,
177  SD_MAX_RETRIES, &data, &sshdr)) {
178  if (scsi_sense_valid(&sshdr))
179  sd_print_sense_hdr(sdkp, &sshdr);
180  return -EINVAL;
181  }
182  revalidate_disk(sdkp->disk);
183  return count;
184 }
185 
186 static ssize_t
187 sd_store_manage_start_stop(struct device *dev, struct device_attribute *attr,
188  const char *buf, size_t count)
189 {
190  struct scsi_disk *sdkp = to_scsi_disk(dev);
191  struct scsi_device *sdp = sdkp->device;
192 
193  if (!capable(CAP_SYS_ADMIN))
194  return -EACCES;
195 
196  sdp->manage_start_stop = simple_strtoul(buf, NULL, 10);
197 
198  return count;
199 }
200 
201 static ssize_t
202 sd_store_allow_restart(struct device *dev, struct device_attribute *attr,
203  const char *buf, size_t count)
204 {
205  struct scsi_disk *sdkp = to_scsi_disk(dev);
206  struct scsi_device *sdp = sdkp->device;
207 
208  if (!capable(CAP_SYS_ADMIN))
209  return -EACCES;
210 
211  if (sdp->type != TYPE_DISK)
212  return -EINVAL;
213 
214  sdp->allow_restart = simple_strtoul(buf, NULL, 10);
215 
216  return count;
217 }
218 
219 static ssize_t
220 sd_show_cache_type(struct device *dev, struct device_attribute *attr,
221  char *buf)
222 {
223  struct scsi_disk *sdkp = to_scsi_disk(dev);
224  int ct = sdkp->RCD + 2*sdkp->WCE;
225 
226  return snprintf(buf, 40, "%s\n", sd_cache_types[ct]);
227 }
228 
229 static ssize_t
230 sd_show_fua(struct device *dev, struct device_attribute *attr, char *buf)
231 {
232  struct scsi_disk *sdkp = to_scsi_disk(dev);
233 
234  return snprintf(buf, 20, "%u\n", sdkp->DPOFUA);
235 }
236 
237 static ssize_t
238 sd_show_manage_start_stop(struct device *dev, struct device_attribute *attr,
239  char *buf)
240 {
241  struct scsi_disk *sdkp = to_scsi_disk(dev);
242  struct scsi_device *sdp = sdkp->device;
243 
244  return snprintf(buf, 20, "%u\n", sdp->manage_start_stop);
245 }
246 
247 static ssize_t
248 sd_show_allow_restart(struct device *dev, struct device_attribute *attr,
249  char *buf)
250 {
251  struct scsi_disk *sdkp = to_scsi_disk(dev);
252 
253  return snprintf(buf, 40, "%d\n", sdkp->device->allow_restart);
254 }
255 
256 static ssize_t
257 sd_show_protection_type(struct device *dev, struct device_attribute *attr,
258  char *buf)
259 {
260  struct scsi_disk *sdkp = to_scsi_disk(dev);
261 
262  return snprintf(buf, 20, "%u\n", sdkp->protection_type);
263 }
264 
265 static ssize_t
266 sd_store_protection_type(struct device *dev, struct device_attribute *attr,
267  const char *buf, size_t count)
268 {
269  struct scsi_disk *sdkp = to_scsi_disk(dev);
270  unsigned int val;
271  int err;
272 
273  if (!capable(CAP_SYS_ADMIN))
274  return -EACCES;
275 
276  err = kstrtouint(buf, 10, &val);
277 
278  if (err)
279  return err;
280 
281  if (val >= 0 && val <= SD_DIF_TYPE3_PROTECTION)
282  sdkp->protection_type = val;
283 
284  return count;
285 }
286 
287 static ssize_t
288 sd_show_protection_mode(struct device *dev, struct device_attribute *attr,
289  char *buf)
290 {
291  struct scsi_disk *sdkp = to_scsi_disk(dev);
292  struct scsi_device *sdp = sdkp->device;
293  unsigned int dif, dix;
294 
295  dif = scsi_host_dif_capable(sdp->host, sdkp->protection_type);
296  dix = scsi_host_dix_capable(sdp->host, sdkp->protection_type);
297 
298  if (!dix && scsi_host_dix_capable(sdp->host, SD_DIF_TYPE0_PROTECTION)) {
299  dif = 0;
300  dix = 1;
301  }
302 
303  if (!dif && !dix)
304  return snprintf(buf, 20, "none\n");
305 
306  return snprintf(buf, 20, "%s%u\n", dix ? "dix" : "dif", dif);
307 }
308 
309 static ssize_t
310 sd_show_app_tag_own(struct device *dev, struct device_attribute *attr,
311  char *buf)
312 {
313  struct scsi_disk *sdkp = to_scsi_disk(dev);
314 
315  return snprintf(buf, 20, "%u\n", sdkp->ATO);
316 }
317 
318 static ssize_t
319 sd_show_thin_provisioning(struct device *dev, struct device_attribute *attr,
320  char *buf)
321 {
322  struct scsi_disk *sdkp = to_scsi_disk(dev);
323 
324  return snprintf(buf, 20, "%u\n", sdkp->lbpme);
325 }
326 
327 static const char *lbp_mode[] = {
328  [SD_LBP_FULL] = "full",
329  [SD_LBP_UNMAP] = "unmap",
330  [SD_LBP_WS16] = "writesame_16",
331  [SD_LBP_WS10] = "writesame_10",
332  [SD_LBP_ZERO] = "writesame_zero",
333  [SD_LBP_DISABLE] = "disabled",
334 };
335 
336 static ssize_t
337 sd_show_provisioning_mode(struct device *dev, struct device_attribute *attr,
338  char *buf)
339 {
340  struct scsi_disk *sdkp = to_scsi_disk(dev);
341 
342  return snprintf(buf, 20, "%s\n", lbp_mode[sdkp->provisioning_mode]);
343 }
344 
345 static ssize_t
346 sd_store_provisioning_mode(struct device *dev, struct device_attribute *attr,
347  const char *buf, size_t count)
348 {
349  struct scsi_disk *sdkp = to_scsi_disk(dev);
350  struct scsi_device *sdp = sdkp->device;
351 
352  if (!capable(CAP_SYS_ADMIN))
353  return -EACCES;
354 
355  if (sdp->type != TYPE_DISK)
356  return -EINVAL;
357 
358  if (!strncmp(buf, lbp_mode[SD_LBP_UNMAP], 20))
359  sd_config_discard(sdkp, SD_LBP_UNMAP);
360  else if (!strncmp(buf, lbp_mode[SD_LBP_WS16], 20))
361  sd_config_discard(sdkp, SD_LBP_WS16);
362  else if (!strncmp(buf, lbp_mode[SD_LBP_WS10], 20))
363  sd_config_discard(sdkp, SD_LBP_WS10);
364  else if (!strncmp(buf, lbp_mode[SD_LBP_ZERO], 20))
365  sd_config_discard(sdkp, SD_LBP_ZERO);
366  else if (!strncmp(buf, lbp_mode[SD_LBP_DISABLE], 20))
367  sd_config_discard(sdkp, SD_LBP_DISABLE);
368  else
369  return -EINVAL;
370 
371  return count;
372 }
373 
374 static ssize_t
375 sd_show_max_medium_access_timeouts(struct device *dev,
376  struct device_attribute *attr, char *buf)
377 {
378  struct scsi_disk *sdkp = to_scsi_disk(dev);
379 
380  return snprintf(buf, 20, "%u\n", sdkp->max_medium_access_timeouts);
381 }
382 
383 static ssize_t
384 sd_store_max_medium_access_timeouts(struct device *dev,
385  struct device_attribute *attr,
386  const char *buf, size_t count)
387 {
388  struct scsi_disk *sdkp = to_scsi_disk(dev);
389  int err;
390 
391  if (!capable(CAP_SYS_ADMIN))
392  return -EACCES;
393 
394  err = kstrtouint(buf, 10, &sdkp->max_medium_access_timeouts);
395 
396  return err ? err : count;
397 }
398 
399 static ssize_t
400 sd_show_write_same_blocks(struct device *dev, struct device_attribute *attr,
401  char *buf)
402 {
403  struct scsi_disk *sdkp = to_scsi_disk(dev);
404 
405  return snprintf(buf, 20, "%u\n", sdkp->max_ws_blocks);
406 }
407 
408 static ssize_t
409 sd_store_write_same_blocks(struct device *dev, struct device_attribute *attr,
410  const char *buf, size_t count)
411 {
412  struct scsi_disk *sdkp = to_scsi_disk(dev);
413  struct scsi_device *sdp = sdkp->device;
414  unsigned long max;
415  int err;
416 
417  if (!capable(CAP_SYS_ADMIN))
418  return -EACCES;
419 
420  if (sdp->type != TYPE_DISK)
421  return -EINVAL;
422 
423  err = kstrtoul(buf, 10, &max);
424 
425  if (err)
426  return err;
427 
428  if (max == 0)
429  sdp->no_write_same = 1;
430  else if (max <= SD_MAX_WS16_BLOCKS)
431  sdkp->max_ws_blocks = max;
432 
433  sd_config_write_same(sdkp);
434 
435  return count;
436 }
437 
438 static struct device_attribute sd_disk_attrs[] = {
439  __ATTR(cache_type, S_IRUGO|S_IWUSR, sd_show_cache_type,
440  sd_store_cache_type),
441  __ATTR(FUA, S_IRUGO, sd_show_fua, NULL),
442  __ATTR(allow_restart, S_IRUGO|S_IWUSR, sd_show_allow_restart,
443  sd_store_allow_restart),
444  __ATTR(manage_start_stop, S_IRUGO|S_IWUSR, sd_show_manage_start_stop,
445  sd_store_manage_start_stop),
446  __ATTR(protection_type, S_IRUGO|S_IWUSR, sd_show_protection_type,
447  sd_store_protection_type),
448  __ATTR(protection_mode, S_IRUGO, sd_show_protection_mode, NULL),
449  __ATTR(app_tag_own, S_IRUGO, sd_show_app_tag_own, NULL),
450  __ATTR(thin_provisioning, S_IRUGO, sd_show_thin_provisioning, NULL),
451  __ATTR(provisioning_mode, S_IRUGO|S_IWUSR, sd_show_provisioning_mode,
452  sd_store_provisioning_mode),
453  __ATTR(max_write_same_blocks, S_IRUGO|S_IWUSR,
454  sd_show_write_same_blocks, sd_store_write_same_blocks),
455  __ATTR(max_medium_access_timeouts, S_IRUGO|S_IWUSR,
456  sd_show_max_medium_access_timeouts,
457  sd_store_max_medium_access_timeouts),
458  __ATTR_NULL,
459 };
460 
461 static struct class sd_disk_class = {
462  .name = "scsi_disk",
463  .owner = THIS_MODULE,
464  .dev_release = scsi_disk_release,
465  .dev_attrs = sd_disk_attrs,
466 };
467 
468 static struct scsi_driver sd_template = {
469  .owner = THIS_MODULE,
470  .gendrv = {
471  .name = "sd",
472  .probe = sd_probe,
473  .remove = sd_remove,
474  .suspend = sd_suspend,
475  .resume = sd_resume,
476  .shutdown = sd_shutdown,
477  },
478  .rescan = sd_rescan,
479  .done = sd_done,
480  .eh_action = sd_eh_action,
481 };
482 
483 /*
484  * Device no to disk mapping:
485  *
486  * major disc2 disc p1
487  * |............|.............|....|....| <- dev_t
488  * 31 20 19 8 7 4 3 0
489  *
490  * Inside a major, we have 16k disks, however mapped non-
491  * contiguously. The first 16 disks are for major0, the next
492  * ones with major1, ... Disk 256 is for major0 again, disk 272
493  * for major1, ...
494  * As we stay compatible with our numbering scheme, we can reuse
495  * the well-know SCSI majors 8, 65--71, 136--143.
496  */
497 static int sd_major(int major_idx)
498 {
499  switch (major_idx) {
500  case 0:
501  return SCSI_DISK0_MAJOR;
502  case 1 ... 7:
503  return SCSI_DISK1_MAJOR + major_idx - 1;
504  case 8 ... 15:
505  return SCSI_DISK8_MAJOR + major_idx - 8;
506  default:
507  BUG();
508  return 0; /* shut up gcc */
509  }
510 }
511 
512 static struct scsi_disk *__scsi_disk_get(struct gendisk *disk)
513 {
514  struct scsi_disk *sdkp = NULL;
515 
516  if (disk->private_data) {
517  sdkp = scsi_disk(disk);
518  if (scsi_device_get(sdkp->device) == 0)
519  get_device(&sdkp->dev);
520  else
521  sdkp = NULL;
522  }
523  return sdkp;
524 }
525 
526 static struct scsi_disk *scsi_disk_get(struct gendisk *disk)
527 {
528  struct scsi_disk *sdkp;
529 
530  mutex_lock(&sd_ref_mutex);
531  sdkp = __scsi_disk_get(disk);
532  mutex_unlock(&sd_ref_mutex);
533  return sdkp;
534 }
535 
536 static struct scsi_disk *scsi_disk_get_from_dev(struct device *dev)
537 {
538  struct scsi_disk *sdkp;
539 
540  mutex_lock(&sd_ref_mutex);
541  sdkp = dev_get_drvdata(dev);
542  if (sdkp)
543  sdkp = __scsi_disk_get(sdkp->disk);
544  mutex_unlock(&sd_ref_mutex);
545  return sdkp;
546 }
547 
548 static void scsi_disk_put(struct scsi_disk *sdkp)
549 {
550  struct scsi_device *sdev = sdkp->device;
551 
552  mutex_lock(&sd_ref_mutex);
553  put_device(&sdkp->dev);
554  scsi_device_put(sdev);
555  mutex_unlock(&sd_ref_mutex);
556 }
557 
558 static void sd_prot_op(struct scsi_cmnd *scmd, unsigned int dif)
559 {
560  unsigned int prot_op = SCSI_PROT_NORMAL;
561  unsigned int dix = scsi_prot_sg_count(scmd);
562 
563  if (scmd->sc_data_direction == DMA_FROM_DEVICE) {
564  if (dif && dix)
565  prot_op = SCSI_PROT_READ_PASS;
566  else if (dif && !dix)
567  prot_op = SCSI_PROT_READ_STRIP;
568  else if (!dif && dix)
569  prot_op = SCSI_PROT_READ_INSERT;
570  } else {
571  if (dif && dix)
572  prot_op = SCSI_PROT_WRITE_PASS;
573  else if (dif && !dix)
574  prot_op = SCSI_PROT_WRITE_INSERT;
575  else if (!dif && dix)
576  prot_op = SCSI_PROT_WRITE_STRIP;
577  }
578 
579  scsi_set_prot_op(scmd, prot_op);
580  scsi_set_prot_type(scmd, dif);
581 }
582 
583 static void sd_config_discard(struct scsi_disk *sdkp, unsigned int mode)
584 {
585  struct request_queue *q = sdkp->disk->queue;
586  unsigned int logical_block_size = sdkp->device->sector_size;
587  unsigned int max_blocks = 0;
588 
589  q->limits.discard_zeroes_data = sdkp->lbprz;
590  q->limits.discard_alignment = sdkp->unmap_alignment *
591  logical_block_size;
592  q->limits.discard_granularity =
593  max(sdkp->physical_block_size,
594  sdkp->unmap_granularity * logical_block_size);
595 
596  sdkp->provisioning_mode = mode;
597 
598  switch (mode) {
599 
600  case SD_LBP_DISABLE:
601  q->limits.max_discard_sectors = 0;
602  queue_flag_clear_unlocked(QUEUE_FLAG_DISCARD, q);
603  return;
604 
605  case SD_LBP_UNMAP:
606  max_blocks = min_not_zero(sdkp->max_unmap_blocks,
607  (u32)SD_MAX_WS16_BLOCKS);
608  break;
609 
610  case SD_LBP_WS16:
611  max_blocks = min_not_zero(sdkp->max_ws_blocks,
612  (u32)SD_MAX_WS16_BLOCKS);
613  break;
614 
615  case SD_LBP_WS10:
616  max_blocks = min_not_zero(sdkp->max_ws_blocks,
617  (u32)SD_MAX_WS10_BLOCKS);
618  break;
619 
620  case SD_LBP_ZERO:
621  max_blocks = min_not_zero(sdkp->max_ws_blocks,
622  (u32)SD_MAX_WS10_BLOCKS);
623  q->limits.discard_zeroes_data = 1;
624  break;
625  }
626 
627  q->limits.max_discard_sectors = max_blocks * (logical_block_size >> 9);
628  queue_flag_set_unlocked(QUEUE_FLAG_DISCARD, q);
629 }
630 
639 static int sd_setup_discard_cmnd(struct scsi_device *sdp, struct request *rq)
640 {
641  struct scsi_disk *sdkp = scsi_disk(rq->rq_disk);
642  sector_t sector = blk_rq_pos(rq);
643  unsigned int nr_sectors = blk_rq_sectors(rq);
644  unsigned int nr_bytes = blk_rq_bytes(rq);
645  unsigned int len;
646  int ret;
647  char *buf;
648  struct page *page;
649 
650  sector >>= ilog2(sdp->sector_size) - 9;
651  nr_sectors >>= ilog2(sdp->sector_size) - 9;
652  rq->timeout = SD_TIMEOUT;
653 
654  memset(rq->cmd, 0, rq->cmd_len);
655 
656  page = alloc_page(GFP_ATOMIC | __GFP_ZERO);
657  if (!page)
658  return BLKPREP_DEFER;
659 
660  switch (sdkp->provisioning_mode) {
661  case SD_LBP_UNMAP:
662  buf = page_address(page);
663 
664  rq->cmd_len = 10;
665  rq->cmd[0] = UNMAP;
666  rq->cmd[8] = 24;
667 
668  put_unaligned_be16(6 + 16, &buf[0]);
669  put_unaligned_be16(16, &buf[2]);
670  put_unaligned_be64(sector, &buf[8]);
671  put_unaligned_be32(nr_sectors, &buf[16]);
672 
673  len = 24;
674  break;
675 
676  case SD_LBP_WS16:
677  rq->cmd_len = 16;
678  rq->cmd[0] = WRITE_SAME_16;
679  rq->cmd[1] = 0x8; /* UNMAP */
680  put_unaligned_be64(sector, &rq->cmd[2]);
681  put_unaligned_be32(nr_sectors, &rq->cmd[10]);
682 
683  len = sdkp->device->sector_size;
684  break;
685 
686  case SD_LBP_WS10:
687  case SD_LBP_ZERO:
688  rq->cmd_len = 10;
689  rq->cmd[0] = WRITE_SAME;
690  if (sdkp->provisioning_mode == SD_LBP_WS10)
691  rq->cmd[1] = 0x8; /* UNMAP */
692  put_unaligned_be32(sector, &rq->cmd[2]);
693  put_unaligned_be16(nr_sectors, &rq->cmd[7]);
694 
695  len = sdkp->device->sector_size;
696  break;
697 
698  default:
699  ret = BLKPREP_KILL;
700  goto out;
701  }
702 
703  blk_add_request_payload(rq, page, len);
704  ret = scsi_setup_blk_pc_cmnd(sdp, rq);
705  rq->buffer = page_address(page);
706  rq->__data_len = nr_bytes;
707 
708 out:
709  if (ret != BLKPREP_OK) {
710  __free_page(page);
711  rq->buffer = NULL;
712  }
713  return ret;
714 }
715 
716 static void sd_config_write_same(struct scsi_disk *sdkp)
717 {
718  struct request_queue *q = sdkp->disk->queue;
719  unsigned int logical_block_size = sdkp->device->sector_size;
720  unsigned int blocks = 0;
721 
722  if (sdkp->device->no_write_same) {
723  sdkp->max_ws_blocks = 0;
724  goto out;
725  }
726 
727  /* Some devices can not handle block counts above 0xffff despite
728  * supporting WRITE SAME(16). Consequently we default to 64k
729  * blocks per I/O unless the device explicitly advertises a
730  * bigger limit.
731  */
732  if (sdkp->max_ws_blocks == 0)
733  sdkp->max_ws_blocks = SD_MAX_WS10_BLOCKS;
734 
735  if (sdkp->ws16 || sdkp->max_ws_blocks > SD_MAX_WS10_BLOCKS)
736  blocks = min_not_zero(sdkp->max_ws_blocks,
737  (u32)SD_MAX_WS16_BLOCKS);
738  else
739  blocks = min_not_zero(sdkp->max_ws_blocks,
740  (u32)SD_MAX_WS10_BLOCKS);
741 
742 out:
743  blk_queue_max_write_same_sectors(q, blocks * (logical_block_size >> 9));
744 }
745 
754 static int sd_setup_write_same_cmnd(struct scsi_device *sdp, struct request *rq)
755 {
756  struct scsi_disk *sdkp = scsi_disk(rq->rq_disk);
757  struct bio *bio = rq->bio;
758  sector_t sector = blk_rq_pos(rq);
759  unsigned int nr_sectors = blk_rq_sectors(rq);
760  unsigned int nr_bytes = blk_rq_bytes(rq);
761  int ret;
762 
763  if (sdkp->device->no_write_same)
764  return BLKPREP_KILL;
765 
766  BUG_ON(bio_offset(bio) || bio_iovec(bio)->bv_len != sdp->sector_size);
767 
768  sector >>= ilog2(sdp->sector_size) - 9;
769  nr_sectors >>= ilog2(sdp->sector_size) - 9;
770 
771  rq->__data_len = sdp->sector_size;
772  rq->timeout = SD_WRITE_SAME_TIMEOUT;
773  memset(rq->cmd, 0, rq->cmd_len);
774 
775  if (sdkp->ws16 || sector > 0xffffffff || nr_sectors > 0xffff) {
776  rq->cmd_len = 16;
777  rq->cmd[0] = WRITE_SAME_16;
778  put_unaligned_be64(sector, &rq->cmd[2]);
779  put_unaligned_be32(nr_sectors, &rq->cmd[10]);
780  } else {
781  rq->cmd_len = 10;
782  rq->cmd[0] = WRITE_SAME;
783  put_unaligned_be32(sector, &rq->cmd[2]);
784  put_unaligned_be16(nr_sectors, &rq->cmd[7]);
785  }
786 
787  ret = scsi_setup_blk_pc_cmnd(sdp, rq);
788  rq->__data_len = nr_bytes;
789 
790  return ret;
791 }
792 
793 static int scsi_setup_flush_cmnd(struct scsi_device *sdp, struct request *rq)
794 {
795  rq->timeout = SD_FLUSH_TIMEOUT;
796  rq->retries = SD_MAX_RETRIES;
797  rq->cmd[0] = SYNCHRONIZE_CACHE;
798  rq->cmd_len = 10;
799 
800  return scsi_setup_blk_pc_cmnd(sdp, rq);
801 }
802 
803 static void sd_unprep_fn(struct request_queue *q, struct request *rq)
804 {
805  if (rq->cmd_flags & REQ_DISCARD) {
806  free_page((unsigned long)rq->buffer);
807  rq->buffer = NULL;
808  }
809 }
810 
819 static int sd_prep_fn(struct request_queue *q, struct request *rq)
820 {
821  struct scsi_cmnd *SCpnt;
822  struct scsi_device *sdp = q->queuedata;
823  struct gendisk *disk = rq->rq_disk;
824  struct scsi_disk *sdkp;
825  sector_t block = blk_rq_pos(rq);
826  sector_t threshold;
827  unsigned int this_count = blk_rq_sectors(rq);
828  int ret, host_dif;
829  unsigned char protect;
830 
831  /*
832  * Discard request come in as REQ_TYPE_FS but we turn them into
833  * block PC requests to make life easier.
834  */
835  if (rq->cmd_flags & REQ_DISCARD) {
836  ret = sd_setup_discard_cmnd(sdp, rq);
837  goto out;
838  } else if (rq->cmd_flags & REQ_WRITE_SAME) {
839  ret = sd_setup_write_same_cmnd(sdp, rq);
840  goto out;
841  } else if (rq->cmd_flags & REQ_FLUSH) {
842  ret = scsi_setup_flush_cmnd(sdp, rq);
843  goto out;
844  } else if (rq->cmd_type == REQ_TYPE_BLOCK_PC) {
845  ret = scsi_setup_blk_pc_cmnd(sdp, rq);
846  goto out;
847  } else if (rq->cmd_type != REQ_TYPE_FS) {
848  ret = BLKPREP_KILL;
849  goto out;
850  }
851  ret = scsi_setup_fs_cmnd(sdp, rq);
852  if (ret != BLKPREP_OK)
853  goto out;
854  SCpnt = rq->special;
855  sdkp = scsi_disk(disk);
856 
857  /* from here on until we're complete, any goto out
858  * is used for a killable error condition */
859  ret = BLKPREP_KILL;
860 
861  SCSI_LOG_HLQUEUE(1, scmd_printk(KERN_INFO, SCpnt,
862  "sd_prep_fn: block=%llu, "
863  "count=%d\n",
864  (unsigned long long)block,
865  this_count));
866 
867  if (!sdp || !scsi_device_online(sdp) ||
868  block + blk_rq_sectors(rq) > get_capacity(disk)) {
869  SCSI_LOG_HLQUEUE(2, scmd_printk(KERN_INFO, SCpnt,
870  "Finishing %u sectors\n",
871  blk_rq_sectors(rq)));
872  SCSI_LOG_HLQUEUE(2, scmd_printk(KERN_INFO, SCpnt,
873  "Retry with 0x%p\n", SCpnt));
874  goto out;
875  }
876 
877  if (sdp->changed) {
878  /*
879  * quietly refuse to do anything to a changed disc until
880  * the changed bit has been reset
881  */
882  /* printk("SCSI disk has been changed or is not present. Prohibiting further I/O.\n"); */
883  goto out;
884  }
885 
886  /*
887  * Some SD card readers can't handle multi-sector accesses which touch
888  * the last one or two hardware sectors. Split accesses as needed.
889  */
890  threshold = get_capacity(disk) - SD_LAST_BUGGY_SECTORS *
891  (sdp->sector_size / 512);
892 
893  if (unlikely(sdp->last_sector_bug && block + this_count > threshold)) {
894  if (block < threshold) {
895  /* Access up to the threshold but not beyond */
896  this_count = threshold - block;
897  } else {
898  /* Access only a single hardware sector */
899  this_count = sdp->sector_size / 512;
900  }
901  }
902 
903  SCSI_LOG_HLQUEUE(2, scmd_printk(KERN_INFO, SCpnt, "block=%llu\n",
904  (unsigned long long)block));
905 
906  /*
907  * If we have a 1K hardware sectorsize, prevent access to single
908  * 512 byte sectors. In theory we could handle this - in fact
909  * the scsi cdrom driver must be able to handle this because
910  * we typically use 1K blocksizes, and cdroms typically have
911  * 2K hardware sectorsizes. Of course, things are simpler
912  * with the cdrom, since it is read-only. For performance
913  * reasons, the filesystems should be able to handle this
914  * and not force the scsi disk driver to use bounce buffers
915  * for this.
916  */
917  if (sdp->sector_size == 1024) {
918  if ((block & 1) || (blk_rq_sectors(rq) & 1)) {
919  scmd_printk(KERN_ERR, SCpnt,
920  "Bad block number requested\n");
921  goto out;
922  } else {
923  block = block >> 1;
924  this_count = this_count >> 1;
925  }
926  }
927  if (sdp->sector_size == 2048) {
928  if ((block & 3) || (blk_rq_sectors(rq) & 3)) {
929  scmd_printk(KERN_ERR, SCpnt,
930  "Bad block number requested\n");
931  goto out;
932  } else {
933  block = block >> 2;
934  this_count = this_count >> 2;
935  }
936  }
937  if (sdp->sector_size == 4096) {
938  if ((block & 7) || (blk_rq_sectors(rq) & 7)) {
939  scmd_printk(KERN_ERR, SCpnt,
940  "Bad block number requested\n");
941  goto out;
942  } else {
943  block = block >> 3;
944  this_count = this_count >> 3;
945  }
946  }
947  if (rq_data_dir(rq) == WRITE) {
948  if (!sdp->writeable) {
949  goto out;
950  }
951  SCpnt->cmnd[0] = WRITE_6;
952  SCpnt->sc_data_direction = DMA_TO_DEVICE;
953 
954  if (blk_integrity_rq(rq))
955  sd_dif_prepare(rq, block, sdp->sector_size);
956 
957  } else if (rq_data_dir(rq) == READ) {
958  SCpnt->cmnd[0] = READ_6;
959  SCpnt->sc_data_direction = DMA_FROM_DEVICE;
960  } else {
961  scmd_printk(KERN_ERR, SCpnt, "Unknown command %x\n", rq->cmd_flags);
962  goto out;
963  }
964 
965  SCSI_LOG_HLQUEUE(2, scmd_printk(KERN_INFO, SCpnt,
966  "%s %d/%u 512 byte blocks.\n",
967  (rq_data_dir(rq) == WRITE) ?
968  "writing" : "reading", this_count,
969  blk_rq_sectors(rq)));
970 
971  /* Set RDPROTECT/WRPROTECT if disk is formatted with DIF */
972  host_dif = scsi_host_dif_capable(sdp->host, sdkp->protection_type);
973  if (host_dif)
974  protect = 1 << 5;
975  else
976  protect = 0;
977 
978  if (host_dif == SD_DIF_TYPE2_PROTECTION) {
979  SCpnt->cmnd = mempool_alloc(sd_cdb_pool, GFP_ATOMIC);
980 
981  if (unlikely(SCpnt->cmnd == NULL)) {
982  ret = BLKPREP_DEFER;
983  goto out;
984  }
985 
986  SCpnt->cmd_len = SD_EXT_CDB_SIZE;
987  memset(SCpnt->cmnd, 0, SCpnt->cmd_len);
988  SCpnt->cmnd[0] = VARIABLE_LENGTH_CMD;
989  SCpnt->cmnd[7] = 0x18;
990  SCpnt->cmnd[9] = (rq_data_dir(rq) == READ) ? READ_32 : WRITE_32;
991  SCpnt->cmnd[10] = protect | ((rq->cmd_flags & REQ_FUA) ? 0x8 : 0);
992 
993  /* LBA */
994  SCpnt->cmnd[12] = sizeof(block) > 4 ? (unsigned char) (block >> 56) & 0xff : 0;
995  SCpnt->cmnd[13] = sizeof(block) > 4 ? (unsigned char) (block >> 48) & 0xff : 0;
996  SCpnt->cmnd[14] = sizeof(block) > 4 ? (unsigned char) (block >> 40) & 0xff : 0;
997  SCpnt->cmnd[15] = sizeof(block) > 4 ? (unsigned char) (block >> 32) & 0xff : 0;
998  SCpnt->cmnd[16] = (unsigned char) (block >> 24) & 0xff;
999  SCpnt->cmnd[17] = (unsigned char) (block >> 16) & 0xff;
1000  SCpnt->cmnd[18] = (unsigned char) (block >> 8) & 0xff;
1001  SCpnt->cmnd[19] = (unsigned char) block & 0xff;
1002 
1003  /* Expected Indirect LBA */
1004  SCpnt->cmnd[20] = (unsigned char) (block >> 24) & 0xff;
1005  SCpnt->cmnd[21] = (unsigned char) (block >> 16) & 0xff;
1006  SCpnt->cmnd[22] = (unsigned char) (block >> 8) & 0xff;
1007  SCpnt->cmnd[23] = (unsigned char) block & 0xff;
1008 
1009  /* Transfer length */
1010  SCpnt->cmnd[28] = (unsigned char) (this_count >> 24) & 0xff;
1011  SCpnt->cmnd[29] = (unsigned char) (this_count >> 16) & 0xff;
1012  SCpnt->cmnd[30] = (unsigned char) (this_count >> 8) & 0xff;
1013  SCpnt->cmnd[31] = (unsigned char) this_count & 0xff;
1014  } else if (block > 0xffffffff) {
1015  SCpnt->cmnd[0] += READ_16 - READ_6;
1016  SCpnt->cmnd[1] = protect | ((rq->cmd_flags & REQ_FUA) ? 0x8 : 0);
1017  SCpnt->cmnd[2] = sizeof(block) > 4 ? (unsigned char) (block >> 56) & 0xff : 0;
1018  SCpnt->cmnd[3] = sizeof(block) > 4 ? (unsigned char) (block >> 48) & 0xff : 0;
1019  SCpnt->cmnd[4] = sizeof(block) > 4 ? (unsigned char) (block >> 40) & 0xff : 0;
1020  SCpnt->cmnd[5] = sizeof(block) > 4 ? (unsigned char) (block >> 32) & 0xff : 0;
1021  SCpnt->cmnd[6] = (unsigned char) (block >> 24) & 0xff;
1022  SCpnt->cmnd[7] = (unsigned char) (block >> 16) & 0xff;
1023  SCpnt->cmnd[8] = (unsigned char) (block >> 8) & 0xff;
1024  SCpnt->cmnd[9] = (unsigned char) block & 0xff;
1025  SCpnt->cmnd[10] = (unsigned char) (this_count >> 24) & 0xff;
1026  SCpnt->cmnd[11] = (unsigned char) (this_count >> 16) & 0xff;
1027  SCpnt->cmnd[12] = (unsigned char) (this_count >> 8) & 0xff;
1028  SCpnt->cmnd[13] = (unsigned char) this_count & 0xff;
1029  SCpnt->cmnd[14] = SCpnt->cmnd[15] = 0;
1030  } else if ((this_count > 0xff) || (block > 0x1fffff) ||
1031  scsi_device_protection(SCpnt->device) ||
1032  SCpnt->device->use_10_for_rw) {
1033  if (this_count > 0xffff)
1034  this_count = 0xffff;
1035 
1036  SCpnt->cmnd[0] += READ_10 - READ_6;
1037  SCpnt->cmnd[1] = protect | ((rq->cmd_flags & REQ_FUA) ? 0x8 : 0);
1038  SCpnt->cmnd[2] = (unsigned char) (block >> 24) & 0xff;
1039  SCpnt->cmnd[3] = (unsigned char) (block >> 16) & 0xff;
1040  SCpnt->cmnd[4] = (unsigned char) (block >> 8) & 0xff;
1041  SCpnt->cmnd[5] = (unsigned char) block & 0xff;
1042  SCpnt->cmnd[6] = SCpnt->cmnd[9] = 0;
1043  SCpnt->cmnd[7] = (unsigned char) (this_count >> 8) & 0xff;
1044  SCpnt->cmnd[8] = (unsigned char) this_count & 0xff;
1045  } else {
1046  if (unlikely(rq->cmd_flags & REQ_FUA)) {
1047  /*
1048  * This happens only if this drive failed
1049  * 10byte rw command with ILLEGAL_REQUEST
1050  * during operation and thus turned off
1051  * use_10_for_rw.
1052  */
1053  scmd_printk(KERN_ERR, SCpnt,
1054  "FUA write on READ/WRITE(6) drive\n");
1055  goto out;
1056  }
1057 
1058  SCpnt->cmnd[1] |= (unsigned char) ((block >> 16) & 0x1f);
1059  SCpnt->cmnd[2] = (unsigned char) ((block >> 8) & 0xff);
1060  SCpnt->cmnd[3] = (unsigned char) block & 0xff;
1061  SCpnt->cmnd[4] = (unsigned char) this_count;
1062  SCpnt->cmnd[5] = 0;
1063  }
1064  SCpnt->sdb.length = this_count * sdp->sector_size;
1065 
1066  /* If DIF or DIX is enabled, tell HBA how to handle request */
1067  if (host_dif || scsi_prot_sg_count(SCpnt))
1068  sd_prot_op(SCpnt, host_dif);
1069 
1070  /*
1071  * We shouldn't disconnect in the middle of a sector, so with a dumb
1072  * host adapter, it's safe to assume that we can at least transfer
1073  * this many bytes between each connect / disconnect.
1074  */
1075  SCpnt->transfersize = sdp->sector_size;
1076  SCpnt->underflow = this_count << 9;
1077  SCpnt->allowed = SD_MAX_RETRIES;
1078 
1079  /*
1080  * This indicates that the command is ready from our end to be
1081  * queued.
1082  */
1083  ret = BLKPREP_OK;
1084  out:
1085  return scsi_prep_return(q, rq, ret);
1086 }
1087 
1103 static int sd_open(struct block_device *bdev, fmode_t mode)
1104 {
1105  struct scsi_disk *sdkp = scsi_disk_get(bdev->bd_disk);
1106  struct scsi_device *sdev;
1107  int retval;
1108 
1109  if (!sdkp)
1110  return -ENXIO;
1111 
1112  SCSI_LOG_HLQUEUE(3, sd_printk(KERN_INFO, sdkp, "sd_open\n"));
1113 
1114  sdev = sdkp->device;
1115 
1116  retval = scsi_autopm_get_device(sdev);
1117  if (retval)
1118  goto error_autopm;
1119 
1120  /*
1121  * If the device is in error recovery, wait until it is done.
1122  * If the device is offline, then disallow any access to it.
1123  */
1124  retval = -ENXIO;
1125  if (!scsi_block_when_processing_errors(sdev))
1126  goto error_out;
1127 
1128  if (sdev->removable || sdkp->write_prot)
1129  check_disk_change(bdev);
1130 
1131  /*
1132  * If the drive is empty, just let the open fail.
1133  */
1134  retval = -ENOMEDIUM;
1135  if (sdev->removable && !sdkp->media_present && !(mode & FMODE_NDELAY))
1136  goto error_out;
1137 
1138  /*
1139  * If the device has the write protect tab set, have the open fail
1140  * if the user expects to be able to write to the thing.
1141  */
1142  retval = -EROFS;
1143  if (sdkp->write_prot && (mode & FMODE_WRITE))
1144  goto error_out;
1145 
1146  /*
1147  * It is possible that the disk changing stuff resulted in
1148  * the device being taken offline. If this is the case,
1149  * report this to the user, and don't pretend that the
1150  * open actually succeeded.
1151  */
1152  retval = -ENXIO;
1153  if (!scsi_device_online(sdev))
1154  goto error_out;
1155 
1156  if ((atomic_inc_return(&sdkp->openers) == 1) && sdev->removable) {
1157  if (scsi_block_when_processing_errors(sdev))
1158  scsi_set_medium_removal(sdev, SCSI_REMOVAL_PREVENT);
1159  }
1160 
1161  return 0;
1162 
1163 error_out:
1164  scsi_autopm_put_device(sdev);
1165 error_autopm:
1166  scsi_disk_put(sdkp);
1167  return retval;
1168 }
1169 
1183 static int sd_release(struct gendisk *disk, fmode_t mode)
1184 {
1185  struct scsi_disk *sdkp = scsi_disk(disk);
1186  struct scsi_device *sdev = sdkp->device;
1187 
1188  SCSI_LOG_HLQUEUE(3, sd_printk(KERN_INFO, sdkp, "sd_release\n"));
1189 
1190  if (atomic_dec_return(&sdkp->openers) == 0 && sdev->removable) {
1191  if (scsi_block_when_processing_errors(sdev))
1192  scsi_set_medium_removal(sdev, SCSI_REMOVAL_ALLOW);
1193  }
1194 
1195  /*
1196  * XXX and what if there are packets in flight and this close()
1197  * XXX is followed by a "rmmod sd_mod"?
1198  */
1199 
1200  scsi_autopm_put_device(sdev);
1201  scsi_disk_put(sdkp);
1202  return 0;
1203 }
1204 
1205 static int sd_getgeo(struct block_device *bdev, struct hd_geometry *geo)
1206 {
1207  struct scsi_disk *sdkp = scsi_disk(bdev->bd_disk);
1208  struct scsi_device *sdp = sdkp->device;
1209  struct Scsi_Host *host = sdp->host;
1210  int diskinfo[4];
1211 
1212  /* default to most commonly used values */
1213  diskinfo[0] = 0x40; /* 1 << 6 */
1214  diskinfo[1] = 0x20; /* 1 << 5 */
1215  diskinfo[2] = sdkp->capacity >> 11;
1216 
1217  /* override with calculated, extended default, or driver values */
1218  if (host->hostt->bios_param)
1219  host->hostt->bios_param(sdp, bdev, sdkp->capacity, diskinfo);
1220  else
1221  scsicam_bios_param(bdev, sdkp->capacity, diskinfo);
1222 
1223  geo->heads = diskinfo[0];
1224  geo->sectors = diskinfo[1];
1225  geo->cylinders = diskinfo[2];
1226  return 0;
1227 }
1228 
1243 static int sd_ioctl(struct block_device *bdev, fmode_t mode,
1244  unsigned int cmd, unsigned long arg)
1245 {
1246  struct gendisk *disk = bdev->bd_disk;
1247  struct scsi_disk *sdkp = scsi_disk(disk);
1248  struct scsi_device *sdp = sdkp->device;
1249  void __user *p = (void __user *)arg;
1250  int error;
1251 
1252  SCSI_LOG_IOCTL(1, sd_printk(KERN_INFO, sdkp, "sd_ioctl: disk=%s, "
1253  "cmd=0x%x\n", disk->disk_name, cmd));
1254 
1255  error = scsi_verify_blk_ioctl(bdev, cmd);
1256  if (error < 0)
1257  return error;
1258 
1259  /*
1260  * If we are in the middle of error recovery, don't let anyone
1261  * else try and use this device. Also, if error recovery fails, it
1262  * may try and take the device offline, in which case all further
1263  * access to the device is prohibited.
1264  */
1265  error = scsi_nonblockable_ioctl(sdp, cmd, p,
1266  (mode & FMODE_NDELAY) != 0);
1267  if (!scsi_block_when_processing_errors(sdp) || !error)
1268  goto out;
1269 
1270  /*
1271  * Send SCSI addressing ioctls directly to mid level, send other
1272  * ioctls to block level and then onto mid level if they can't be
1273  * resolved.
1274  */
1275  switch (cmd) {
1276  case SCSI_IOCTL_GET_IDLUN:
1277  case SCSI_IOCTL_GET_BUS_NUMBER:
1278  error = scsi_ioctl(sdp, cmd, p);
1279  break;
1280  default:
1281  error = scsi_cmd_blk_ioctl(bdev, mode, cmd, p);
1282  if (error != -ENOTTY)
1283  break;
1284  error = scsi_ioctl(sdp, cmd, p);
1285  break;
1286  }
1287 out:
1288  return error;
1289 }
1290 
1291 static void set_media_not_present(struct scsi_disk *sdkp)
1292 {
1293  if (sdkp->media_present)
1294  sdkp->device->changed = 1;
1295 
1296  if (sdkp->device->removable) {
1297  sdkp->media_present = 0;
1298  sdkp->capacity = 0;
1299  }
1300 }
1301 
1302 static int media_not_present(struct scsi_disk *sdkp,
1303  struct scsi_sense_hdr *sshdr)
1304 {
1305  if (!scsi_sense_valid(sshdr))
1306  return 0;
1307 
1308  /* not invoked for commands that could return deferred errors */
1309  switch (sshdr->sense_key) {
1310  case UNIT_ATTENTION:
1311  case NOT_READY:
1312  /* medium not present */
1313  if (sshdr->asc == 0x3A) {
1314  set_media_not_present(sdkp);
1315  return 1;
1316  }
1317  }
1318  return 0;
1319 }
1320 
1330 static unsigned int sd_check_events(struct gendisk *disk, unsigned int clearing)
1331 {
1332  struct scsi_disk *sdkp = scsi_disk(disk);
1333  struct scsi_device *sdp = sdkp->device;
1334  struct scsi_sense_hdr *sshdr = NULL;
1335  int retval;
1336 
1337  SCSI_LOG_HLQUEUE(3, sd_printk(KERN_INFO, sdkp, "sd_check_events\n"));
1338 
1339  /*
1340  * If the device is offline, don't send any commands - just pretend as
1341  * if the command failed. If the device ever comes back online, we
1342  * can deal with it then. It is only because of unrecoverable errors
1343  * that we would ever take a device offline in the first place.
1344  */
1345  if (!scsi_device_online(sdp)) {
1346  set_media_not_present(sdkp);
1347  goto out;
1348  }
1349 
1350  /*
1351  * Using TEST_UNIT_READY enables differentiation between drive with
1352  * no cartridge loaded - NOT READY, drive with changed cartridge -
1353  * UNIT ATTENTION, or with same cartridge - GOOD STATUS.
1354  *
1355  * Drives that auto spin down. eg iomega jaz 1G, will be started
1356  * by sd_spinup_disk() from sd_revalidate_disk(), which happens whenever
1357  * sd_revalidate() is called.
1358  */
1359  retval = -ENODEV;
1360 
1361  if (scsi_block_when_processing_errors(sdp)) {
1362  retval = scsi_autopm_get_device(sdp);
1363  if (retval)
1364  goto out;
1365 
1366  sshdr = kzalloc(sizeof(*sshdr), GFP_KERNEL);
1367  retval = scsi_test_unit_ready(sdp, SD_TIMEOUT, SD_MAX_RETRIES,
1368  sshdr);
1369  scsi_autopm_put_device(sdp);
1370  }
1371 
1372  /* failed to execute TUR, assume media not present */
1373  if (host_byte(retval)) {
1374  set_media_not_present(sdkp);
1375  goto out;
1376  }
1377 
1378  if (media_not_present(sdkp, sshdr))
1379  goto out;
1380 
1381  /*
1382  * For removable scsi disk we have to recognise the presence
1383  * of a disk in the drive.
1384  */
1385  if (!sdkp->media_present)
1386  sdp->changed = 1;
1387  sdkp->media_present = 1;
1388 out:
1389  /*
1390  * sdp->changed is set under the following conditions:
1391  *
1392  * Medium present state has changed in either direction.
1393  * Device has indicated UNIT_ATTENTION.
1394  */
1395  kfree(sshdr);
1396  retval = sdp->changed ? DISK_EVENT_MEDIA_CHANGE : 0;
1397  sdp->changed = 0;
1398  return retval;
1399 }
1400 
1401 static int sd_sync_cache(struct scsi_disk *sdkp)
1402 {
1403  int retries, res;
1404  struct scsi_device *sdp = sdkp->device;
1405  struct scsi_sense_hdr sshdr;
1406 
1407  if (!scsi_device_online(sdp))
1408  return -ENODEV;
1409 
1410 
1411  for (retries = 3; retries > 0; --retries) {
1412  unsigned char cmd[10] = { 0 };
1413 
1414  cmd[0] = SYNCHRONIZE_CACHE;
1415  /*
1416  * Leave the rest of the command zero to indicate
1417  * flush everything.
1418  */
1419  res = scsi_execute_req(sdp, cmd, DMA_NONE, NULL, 0, &sshdr,
1420  SD_FLUSH_TIMEOUT, SD_MAX_RETRIES, NULL);
1421  if (res == 0)
1422  break;
1423  }
1424 
1425  if (res) {
1426  sd_print_result(sdkp, res);
1427  if (driver_byte(res) & DRIVER_SENSE)
1428  sd_print_sense_hdr(sdkp, &sshdr);
1429  }
1430 
1431  if (res)
1432  return -EIO;
1433  return 0;
1434 }
1435 
1436 static void sd_rescan(struct device *dev)
1437 {
1438  struct scsi_disk *sdkp = scsi_disk_get_from_dev(dev);
1439 
1440  if (sdkp) {
1441  revalidate_disk(sdkp->disk);
1442  scsi_disk_put(sdkp);
1443  }
1444 }
1445 
1446 
1447 #ifdef CONFIG_COMPAT
1448 /*
1449  * This gets directly called from VFS. When the ioctl
1450  * is not recognized we go back to the other translation paths.
1451  */
1452 static int sd_compat_ioctl(struct block_device *bdev, fmode_t mode,
1453  unsigned int cmd, unsigned long arg)
1454 {
1455  struct scsi_device *sdev = scsi_disk(bdev->bd_disk)->device;
1456  int ret;
1457 
1458  ret = scsi_verify_blk_ioctl(bdev, cmd);
1459  if (ret < 0)
1460  return ret;
1461 
1462  /*
1463  * If we are in the middle of error recovery, don't let anyone
1464  * else try and use this device. Also, if error recovery fails, it
1465  * may try and take the device offline, in which case all further
1466  * access to the device is prohibited.
1467  */
1468  if (!scsi_block_when_processing_errors(sdev))
1469  return -ENODEV;
1470 
1471  if (sdev->host->hostt->compat_ioctl) {
1472  ret = sdev->host->hostt->compat_ioctl(sdev, cmd, (void __user *)arg);
1473 
1474  return ret;
1475  }
1476 
1477  /*
1478  * Let the static ioctl translation table take care of it.
1479  */
1480  return -ENOIOCTLCMD;
1481 }
1482 #endif
1483 
1484 static const struct block_device_operations sd_fops = {
1485  .owner = THIS_MODULE,
1486  .open = sd_open,
1487  .release = sd_release,
1488  .ioctl = sd_ioctl,
1489  .getgeo = sd_getgeo,
1490 #ifdef CONFIG_COMPAT
1491  .compat_ioctl = sd_compat_ioctl,
1492 #endif
1493  .check_events = sd_check_events,
1494  .revalidate_disk = sd_revalidate_disk,
1495  .unlock_native_capacity = sd_unlock_native_capacity,
1496 };
1497 
1511 static int sd_eh_action(struct scsi_cmnd *scmd, unsigned char *eh_cmnd,
1512  int eh_cmnd_len, int eh_disp)
1513 {
1514  struct scsi_disk *sdkp = scsi_disk(scmd->request->rq_disk);
1515 
1516  if (!scsi_device_online(scmd->device) ||
1517  !scsi_medium_access_command(scmd))
1518  return eh_disp;
1519 
1520  /*
1521  * The device has timed out executing a medium access command.
1522  * However, the TEST UNIT READY command sent during error
1523  * handling completed successfully. Either the device is in the
1524  * process of recovering or has it suffered an internal failure
1525  * that prevents access to the storage medium.
1526  */
1527  if (host_byte(scmd->result) == DID_TIME_OUT && eh_disp == SUCCESS &&
1528  eh_cmnd_len && eh_cmnd[0] == TEST_UNIT_READY)
1529  sdkp->medium_access_timed_out++;
1530 
1531  /*
1532  * If the device keeps failing read/write commands but TEST UNIT
1533  * READY always completes successfully we assume that medium
1534  * access is no longer possible and take the device offline.
1535  */
1536  if (sdkp->medium_access_timed_out >= sdkp->max_medium_access_timeouts) {
1537  scmd_printk(KERN_ERR, scmd,
1538  "Medium access timeout failure. Offlining disk!\n");
1539  scsi_device_set_state(scmd->device, SDEV_OFFLINE);
1540 
1541  return FAILED;
1542  }
1543 
1544  return eh_disp;
1545 }
1546 
1547 static unsigned int sd_completed_bytes(struct scsi_cmnd *scmd)
1548 {
1549  u64 start_lba = blk_rq_pos(scmd->request);
1550  u64 end_lba = blk_rq_pos(scmd->request) + (scsi_bufflen(scmd) / 512);
1551  u64 bad_lba;
1552  int info_valid;
1553  /*
1554  * resid is optional but mostly filled in. When it's unused,
1555  * its value is zero, so we assume the whole buffer transferred
1556  */
1557  unsigned int transferred = scsi_bufflen(scmd) - scsi_get_resid(scmd);
1558  unsigned int good_bytes;
1559 
1560  if (scmd->request->cmd_type != REQ_TYPE_FS)
1561  return 0;
1562 
1563  info_valid = scsi_get_sense_info_fld(scmd->sense_buffer,
1564  SCSI_SENSE_BUFFERSIZE,
1565  &bad_lba);
1566  if (!info_valid)
1567  return 0;
1568 
1569  if (scsi_bufflen(scmd) <= scmd->device->sector_size)
1570  return 0;
1571 
1572  if (scmd->device->sector_size < 512) {
1573  /* only legitimate sector_size here is 256 */
1574  start_lba <<= 1;
1575  end_lba <<= 1;
1576  } else {
1577  /* be careful ... don't want any overflows */
1578  u64 factor = scmd->device->sector_size / 512;
1579  do_div(start_lba, factor);
1580  do_div(end_lba, factor);
1581  }
1582 
1583  /* The bad lba was reported incorrectly, we have no idea where
1584  * the error is.
1585  */
1586  if (bad_lba < start_lba || bad_lba >= end_lba)
1587  return 0;
1588 
1589  /* This computation should always be done in terms of
1590  * the resolution of the device's medium.
1591  */
1592  good_bytes = (bad_lba - start_lba) * scmd->device->sector_size;
1593  return min(good_bytes, transferred);
1594 }
1595 
1603 static int sd_done(struct scsi_cmnd *SCpnt)
1604 {
1605  int result = SCpnt->result;
1606  unsigned int good_bytes = result ? 0 : scsi_bufflen(SCpnt);
1607  struct scsi_sense_hdr sshdr;
1608  struct scsi_disk *sdkp = scsi_disk(SCpnt->request->rq_disk);
1609  struct request *req = SCpnt->request;
1610  int sense_valid = 0;
1611  int sense_deferred = 0;
1612  unsigned char op = SCpnt->cmnd[0];
1613  unsigned char unmap = SCpnt->cmnd[1] & 8;
1614 
1615  if (req->cmd_flags & REQ_DISCARD || req->cmd_flags & REQ_WRITE_SAME) {
1616  if (!result) {
1617  good_bytes = blk_rq_bytes(req);
1618  scsi_set_resid(SCpnt, 0);
1619  } else {
1620  good_bytes = 0;
1621  scsi_set_resid(SCpnt, blk_rq_bytes(req));
1622  }
1623  }
1624 
1625  if (result) {
1626  sense_valid = scsi_command_normalize_sense(SCpnt, &sshdr);
1627  if (sense_valid)
1628  sense_deferred = scsi_sense_is_deferred(&sshdr);
1629  }
1630 #ifdef CONFIG_SCSI_LOGGING
1631  SCSI_LOG_HLCOMPLETE(1, scsi_print_result(SCpnt));
1632  if (sense_valid) {
1633  SCSI_LOG_HLCOMPLETE(1, scmd_printk(KERN_INFO, SCpnt,
1634  "sd_done: sb[respc,sk,asc,"
1635  "ascq]=%x,%x,%x,%x\n",
1636  sshdr.response_code,
1637  sshdr.sense_key, sshdr.asc,
1638  sshdr.ascq));
1639  }
1640 #endif
1641  if (driver_byte(result) != DRIVER_SENSE &&
1642  (!sense_valid || sense_deferred))
1643  goto out;
1644 
1645  sdkp->medium_access_timed_out = 0;
1646 
1647  switch (sshdr.sense_key) {
1648  case HARDWARE_ERROR:
1649  case MEDIUM_ERROR:
1650  good_bytes = sd_completed_bytes(SCpnt);
1651  break;
1652  case RECOVERED_ERROR:
1653  good_bytes = scsi_bufflen(SCpnt);
1654  break;
1655  case NO_SENSE:
1656  /* This indicates a false check condition, so ignore it. An
1657  * unknown amount of data was transferred so treat it as an
1658  * error.
1659  */
1660  scsi_print_sense("sd", SCpnt);
1661  SCpnt->result = 0;
1662  memset(SCpnt->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);
1663  break;
1664  case ABORTED_COMMAND:
1665  if (sshdr.asc == 0x10) /* DIF: Target detected corruption */
1666  good_bytes = sd_completed_bytes(SCpnt);
1667  break;
1668  case ILLEGAL_REQUEST:
1669  if (sshdr.asc == 0x10) /* DIX: Host detected corruption */
1670  good_bytes = sd_completed_bytes(SCpnt);
1671  /* INVALID COMMAND OPCODE or INVALID FIELD IN CDB */
1672  if (sshdr.asc == 0x20 || sshdr.asc == 0x24) {
1673  switch (op) {
1674  case UNMAP:
1675  sd_config_discard(sdkp, SD_LBP_DISABLE);
1676  break;
1677  case WRITE_SAME_16:
1678  case WRITE_SAME:
1679  if (unmap)
1680  sd_config_discard(sdkp, SD_LBP_DISABLE);
1681  else {
1682  sdkp->device->no_write_same = 1;
1683  sd_config_write_same(sdkp);
1684 
1685  good_bytes = 0;
1686  req->__data_len = blk_rq_bytes(req);
1687  req->cmd_flags |= REQ_QUIET;
1688  }
1689  }
1690  }
1691  break;
1692  default:
1693  break;
1694  }
1695  out:
1696  if (rq_data_dir(SCpnt->request) == READ && scsi_prot_sg_count(SCpnt))
1697  sd_dif_complete(SCpnt, good_bytes);
1698 
1699  if (scsi_host_dif_capable(sdkp->device->host, sdkp->protection_type)
1700  == SD_DIF_TYPE2_PROTECTION && SCpnt->cmnd != SCpnt->request->cmd) {
1701 
1702  /* We have to print a failed command here as the
1703  * extended CDB gets freed before scsi_io_completion()
1704  * is called.
1705  */
1706  if (result)
1707  scsi_print_command(SCpnt);
1708 
1709  mempool_free(SCpnt->cmnd, sd_cdb_pool);
1710  SCpnt->cmnd = NULL;
1711  SCpnt->cmd_len = 0;
1712  }
1713 
1714  return good_bytes;
1715 }
1716 
1717 /*
1718  * spinup disk - called only in sd_revalidate_disk()
1719  */
1720 static void
1721 sd_spinup_disk(struct scsi_disk *sdkp)
1722 {
1723  unsigned char cmd[10];
1724  unsigned long spintime_expire = 0;
1725  int retries, spintime;
1726  unsigned int the_result;
1727  struct scsi_sense_hdr sshdr;
1728  int sense_valid = 0;
1729 
1730  spintime = 0;
1731 
1732  /* Spin up drives, as required. Only do this at boot time */
1733  /* Spinup needs to be done for module loads too. */
1734  do {
1735  retries = 0;
1736 
1737  do {
1738  cmd[0] = TEST_UNIT_READY;
1739  memset((void *) &cmd[1], 0, 9);
1740 
1741  the_result = scsi_execute_req(sdkp->device, cmd,
1742  DMA_NONE, NULL, 0,
1743  &sshdr, SD_TIMEOUT,
1744  SD_MAX_RETRIES, NULL);
1745 
1746  /*
1747  * If the drive has indicated to us that it
1748  * doesn't have any media in it, don't bother
1749  * with any more polling.
1750  */
1751  if (media_not_present(sdkp, &sshdr))
1752  return;
1753 
1754  if (the_result)
1755  sense_valid = scsi_sense_valid(&sshdr);
1756  retries++;
1757  } while (retries < 3 &&
1758  (!scsi_status_is_good(the_result) ||
1759  ((driver_byte(the_result) & DRIVER_SENSE) &&
1760  sense_valid && sshdr.sense_key == UNIT_ATTENTION)));
1761 
1762  if ((driver_byte(the_result) & DRIVER_SENSE) == 0) {
1763  /* no sense, TUR either succeeded or failed
1764  * with a status error */
1765  if(!spintime && !scsi_status_is_good(the_result)) {
1766  sd_printk(KERN_NOTICE, sdkp, "Unit Not Ready\n");
1767  sd_print_result(sdkp, the_result);
1768  }
1769  break;
1770  }
1771 
1772  /*
1773  * The device does not want the automatic start to be issued.
1774  */
1775  if (sdkp->device->no_start_on_add)
1776  break;
1777 
1778  if (sense_valid && sshdr.sense_key == NOT_READY) {
1779  if (sshdr.asc == 4 && sshdr.ascq == 3)
1780  break; /* manual intervention required */
1781  if (sshdr.asc == 4 && sshdr.ascq == 0xb)
1782  break; /* standby */
1783  if (sshdr.asc == 4 && sshdr.ascq == 0xc)
1784  break; /* unavailable */
1785  /*
1786  * Issue command to spin up drive when not ready
1787  */
1788  if (!spintime) {
1789  sd_printk(KERN_NOTICE, sdkp, "Spinning up disk...");
1790  cmd[0] = START_STOP;
1791  cmd[1] = 1; /* Return immediately */
1792  memset((void *) &cmd[2], 0, 8);
1793  cmd[4] = 1; /* Start spin cycle */
1794  if (sdkp->device->start_stop_pwr_cond)
1795  cmd[4] |= 1 << 4;
1796  scsi_execute_req(sdkp->device, cmd, DMA_NONE,
1797  NULL, 0, &sshdr,
1798  SD_TIMEOUT, SD_MAX_RETRIES,
1799  NULL);
1800  spintime_expire = jiffies + 100 * HZ;
1801  spintime = 1;
1802  }
1803  /* Wait 1 second for next try */
1804  msleep(1000);
1805  printk(".");
1806 
1807  /*
1808  * Wait for USB flash devices with slow firmware.
1809  * Yes, this sense key/ASC combination shouldn't
1810  * occur here. It's characteristic of these devices.
1811  */
1812  } else if (sense_valid &&
1813  sshdr.sense_key == UNIT_ATTENTION &&
1814  sshdr.asc == 0x28) {
1815  if (!spintime) {
1816  spintime_expire = jiffies + 5 * HZ;
1817  spintime = 1;
1818  }
1819  /* Wait 1 second for next try */
1820  msleep(1000);
1821  } else {
1822  /* we don't understand the sense code, so it's
1823  * probably pointless to loop */
1824  if(!spintime) {
1825  sd_printk(KERN_NOTICE, sdkp, "Unit Not Ready\n");
1826  sd_print_sense_hdr(sdkp, &sshdr);
1827  }
1828  break;
1829  }
1830 
1831  } while (spintime && time_before_eq(jiffies, spintime_expire));
1832 
1833  if (spintime) {
1834  if (scsi_status_is_good(the_result))
1835  printk("ready\n");
1836  else
1837  printk("not responding...\n");
1838  }
1839 }
1840 
1841 
1842 /*
1843  * Determine whether disk supports Data Integrity Field.
1844  */
1845 static int sd_read_protection_type(struct scsi_disk *sdkp, unsigned char *buffer)
1846 {
1847  struct scsi_device *sdp = sdkp->device;
1848  u8 type;
1849  int ret = 0;
1850 
1851  if (scsi_device_protection(sdp) == 0 || (buffer[12] & 1) == 0)
1852  return ret;
1853 
1854  type = ((buffer[12] >> 1) & 7) + 1; /* P_TYPE 0 = Type 1 */
1855 
1856  if (type > SD_DIF_TYPE3_PROTECTION)
1857  ret = -ENODEV;
1858  else if (scsi_host_dif_capable(sdp->host, type))
1859  ret = 1;
1860 
1861  if (sdkp->first_scan || type != sdkp->protection_type)
1862  switch (ret) {
1863  case -ENODEV:
1864  sd_printk(KERN_ERR, sdkp, "formatted with unsupported" \
1865  " protection type %u. Disabling disk!\n",
1866  type);
1867  break;
1868  case 1:
1869  sd_printk(KERN_NOTICE, sdkp,
1870  "Enabling DIF Type %u protection\n", type);
1871  break;
1872  case 0:
1873  sd_printk(KERN_NOTICE, sdkp,
1874  "Disabling DIF Type %u protection\n", type);
1875  break;
1876  }
1877 
1878  sdkp->protection_type = type;
1879 
1880  return ret;
1881 }
1882 
1883 static void read_capacity_error(struct scsi_disk *sdkp, struct scsi_device *sdp,
1884  struct scsi_sense_hdr *sshdr, int sense_valid,
1885  int the_result)
1886 {
1887  sd_print_result(sdkp, the_result);
1888  if (driver_byte(the_result) & DRIVER_SENSE)
1889  sd_print_sense_hdr(sdkp, sshdr);
1890  else
1891  sd_printk(KERN_NOTICE, sdkp, "Sense not available.\n");
1892 
1893  /*
1894  * Set dirty bit for removable devices if not ready -
1895  * sometimes drives will not report this properly.
1896  */
1897  if (sdp->removable &&
1898  sense_valid && sshdr->sense_key == NOT_READY)
1899  set_media_not_present(sdkp);
1900 
1901  /*
1902  * We used to set media_present to 0 here to indicate no media
1903  * in the drive, but some drives fail read capacity even with
1904  * media present, so we can't do that.
1905  */
1906  sdkp->capacity = 0; /* unknown mapped to zero - as usual */
1907 }
1908 
1909 #define RC16_LEN 32
1910 #if RC16_LEN > SD_BUF_SIZE
1911 #error RC16_LEN must not be more than SD_BUF_SIZE
1912 #endif
1913 
1914 #define READ_CAPACITY_RETRIES_ON_RESET 10
1915 
1916 static int read_capacity_16(struct scsi_disk *sdkp, struct scsi_device *sdp,
1917  unsigned char *buffer)
1918 {
1919  unsigned char cmd[16];
1920  struct scsi_sense_hdr sshdr;
1921  int sense_valid = 0;
1922  int the_result;
1923  int retries = 3, reset_retries = READ_CAPACITY_RETRIES_ON_RESET;
1924  unsigned int alignment;
1925  unsigned long long lba;
1926  unsigned sector_size;
1927 
1928  if (sdp->no_read_capacity_16)
1929  return -EINVAL;
1930 
1931  do {
1932  memset(cmd, 0, 16);
1933  cmd[0] = SERVICE_ACTION_IN;
1934  cmd[1] = SAI_READ_CAPACITY_16;
1935  cmd[13] = RC16_LEN;
1936  memset(buffer, 0, RC16_LEN);
1937 
1938  the_result = scsi_execute_req(sdp, cmd, DMA_FROM_DEVICE,
1939  buffer, RC16_LEN, &sshdr,
1940  SD_TIMEOUT, SD_MAX_RETRIES, NULL);
1941 
1942  if (media_not_present(sdkp, &sshdr))
1943  return -ENODEV;
1944 
1945  if (the_result) {
1946  sense_valid = scsi_sense_valid(&sshdr);
1947  if (sense_valid &&
1948  sshdr.sense_key == ILLEGAL_REQUEST &&
1949  (sshdr.asc == 0x20 || sshdr.asc == 0x24) &&
1950  sshdr.ascq == 0x00)
1951  /* Invalid Command Operation Code or
1952  * Invalid Field in CDB, just retry
1953  * silently with RC10 */
1954  return -EINVAL;
1955  if (sense_valid &&
1956  sshdr.sense_key == UNIT_ATTENTION &&
1957  sshdr.asc == 0x29 && sshdr.ascq == 0x00)
1958  /* Device reset might occur several times,
1959  * give it one more chance */
1960  if (--reset_retries > 0)
1961  continue;
1962  }
1963  retries--;
1964 
1965  } while (the_result && retries);
1966 
1967  if (the_result) {
1968  sd_printk(KERN_NOTICE, sdkp, "READ CAPACITY(16) failed\n");
1969  read_capacity_error(sdkp, sdp, &sshdr, sense_valid, the_result);
1970  return -EINVAL;
1971  }
1972 
1973  sector_size = get_unaligned_be32(&buffer[8]);
1974  lba = get_unaligned_be64(&buffer[0]);
1975 
1976  if (sd_read_protection_type(sdkp, buffer) < 0) {
1977  sdkp->capacity = 0;
1978  return -ENODEV;
1979  }
1980 
1981  if ((sizeof(sdkp->capacity) == 4) && (lba >= 0xffffffffULL)) {
1982  sd_printk(KERN_ERR, sdkp, "Too big for this kernel. Use a "
1983  "kernel compiled with support for large block "
1984  "devices.\n");
1985  sdkp->capacity = 0;
1986  return -EOVERFLOW;
1987  }
1988 
1989  /* Logical blocks per physical block exponent */
1990  sdkp->physical_block_size = (1 << (buffer[13] & 0xf)) * sector_size;
1991 
1992  /* Lowest aligned logical block */
1993  alignment = ((buffer[14] & 0x3f) << 8 | buffer[15]) * sector_size;
1994  blk_queue_alignment_offset(sdp->request_queue, alignment);
1995  if (alignment && sdkp->first_scan)
1996  sd_printk(KERN_NOTICE, sdkp,
1997  "physical block alignment offset: %u\n", alignment);
1998 
1999  if (buffer[14] & 0x80) { /* LBPME */
2000  sdkp->lbpme = 1;
2001 
2002  if (buffer[14] & 0x40) /* LBPRZ */
2003  sdkp->lbprz = 1;
2004 
2005  sd_config_discard(sdkp, SD_LBP_WS16);
2006  }
2007 
2008  sdkp->capacity = lba + 1;
2009  return sector_size;
2010 }
2011 
2012 static int read_capacity_10(struct scsi_disk *sdkp, struct scsi_device *sdp,
2013  unsigned char *buffer)
2014 {
2015  unsigned char cmd[16];
2016  struct scsi_sense_hdr sshdr;
2017  int sense_valid = 0;
2018  int the_result;
2019  int retries = 3, reset_retries = READ_CAPACITY_RETRIES_ON_RESET;
2020  sector_t lba;
2021  unsigned sector_size;
2022 
2023  do {
2024  cmd[0] = READ_CAPACITY;
2025  memset(&cmd[1], 0, 9);
2026  memset(buffer, 0, 8);
2027 
2028  the_result = scsi_execute_req(sdp, cmd, DMA_FROM_DEVICE,
2029  buffer, 8, &sshdr,
2030  SD_TIMEOUT, SD_MAX_RETRIES, NULL);
2031 
2032  if (media_not_present(sdkp, &sshdr))
2033  return -ENODEV;
2034 
2035  if (the_result) {
2036  sense_valid = scsi_sense_valid(&sshdr);
2037  if (sense_valid &&
2038  sshdr.sense_key == UNIT_ATTENTION &&
2039  sshdr.asc == 0x29 && sshdr.ascq == 0x00)
2040  /* Device reset might occur several times,
2041  * give it one more chance */
2042  if (--reset_retries > 0)
2043  continue;
2044  }
2045  retries--;
2046 
2047  } while (the_result && retries);
2048 
2049  if (the_result) {
2050  sd_printk(KERN_NOTICE, sdkp, "READ CAPACITY failed\n");
2051  read_capacity_error(sdkp, sdp, &sshdr, sense_valid, the_result);
2052  return -EINVAL;
2053  }
2054 
2055  sector_size = get_unaligned_be32(&buffer[4]);
2056  lba = get_unaligned_be32(&buffer[0]);
2057 
2058  if (sdp->no_read_capacity_16 && (lba == 0xffffffff)) {
2059  /* Some buggy (usb cardreader) devices return an lba of
2060  0xffffffff when the want to report a size of 0 (with
2061  which they really mean no media is present) */
2062  sdkp->capacity = 0;
2063  sdkp->physical_block_size = sector_size;
2064  return sector_size;
2065  }
2066 
2067  if ((sizeof(sdkp->capacity) == 4) && (lba == 0xffffffff)) {
2068  sd_printk(KERN_ERR, sdkp, "Too big for this kernel. Use a "
2069  "kernel compiled with support for large block "
2070  "devices.\n");
2071  sdkp->capacity = 0;
2072  return -EOVERFLOW;
2073  }
2074 
2075  sdkp->capacity = lba + 1;
2076  sdkp->physical_block_size = sector_size;
2077  return sector_size;
2078 }
2079 
2080 static int sd_try_rc16_first(struct scsi_device *sdp)
2081 {
2082  if (sdp->host->max_cmd_len < 16)
2083  return 0;
2084  if (sdp->try_rc_10_first)
2085  return 0;
2086  if (sdp->scsi_level > SCSI_SPC_2)
2087  return 1;
2088  if (scsi_device_protection(sdp))
2089  return 1;
2090  return 0;
2091 }
2092 
2093 /*
2094  * read disk capacity
2095  */
2096 static void
2097 sd_read_capacity(struct scsi_disk *sdkp, unsigned char *buffer)
2098 {
2099  int sector_size;
2100  struct scsi_device *sdp = sdkp->device;
2101  sector_t old_capacity = sdkp->capacity;
2102 
2103  if (sd_try_rc16_first(sdp)) {
2104  sector_size = read_capacity_16(sdkp, sdp, buffer);
2105  if (sector_size == -EOVERFLOW)
2106  goto got_data;
2107  if (sector_size == -ENODEV)
2108  return;
2109  if (sector_size < 0)
2110  sector_size = read_capacity_10(sdkp, sdp, buffer);
2111  if (sector_size < 0)
2112  return;
2113  } else {
2114  sector_size = read_capacity_10(sdkp, sdp, buffer);
2115  if (sector_size == -EOVERFLOW)
2116  goto got_data;
2117  if (sector_size < 0)
2118  return;
2119  if ((sizeof(sdkp->capacity) > 4) &&
2120  (sdkp->capacity > 0xffffffffULL)) {
2121  int old_sector_size = sector_size;
2122  sd_printk(KERN_NOTICE, sdkp, "Very big device. "
2123  "Trying to use READ CAPACITY(16).\n");
2124  sector_size = read_capacity_16(sdkp, sdp, buffer);
2125  if (sector_size < 0) {
2126  sd_printk(KERN_NOTICE, sdkp,
2127  "Using 0xffffffff as device size\n");
2128  sdkp->capacity = 1 + (sector_t) 0xffffffff;
2129  sector_size = old_sector_size;
2130  goto got_data;
2131  }
2132  }
2133  }
2134 
2135  /* Some devices are known to return the total number of blocks,
2136  * not the highest block number. Some devices have versions
2137  * which do this and others which do not. Some devices we might
2138  * suspect of doing this but we don't know for certain.
2139  *
2140  * If we know the reported capacity is wrong, decrement it. If
2141  * we can only guess, then assume the number of blocks is even
2142  * (usually true but not always) and err on the side of lowering
2143  * the capacity.
2144  */
2145  if (sdp->fix_capacity ||
2146  (sdp->guess_capacity && (sdkp->capacity & 0x01))) {
2147  sd_printk(KERN_INFO, sdkp, "Adjusting the sector count "
2148  "from its reported value: %llu\n",
2149  (unsigned long long) sdkp->capacity);
2150  --sdkp->capacity;
2151  }
2152 
2153 got_data:
2154  if (sector_size == 0) {
2155  sector_size = 512;
2156  sd_printk(KERN_NOTICE, sdkp, "Sector size 0 reported, "
2157  "assuming 512.\n");
2158  }
2159 
2160  if (sector_size != 512 &&
2161  sector_size != 1024 &&
2162  sector_size != 2048 &&
2163  sector_size != 4096 &&
2164  sector_size != 256) {
2165  sd_printk(KERN_NOTICE, sdkp, "Unsupported sector size %d.\n",
2166  sector_size);
2167  /*
2168  * The user might want to re-format the drive with
2169  * a supported sectorsize. Once this happens, it
2170  * would be relatively trivial to set the thing up.
2171  * For this reason, we leave the thing in the table.
2172  */
2173  sdkp->capacity = 0;
2174  /*
2175  * set a bogus sector size so the normal read/write
2176  * logic in the block layer will eventually refuse any
2177  * request on this device without tripping over power
2178  * of two sector size assumptions
2179  */
2180  sector_size = 512;
2181  }
2182  blk_queue_logical_block_size(sdp->request_queue, sector_size);
2183 
2184  {
2185  char cap_str_2[10], cap_str_10[10];
2186  u64 sz = (u64)sdkp->capacity << ilog2(sector_size);
2187 
2188  string_get_size(sz, STRING_UNITS_2, cap_str_2,
2189  sizeof(cap_str_2));
2190  string_get_size(sz, STRING_UNITS_10, cap_str_10,
2191  sizeof(cap_str_10));
2192 
2193  if (sdkp->first_scan || old_capacity != sdkp->capacity) {
2194  sd_printk(KERN_NOTICE, sdkp,
2195  "%llu %d-byte logical blocks: (%s/%s)\n",
2196  (unsigned long long)sdkp->capacity,
2197  sector_size, cap_str_10, cap_str_2);
2198 
2199  if (sdkp->physical_block_size != sector_size)
2200  sd_printk(KERN_NOTICE, sdkp,
2201  "%u-byte physical blocks\n",
2202  sdkp->physical_block_size);
2203  }
2204  }
2205 
2206  /* Rescale capacity to 512-byte units */
2207  if (sector_size == 4096)
2208  sdkp->capacity <<= 3;
2209  else if (sector_size == 2048)
2210  sdkp->capacity <<= 2;
2211  else if (sector_size == 1024)
2212  sdkp->capacity <<= 1;
2213  else if (sector_size == 256)
2214  sdkp->capacity >>= 1;
2215 
2216  blk_queue_physical_block_size(sdp->request_queue,
2217  sdkp->physical_block_size);
2218  sdkp->device->sector_size = sector_size;
2219 }
2220 
2221 /* called with buffer of length 512 */
2222 static inline int
2223 sd_do_mode_sense(struct scsi_device *sdp, int dbd, int modepage,
2224  unsigned char *buffer, int len, struct scsi_mode_data *data,
2225  struct scsi_sense_hdr *sshdr)
2226 {
2227  return scsi_mode_sense(sdp, dbd, modepage, buffer, len,
2228  SD_TIMEOUT, SD_MAX_RETRIES, data,
2229  sshdr);
2230 }
2231 
2232 /*
2233  * read write protect setting, if possible - called only in sd_revalidate_disk()
2234  * called with buffer of length SD_BUF_SIZE
2235  */
2236 static void
2237 sd_read_write_protect_flag(struct scsi_disk *sdkp, unsigned char *buffer)
2238 {
2239  int res;
2240  struct scsi_device *sdp = sdkp->device;
2241  struct scsi_mode_data data;
2242  int old_wp = sdkp->write_prot;
2243 
2244  set_disk_ro(sdkp->disk, 0);
2245  if (sdp->skip_ms_page_3f) {
2246  sd_printk(KERN_NOTICE, sdkp, "Assuming Write Enabled\n");
2247  return;
2248  }
2249 
2250  if (sdp->use_192_bytes_for_3f) {
2251  res = sd_do_mode_sense(sdp, 0, 0x3F, buffer, 192, &data, NULL);
2252  } else {
2253  /*
2254  * First attempt: ask for all pages (0x3F), but only 4 bytes.
2255  * We have to start carefully: some devices hang if we ask
2256  * for more than is available.
2257  */
2258  res = sd_do_mode_sense(sdp, 0, 0x3F, buffer, 4, &data, NULL);
2259 
2260  /*
2261  * Second attempt: ask for page 0 When only page 0 is
2262  * implemented, a request for page 3F may return Sense Key
2263  * 5: Illegal Request, Sense Code 24: Invalid field in
2264  * CDB.
2265  */
2266  if (!scsi_status_is_good(res))
2267  res = sd_do_mode_sense(sdp, 0, 0, buffer, 4, &data, NULL);
2268 
2269  /*
2270  * Third attempt: ask 255 bytes, as we did earlier.
2271  */
2272  if (!scsi_status_is_good(res))
2273  res = sd_do_mode_sense(sdp, 0, 0x3F, buffer, 255,
2274  &data, NULL);
2275  }
2276 
2277  if (!scsi_status_is_good(res)) {
2278  sd_printk(KERN_WARNING, sdkp,
2279  "Test WP failed, assume Write Enabled\n");
2280  } else {
2281  sdkp->write_prot = ((data.device_specific & 0x80) != 0);
2282  set_disk_ro(sdkp->disk, sdkp->write_prot);
2283  if (sdkp->first_scan || old_wp != sdkp->write_prot) {
2284  sd_printk(KERN_NOTICE, sdkp, "Write Protect is %s\n",
2285  sdkp->write_prot ? "on" : "off");
2286  sd_printk(KERN_DEBUG, sdkp,
2287  "Mode Sense: %02x %02x %02x %02x\n",
2288  buffer[0], buffer[1], buffer[2], buffer[3]);
2289  }
2290  }
2291 }
2292 
2293 /*
2294  * sd_read_cache_type - called only from sd_revalidate_disk()
2295  * called with buffer of length SD_BUF_SIZE
2296  */
2297 static void
2298 sd_read_cache_type(struct scsi_disk *sdkp, unsigned char *buffer)
2299 {
2300  int len = 0, res;
2301  struct scsi_device *sdp = sdkp->device;
2302 
2303  int dbd;
2304  int modepage;
2305  int first_len;
2306  struct scsi_mode_data data;
2307  struct scsi_sense_hdr sshdr;
2308  int old_wce = sdkp->WCE;
2309  int old_rcd = sdkp->RCD;
2310  int old_dpofua = sdkp->DPOFUA;
2311 
2312  first_len = 4;
2313  if (sdp->skip_ms_page_8) {
2314  if (sdp->type == TYPE_RBC)
2315  goto defaults;
2316  else {
2317  if (sdp->skip_ms_page_3f)
2318  goto defaults;
2319  modepage = 0x3F;
2320  if (sdp->use_192_bytes_for_3f)
2321  first_len = 192;
2322  dbd = 0;
2323  }
2324  } else if (sdp->type == TYPE_RBC) {
2325  modepage = 6;
2326  dbd = 8;
2327  } else {
2328  modepage = 8;
2329  dbd = 0;
2330  }
2331 
2332  /* cautiously ask */
2333  res = sd_do_mode_sense(sdp, dbd, modepage, buffer, first_len,
2334  &data, &sshdr);
2335 
2336  if (!scsi_status_is_good(res))
2337  goto bad_sense;
2338 
2339  if (!data.header_length) {
2340  modepage = 6;
2341  first_len = 0;
2342  sd_printk(KERN_ERR, sdkp, "Missing header in MODE_SENSE response\n");
2343  }
2344 
2345  /* that went OK, now ask for the proper length */
2346  len = data.length;
2347 
2348  /*
2349  * We're only interested in the first three bytes, actually.
2350  * But the data cache page is defined for the first 20.
2351  */
2352  if (len < 3)
2353  goto bad_sense;
2354  else if (len > SD_BUF_SIZE) {
2355  sd_printk(KERN_NOTICE, sdkp, "Truncating mode parameter "
2356  "data from %d to %d bytes\n", len, SD_BUF_SIZE);
2357  len = SD_BUF_SIZE;
2358  }
2359  if (modepage == 0x3F && sdp->use_192_bytes_for_3f)
2360  len = 192;
2361 
2362  /* Get the data */
2363  if (len > first_len)
2364  res = sd_do_mode_sense(sdp, dbd, modepage, buffer, len,
2365  &data, &sshdr);
2366 
2367  if (scsi_status_is_good(res)) {
2368  int offset = data.header_length + data.block_descriptor_length;
2369 
2370  while (offset < len) {
2371  u8 page_code = buffer[offset] & 0x3F;
2372  u8 spf = buffer[offset] & 0x40;
2373 
2374  if (page_code == 8 || page_code == 6) {
2375  /* We're interested only in the first 3 bytes.
2376  */
2377  if (len - offset <= 2) {
2378  sd_printk(KERN_ERR, sdkp, "Incomplete "
2379  "mode parameter data\n");
2380  goto defaults;
2381  } else {
2382  modepage = page_code;
2383  goto Page_found;
2384  }
2385  } else {
2386  /* Go to the next page */
2387  if (spf && len - offset > 3)
2388  offset += 4 + (buffer[offset+2] << 8) +
2389  buffer[offset+3];
2390  else if (!spf && len - offset > 1)
2391  offset += 2 + buffer[offset+1];
2392  else {
2393  sd_printk(KERN_ERR, sdkp, "Incomplete "
2394  "mode parameter data\n");
2395  goto defaults;
2396  }
2397  }
2398  }
2399 
2400  if (modepage == 0x3F) {
2401  sd_printk(KERN_ERR, sdkp, "No Caching mode page "
2402  "present\n");
2403  goto defaults;
2404  } else if ((buffer[offset] & 0x3f) != modepage) {
2405  sd_printk(KERN_ERR, sdkp, "Got wrong page\n");
2406  goto defaults;
2407  }
2408  Page_found:
2409  if (modepage == 8) {
2410  sdkp->WCE = ((buffer[offset + 2] & 0x04) != 0);
2411  sdkp->RCD = ((buffer[offset + 2] & 0x01) != 0);
2412  } else {
2413  sdkp->WCE = ((buffer[offset + 2] & 0x01) == 0);
2414  sdkp->RCD = 0;
2415  }
2416 
2417  sdkp->DPOFUA = (data.device_specific & 0x10) != 0;
2418  if (sdkp->DPOFUA && !sdkp->device->use_10_for_rw) {
2419  sd_printk(KERN_NOTICE, sdkp,
2420  "Uses READ/WRITE(6), disabling FUA\n");
2421  sdkp->DPOFUA = 0;
2422  }
2423 
2424  if (sdkp->first_scan || old_wce != sdkp->WCE ||
2425  old_rcd != sdkp->RCD || old_dpofua != sdkp->DPOFUA)
2426  sd_printk(KERN_NOTICE, sdkp,
2427  "Write cache: %s, read cache: %s, %s\n",
2428  sdkp->WCE ? "enabled" : "disabled",
2429  sdkp->RCD ? "disabled" : "enabled",
2430  sdkp->DPOFUA ? "supports DPO and FUA"
2431  : "doesn't support DPO or FUA");
2432 
2433  return;
2434  }
2435 
2436 bad_sense:
2437  if (scsi_sense_valid(&sshdr) &&
2438  sshdr.sense_key == ILLEGAL_REQUEST &&
2439  sshdr.asc == 0x24 && sshdr.ascq == 0x0)
2440  /* Invalid field in CDB */
2441  sd_printk(KERN_NOTICE, sdkp, "Cache data unavailable\n");
2442  else
2443  sd_printk(KERN_ERR, sdkp, "Asking for cache data failed\n");
2444 
2445 defaults:
2446  if (sdp->wce_default_on) {
2447  sd_printk(KERN_NOTICE, sdkp, "Assuming drive cache: write back\n");
2448  sdkp->WCE = 1;
2449  } else {
2450  sd_printk(KERN_ERR, sdkp, "Assuming drive cache: write through\n");
2451  sdkp->WCE = 0;
2452  }
2453  sdkp->RCD = 0;
2454  sdkp->DPOFUA = 0;
2455 }
2456 
2457 /*
2458  * The ATO bit indicates whether the DIF application tag is available
2459  * for use by the operating system.
2460  */
2461 static void sd_read_app_tag_own(struct scsi_disk *sdkp, unsigned char *buffer)
2462 {
2463  int res, offset;
2464  struct scsi_device *sdp = sdkp->device;
2465  struct scsi_mode_data data;
2466  struct scsi_sense_hdr sshdr;
2467 
2468  if (sdp->type != TYPE_DISK)
2469  return;
2470 
2471  if (sdkp->protection_type == 0)
2472  return;
2473 
2474  res = scsi_mode_sense(sdp, 1, 0x0a, buffer, 36, SD_TIMEOUT,
2475  SD_MAX_RETRIES, &data, &sshdr);
2476 
2477  if (!scsi_status_is_good(res) || !data.header_length ||
2478  data.length < 6) {
2479  sd_printk(KERN_WARNING, sdkp,
2480  "getting Control mode page failed, assume no ATO\n");
2481 
2482  if (scsi_sense_valid(&sshdr))
2483  sd_print_sense_hdr(sdkp, &sshdr);
2484 
2485  return;
2486  }
2487 
2488  offset = data.header_length + data.block_descriptor_length;
2489 
2490  if ((buffer[offset] & 0x3f) != 0x0a) {
2491  sd_printk(KERN_ERR, sdkp, "ATO Got wrong page\n");
2492  return;
2493  }
2494 
2495  if ((buffer[offset + 5] & 0x80) == 0)
2496  return;
2497 
2498  sdkp->ATO = 1;
2499 
2500  return;
2501 }
2502 
2507 static void sd_read_block_limits(struct scsi_disk *sdkp)
2508 {
2509  unsigned int sector_sz = sdkp->device->sector_size;
2510  const int vpd_len = 64;
2511  unsigned char *buffer = kmalloc(vpd_len, GFP_KERNEL);
2512 
2513  if (!buffer ||
2514  /* Block Limits VPD */
2515  scsi_get_vpd_page(sdkp->device, 0xb0, buffer, vpd_len))
2516  goto out;
2517 
2518  blk_queue_io_min(sdkp->disk->queue,
2519  get_unaligned_be16(&buffer[6]) * sector_sz);
2520  blk_queue_io_opt(sdkp->disk->queue,
2521  get_unaligned_be32(&buffer[12]) * sector_sz);
2522 
2523  if (buffer[3] == 0x3c) {
2524  unsigned int lba_count, desc_count;
2525 
2526  sdkp->max_ws_blocks = (u32)get_unaligned_be64(&buffer[36]);
2527 
2528  if (!sdkp->lbpme)
2529  goto out;
2530 
2531  lba_count = get_unaligned_be32(&buffer[20]);
2532  desc_count = get_unaligned_be32(&buffer[24]);
2533 
2534  if (lba_count && desc_count)
2535  sdkp->max_unmap_blocks = lba_count;
2536 
2537  sdkp->unmap_granularity = get_unaligned_be32(&buffer[28]);
2538 
2539  if (buffer[32] & 0x80)
2540  sdkp->unmap_alignment =
2541  get_unaligned_be32(&buffer[32]) & ~(1 << 31);
2542 
2543  if (!sdkp->lbpvpd) { /* LBP VPD page not provided */
2544 
2545  if (sdkp->max_unmap_blocks)
2546  sd_config_discard(sdkp, SD_LBP_UNMAP);
2547  else
2548  sd_config_discard(sdkp, SD_LBP_WS16);
2549 
2550  } else { /* LBP VPD page tells us what to use */
2551 
2552  if (sdkp->lbpu && sdkp->max_unmap_blocks)
2553  sd_config_discard(sdkp, SD_LBP_UNMAP);
2554  else if (sdkp->lbpws)
2555  sd_config_discard(sdkp, SD_LBP_WS16);
2556  else if (sdkp->lbpws10)
2557  sd_config_discard(sdkp, SD_LBP_WS10);
2558  else
2559  sd_config_discard(sdkp, SD_LBP_DISABLE);
2560  }
2561  }
2562 
2563  out:
2564  kfree(buffer);
2565 }
2566 
2571 static void sd_read_block_characteristics(struct scsi_disk *sdkp)
2572 {
2573  unsigned char *buffer;
2574  u16 rot;
2575  const int vpd_len = 64;
2576 
2577  buffer = kmalloc(vpd_len, GFP_KERNEL);
2578 
2579  if (!buffer ||
2580  /* Block Device Characteristics VPD */
2581  scsi_get_vpd_page(sdkp->device, 0xb1, buffer, vpd_len))
2582  goto out;
2583 
2584  rot = get_unaligned_be16(&buffer[4]);
2585 
2586  if (rot == 1)
2587  queue_flag_set_unlocked(QUEUE_FLAG_NONROT, sdkp->disk->queue);
2588 
2589  out:
2590  kfree(buffer);
2591 }
2592 
2597 static void sd_read_block_provisioning(struct scsi_disk *sdkp)
2598 {
2599  unsigned char *buffer;
2600  const int vpd_len = 8;
2601 
2602  if (sdkp->lbpme == 0)
2603  return;
2604 
2605  buffer = kmalloc(vpd_len, GFP_KERNEL);
2606 
2607  if (!buffer || scsi_get_vpd_page(sdkp->device, 0xb2, buffer, vpd_len))
2608  goto out;
2609 
2610  sdkp->lbpvpd = 1;
2611  sdkp->lbpu = (buffer[5] >> 7) & 1; /* UNMAP */
2612  sdkp->lbpws = (buffer[5] >> 6) & 1; /* WRITE SAME(16) with UNMAP */
2613  sdkp->lbpws10 = (buffer[5] >> 5) & 1; /* WRITE SAME(10) with UNMAP */
2614 
2615  out:
2616  kfree(buffer);
2617 }
2618 
2619 static void sd_read_write_same(struct scsi_disk *sdkp, unsigned char *buffer)
2620 {
2621  if (scsi_report_opcode(sdkp->device, buffer, SD_BUF_SIZE,
2622  WRITE_SAME_16))
2623  sdkp->ws16 = 1;
2624 }
2625 
2626 static int sd_try_extended_inquiry(struct scsi_device *sdp)
2627 {
2628  /*
2629  * Although VPD inquiries can go to SCSI-2 type devices,
2630  * some USB ones crash on receiving them, and the pages
2631  * we currently ask for are for SPC-3 and beyond
2632  */
2633  if (sdp->scsi_level > SCSI_SPC_2 && !sdp->skip_vpd_pages)
2634  return 1;
2635  return 0;
2636 }
2637 
2643 static int sd_revalidate_disk(struct gendisk *disk)
2644 {
2645  struct scsi_disk *sdkp = scsi_disk(disk);
2646  struct scsi_device *sdp = sdkp->device;
2647  unsigned char *buffer;
2648  unsigned flush = 0;
2649 
2650  SCSI_LOG_HLQUEUE(3, sd_printk(KERN_INFO, sdkp,
2651  "sd_revalidate_disk\n"));
2652 
2653  /*
2654  * If the device is offline, don't try and read capacity or any
2655  * of the other niceties.
2656  */
2657  if (!scsi_device_online(sdp))
2658  goto out;
2659 
2660  buffer = kmalloc(SD_BUF_SIZE, GFP_KERNEL);
2661  if (!buffer) {
2662  sd_printk(KERN_WARNING, sdkp, "sd_revalidate_disk: Memory "
2663  "allocation failure.\n");
2664  goto out;
2665  }
2666 
2667  sd_spinup_disk(sdkp);
2668 
2669  /*
2670  * Without media there is no reason to ask; moreover, some devices
2671  * react badly if we do.
2672  */
2673  if (sdkp->media_present) {
2674  sd_read_capacity(sdkp, buffer);
2675 
2676  if (sd_try_extended_inquiry(sdp)) {
2677  sd_read_block_provisioning(sdkp);
2678  sd_read_block_limits(sdkp);
2679  sd_read_block_characteristics(sdkp);
2680  }
2681 
2682  sd_read_write_protect_flag(sdkp, buffer);
2683  sd_read_cache_type(sdkp, buffer);
2684  sd_read_app_tag_own(sdkp, buffer);
2685  sd_read_write_same(sdkp, buffer);
2686  }
2687 
2688  sdkp->first_scan = 0;
2689 
2690  /*
2691  * We now have all cache related info, determine how we deal
2692  * with flush requests.
2693  */
2694  if (sdkp->WCE) {
2695  flush |= REQ_FLUSH;
2696  if (sdkp->DPOFUA)
2697  flush |= REQ_FUA;
2698  }
2699 
2700  blk_queue_flush(sdkp->disk->queue, flush);
2701 
2702  set_capacity(disk, sdkp->capacity);
2703  sd_config_write_same(sdkp);
2704  kfree(buffer);
2705 
2706  out:
2707  return 0;
2708 }
2709 
2722 static void sd_unlock_native_capacity(struct gendisk *disk)
2723 {
2724  struct scsi_device *sdev = scsi_disk(disk)->device;
2725 
2726  if (sdev->host->hostt->unlock_native_capacity)
2727  sdev->host->hostt->unlock_native_capacity(sdev);
2728 }
2729 
2752 static int sd_format_disk_name(char *prefix, int index, char *buf, int buflen)
2753 {
2754  const int base = 'z' - 'a' + 1;
2755  char *begin = buf + strlen(prefix);
2756  char *end = buf + buflen;
2757  char *p;
2758  int unit;
2759 
2760  p = end - 1;
2761  *p = '\0';
2762  unit = base;
2763  do {
2764  if (p == begin)
2765  return -EINVAL;
2766  *--p = 'a' + (index % unit);
2767  index = (index / unit) - 1;
2768  } while (index >= 0);
2769 
2770  memmove(begin, p, end - p);
2771  memcpy(buf, prefix, strlen(prefix));
2772 
2773  return 0;
2774 }
2775 
2776 /*
2777  * The asynchronous part of sd_probe
2778  */
2779 static void sd_probe_async(void *data, async_cookie_t cookie)
2780 {
2781  struct scsi_disk *sdkp = data;
2782  struct scsi_device *sdp;
2783  struct gendisk *gd;
2784  u32 index;
2785  struct device *dev;
2786 
2787  sdp = sdkp->device;
2788  gd = sdkp->disk;
2789  index = sdkp->index;
2790  dev = &sdp->sdev_gendev;
2791 
2792  gd->major = sd_major((index & 0xf0) >> 4);
2793  gd->first_minor = ((index & 0xf) << 4) | (index & 0xfff00);
2794  gd->minors = SD_MINORS;
2795 
2796  gd->fops = &sd_fops;
2797  gd->private_data = &sdkp->driver;
2798  gd->queue = sdkp->device->request_queue;
2799 
2800  /* defaults, until the device tells us otherwise */
2801  sdp->sector_size = 512;
2802  sdkp->capacity = 0;
2803  sdkp->media_present = 1;
2804  sdkp->write_prot = 0;
2805  sdkp->WCE = 0;
2806  sdkp->RCD = 0;
2807  sdkp->ATO = 0;
2808  sdkp->first_scan = 1;
2809  sdkp->max_medium_access_timeouts = SD_MAX_MEDIUM_TIMEOUTS;
2810 
2811  sd_revalidate_disk(gd);
2812 
2813  blk_queue_prep_rq(sdp->request_queue, sd_prep_fn);
2814  blk_queue_unprep_rq(sdp->request_queue, sd_unprep_fn);
2815 
2816  gd->driverfs_dev = &sdp->sdev_gendev;
2817  gd->flags = GENHD_FL_EXT_DEVT;
2818  if (sdp->removable) {
2819  gd->flags |= GENHD_FL_REMOVABLE;
2820  gd->events |= DISK_EVENT_MEDIA_CHANGE;
2821  }
2822 
2823  add_disk(gd);
2824  if (sdkp->capacity)
2825  sd_dif_config_host(sdkp);
2826 
2827  sd_revalidate_disk(gd);
2828 
2829  sd_printk(KERN_NOTICE, sdkp, "Attached SCSI %sdisk\n",
2830  sdp->removable ? "removable " : "");
2831  scsi_autopm_put_device(sdp);
2832  put_device(&sdkp->dev);
2833 }
2834 
2853 static int sd_probe(struct device *dev)
2854 {
2855  struct scsi_device *sdp = to_scsi_device(dev);
2856  struct scsi_disk *sdkp;
2857  struct gendisk *gd;
2858  int index;
2859  int error;
2860 
2861  error = -ENODEV;
2862  if (sdp->type != TYPE_DISK && sdp->type != TYPE_MOD && sdp->type != TYPE_RBC)
2863  goto out;
2864 
2865  SCSI_LOG_HLQUEUE(3, sdev_printk(KERN_INFO, sdp,
2866  "sd_probe\n"));
2867 
2868  error = -ENOMEM;
2869  sdkp = kzalloc(sizeof(*sdkp), GFP_KERNEL);
2870  if (!sdkp)
2871  goto out;
2872 
2873  gd = alloc_disk(SD_MINORS);
2874  if (!gd)
2875  goto out_free;
2876 
2877  do {
2878  if (!ida_pre_get(&sd_index_ida, GFP_KERNEL))
2879  goto out_put;
2880 
2881  spin_lock(&sd_index_lock);
2882  error = ida_get_new(&sd_index_ida, &index);
2883  spin_unlock(&sd_index_lock);
2884  } while (error == -EAGAIN);
2885 
2886  if (error) {
2887  sdev_printk(KERN_WARNING, sdp, "sd_probe: memory exhausted.\n");
2888  goto out_put;
2889  }
2890 
2891  error = sd_format_disk_name("sd", index, gd->disk_name, DISK_NAME_LEN);
2892  if (error) {
2893  sdev_printk(KERN_WARNING, sdp, "SCSI disk (sd) name length exceeded.\n");
2894  goto out_free_index;
2895  }
2896 
2897  sdkp->device = sdp;
2898  sdkp->driver = &sd_template;
2899  sdkp->disk = gd;
2900  sdkp->index = index;
2901  atomic_set(&sdkp->openers, 0);
2902  atomic_set(&sdkp->device->ioerr_cnt, 0);
2903 
2904  if (!sdp->request_queue->rq_timeout) {
2905  if (sdp->type != TYPE_MOD)
2906  blk_queue_rq_timeout(sdp->request_queue, SD_TIMEOUT);
2907  else
2908  blk_queue_rq_timeout(sdp->request_queue,
2909  SD_MOD_TIMEOUT);
2910  }
2911 
2912  device_initialize(&sdkp->dev);
2913  sdkp->dev.parent = dev;
2914  sdkp->dev.class = &sd_disk_class;
2915  dev_set_name(&sdkp->dev, dev_name(dev));
2916 
2917  if (device_add(&sdkp->dev))
2918  goto out_free_index;
2919 
2920  get_device(dev);
2921  dev_set_drvdata(dev, sdkp);
2922 
2923  get_device(&sdkp->dev); /* prevent release before async_schedule */
2924  async_schedule_domain(sd_probe_async, sdkp, &scsi_sd_probe_domain);
2925 
2926  return 0;
2927 
2928  out_free_index:
2929  spin_lock(&sd_index_lock);
2930  ida_remove(&sd_index_ida, index);
2931  spin_unlock(&sd_index_lock);
2932  out_put:
2933  put_disk(gd);
2934  out_free:
2935  kfree(sdkp);
2936  out:
2937  return error;
2938 }
2939 
2951 static int sd_remove(struct device *dev)
2952 {
2953  struct scsi_disk *sdkp;
2954 
2955  sdkp = dev_get_drvdata(dev);
2956  scsi_autopm_get_device(sdkp->device);
2957 
2958  async_synchronize_full_domain(&scsi_sd_probe_domain);
2959  blk_queue_prep_rq(sdkp->device->request_queue, scsi_prep_fn);
2960  blk_queue_unprep_rq(sdkp->device->request_queue, NULL);
2961  device_del(&sdkp->dev);
2962  del_gendisk(sdkp->disk);
2963  sd_shutdown(dev);
2964 
2965  mutex_lock(&sd_ref_mutex);
2966  dev_set_drvdata(dev, NULL);
2967  put_device(&sdkp->dev);
2968  mutex_unlock(&sd_ref_mutex);
2969 
2970  return 0;
2971 }
2972 
2982 static void scsi_disk_release(struct device *dev)
2983 {
2984  struct scsi_disk *sdkp = to_scsi_disk(dev);
2985  struct gendisk *disk = sdkp->disk;
2986 
2987  spin_lock(&sd_index_lock);
2988  ida_remove(&sd_index_ida, sdkp->index);
2989  spin_unlock(&sd_index_lock);
2990 
2991  disk->private_data = NULL;
2992  put_disk(disk);
2993  put_device(&sdkp->device->sdev_gendev);
2994 
2995  kfree(sdkp);
2996 }
2997 
2998 static int sd_start_stop_device(struct scsi_disk *sdkp, int start)
2999 {
3000  unsigned char cmd[6] = { START_STOP }; /* START_VALID */
3001  struct scsi_sense_hdr sshdr;
3002  struct scsi_device *sdp = sdkp->device;
3003  int res;
3004 
3005  if (start)
3006  cmd[4] |= 1; /* START */
3007 
3008  if (sdp->start_stop_pwr_cond)
3009  cmd[4] |= start ? 1 << 4 : 3 << 4; /* Active or Standby */
3010 
3011  if (!scsi_device_online(sdp))
3012  return -ENODEV;
3013 
3014  res = scsi_execute_req(sdp, cmd, DMA_NONE, NULL, 0, &sshdr,
3015  SD_TIMEOUT, SD_MAX_RETRIES, NULL);
3016  if (res) {
3017  sd_printk(KERN_WARNING, sdkp, "START_STOP FAILED\n");
3018  sd_print_result(sdkp, res);
3019  if (driver_byte(res) & DRIVER_SENSE)
3020  sd_print_sense_hdr(sdkp, &sshdr);
3021  }
3022 
3023  return res;
3024 }
3025 
3026 /*
3027  * Send a SYNCHRONIZE CACHE instruction down to the device through
3028  * the normal SCSI command structure. Wait for the command to
3029  * complete.
3030  */
3031 static void sd_shutdown(struct device *dev)
3032 {
3033  struct scsi_disk *sdkp = scsi_disk_get_from_dev(dev);
3034 
3035  if (!sdkp)
3036  return; /* this can happen */
3037 
3038  if (pm_runtime_suspended(dev))
3039  goto exit;
3040 
3041  if (sdkp->WCE) {
3042  sd_printk(KERN_NOTICE, sdkp, "Synchronizing SCSI cache\n");
3043  sd_sync_cache(sdkp);
3044  }
3045 
3046  if (system_state != SYSTEM_RESTART && sdkp->device->manage_start_stop) {
3047  sd_printk(KERN_NOTICE, sdkp, "Stopping disk\n");
3048  sd_start_stop_device(sdkp, 0);
3049  }
3050 
3051 exit:
3052  scsi_disk_put(sdkp);
3053 }
3054 
3055 static int sd_suspend(struct device *dev, pm_message_t mesg)
3056 {
3057  struct scsi_disk *sdkp = scsi_disk_get_from_dev(dev);
3058  int ret = 0;
3059 
3060  if (!sdkp)
3061  return 0; /* this can happen */
3062 
3063  if (sdkp->WCE) {
3064  sd_printk(KERN_NOTICE, sdkp, "Synchronizing SCSI cache\n");
3065  ret = sd_sync_cache(sdkp);
3066  if (ret)
3067  goto done;
3068  }
3069 
3070  if ((mesg.event & PM_EVENT_SLEEP) && sdkp->device->manage_start_stop) {
3071  sd_printk(KERN_NOTICE, sdkp, "Stopping disk\n");
3072  ret = sd_start_stop_device(sdkp, 0);
3073  }
3074 
3075 done:
3076  scsi_disk_put(sdkp);
3077  return ret;
3078 }
3079 
3080 static int sd_resume(struct device *dev)
3081 {
3082  struct scsi_disk *sdkp = scsi_disk_get_from_dev(dev);
3083  int ret = 0;
3084 
3085  if (!sdkp->device->manage_start_stop)
3086  goto done;
3087 
3088  sd_printk(KERN_NOTICE, sdkp, "Starting disk\n");
3089  ret = sd_start_stop_device(sdkp, 1);
3090 
3091 done:
3092  scsi_disk_put(sdkp);
3093  return ret;
3094 }
3095 
3102 static int __init init_sd(void)
3103 {
3104  int majors = 0, i, err;
3105 
3106  SCSI_LOG_HLQUEUE(3, printk("init_sd: sd driver entry point\n"));
3107 
3108  for (i = 0; i < SD_MAJORS; i++)
3109  if (register_blkdev(sd_major(i), "sd") == 0)
3110  majors++;
3111 
3112  if (!majors)
3113  return -ENODEV;
3114 
3115  err = class_register(&sd_disk_class);
3116  if (err)
3117  goto err_out;
3118 
3119  err = scsi_register_driver(&sd_template.gendrv);
3120  if (err)
3121  goto err_out_class;
3122 
3123  sd_cdb_cache = kmem_cache_create("sd_ext_cdb", SD_EXT_CDB_SIZE,
3124  0, 0, NULL);
3125  if (!sd_cdb_cache) {
3126  printk(KERN_ERR "sd: can't init extended cdb cache\n");
3127  goto err_out_class;
3128  }
3129 
3130  sd_cdb_pool = mempool_create_slab_pool(SD_MEMPOOL_SIZE, sd_cdb_cache);
3131  if (!sd_cdb_pool) {
3132  printk(KERN_ERR "sd: can't init extended cdb pool\n");
3133  goto err_out_cache;
3134  }
3135 
3136  return 0;
3137 
3138 err_out_cache:
3139  kmem_cache_destroy(sd_cdb_cache);
3140 
3141 err_out_class:
3142  class_unregister(&sd_disk_class);
3143 err_out:
3144  for (i = 0; i < SD_MAJORS; i++)
3145  unregister_blkdev(sd_major(i), "sd");
3146  return err;
3147 }
3148 
3154 static void __exit exit_sd(void)
3155 {
3156  int i;
3157 
3158  SCSI_LOG_HLQUEUE(3, printk("exit_sd: exiting sd driver\n"));
3159 
3160  mempool_destroy(sd_cdb_pool);
3161  kmem_cache_destroy(sd_cdb_cache);
3162 
3163  scsi_unregister_driver(&sd_template.gendrv);
3164  class_unregister(&sd_disk_class);
3165 
3166  for (i = 0; i < SD_MAJORS; i++)
3167  unregister_blkdev(sd_major(i), "sd");
3168 }
3169 
3170 module_init(init_sd);
3171 module_exit(exit_sd);
3172 
3173 static void sd_print_sense_hdr(struct scsi_disk *sdkp,
3174  struct scsi_sense_hdr *sshdr)
3175 {
3176  sd_printk(KERN_INFO, sdkp, " ");
3177  scsi_show_sense_hdr(sshdr);
3178  sd_printk(KERN_INFO, sdkp, " ");
3179  scsi_show_extd_sense(sshdr->asc, sshdr->ascq);
3180 }
3181 
3182 static void sd_print_result(struct scsi_disk *sdkp, int result)
3183 {
3184  sd_printk(KERN_INFO, sdkp, " ");
3185  scsi_show_result(result);
3186 }
3187 
Generated on Thu Jan 10 2013 13:55:28 for Linux Kernel by   doxygen 1.8.2