LCOV - code coverage report
Current view: top level - drivers/scsi - sd.c (source / functions) Hit Total Coverage
Test: gcov_data_raspi2_real_modules_combined.info Lines: 20 1242 1.6 %
Date: 2020-09-30 20:25:40 Functions: 2 91 2.2 %
Branches: 12 1058 1.1 %

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

Generated by: LCOV version 1.14