Merge branch 'release' of git://git.kernel.org/pub/scm/linux/kernel/git/lenb/linux

[firefly-linux-kernel-4.4.55.git] / drivers / scsi / sd.c

diff --git a/drivers/scsi/sd.c b/drivers/scsi/sd.c
index 4df73e52a4f9fb285a886bbe9e313227e9f92c23..12f6fdfc11474a9363ae6c641959832d2c1d6440 100644 (file)
--- a/drivers/scsi/sd.c
+++ b/drivers/scsi/sd.c
@@ -261,6 +261,28 @@ sd_show_protection_type(struct device *dev, struct device_attribute *attr,
        return snprintf(buf, 20, "%u\n", sdkp->protection_type);
 }
 
+static ssize_t
+sd_store_protection_type(struct device *dev, struct device_attribute *attr,
+                        const char *buf, size_t count)
+{
+       struct scsi_disk *sdkp = to_scsi_disk(dev);
+       unsigned int val;
+       int err;
+
+       if (!capable(CAP_SYS_ADMIN))
+               return -EACCES;
+
+       err = kstrtouint(buf, 10, &val);
+
+       if (err)
+               return err;
+
+       if (val >= 0 && val <= SD_DIF_TYPE3_PROTECTION)
+               sdkp->protection_type = val;
+
+       return count;
+}
+
 static ssize_t
 sd_show_protection_mode(struct device *dev, struct device_attribute *attr,
                        char *buf)
@@ -381,7 +403,8 @@ static struct device_attribute sd_disk_attrs[] = {
               sd_store_allow_restart),
        __ATTR(manage_start_stop, S_IRUGO|S_IWUSR, sd_show_manage_start_stop,
               sd_store_manage_start_stop),
-       __ATTR(protection_type, S_IRUGO, sd_show_protection_type, NULL),
+       __ATTR(protection_type, S_IRUGO|S_IWUSR, sd_show_protection_type,
+              sd_store_protection_type),
        __ATTR(protection_mode, S_IRUGO, sd_show_protection_mode, NULL),
        __ATTR(app_tag_own, S_IRUGO, sd_show_app_tag_own, NULL),
        __ATTR(thin_provisioning, S_IRUGO, sd_show_thin_provisioning, NULL),
@@ -804,9 +827,8 @@ static int sd_prep_fn(struct request_queue *q, struct request *rq)
                SCpnt->cmnd[0] = WRITE_6;
                SCpnt->sc_data_direction = DMA_TO_DEVICE;
 
-               if (blk_integrity_rq(rq) &&
-                   sd_dif_prepare(rq, block, sdp->sector_size) == -EIO)
-                       goto out;
+               if (blk_integrity_rq(rq))
+                       sd_dif_prepare(rq, block, sdp->sector_size);
 
        } else if (rq_data_dir(rq) == READ) {
                SCpnt->cmnd[0] = READ_6;
@@ -1671,34 +1693,42 @@ sd_spinup_disk(struct scsi_disk *sdkp)
 /*
  * Determine whether disk supports Data Integrity Field.
  */
-static void sd_read_protection_type(struct scsi_disk *sdkp, unsigned char *buffer)
+static int sd_read_protection_type(struct scsi_disk *sdkp, unsigned char *buffer)
 {
        struct scsi_device *sdp = sdkp->device;
        u8 type;
+       int ret = 0;
 
        if (scsi_device_protection(sdp) == 0 || (buffer[12] & 1) == 0)
-               return;
+               return ret;
 
        type = ((buffer[12] >> 1) & 7) + 1; /* P_TYPE 0 = Type 1 */
 
-       if (type == sdkp->protection_type || !sdkp->first_scan)
-               return;
+       if (type > SD_DIF_TYPE3_PROTECTION)
+               ret = -ENODEV;
+       else if (scsi_host_dif_capable(sdp->host, type))
+               ret = 1;
+
+       if (sdkp->first_scan || type != sdkp->protection_type)
+               switch (ret) {
+               case -ENODEV:
+                       sd_printk(KERN_ERR, sdkp, "formatted with unsupported" \
+                                 " protection type %u. Disabling disk!\n",
+                                 type);
+                       break;
+               case 1:
+                       sd_printk(KERN_NOTICE, sdkp,
+                                 "Enabling DIF Type %u protection\n", type);
+                       break;
+               case 0:
+                       sd_printk(KERN_NOTICE, sdkp,
+                                 "Disabling DIF Type %u protection\n", type);
+                       break;
+               }
 
        sdkp->protection_type = type;
 
-       if (type > SD_DIF_TYPE3_PROTECTION) {
-               sd_printk(KERN_ERR, sdkp, "formatted with unsupported " \
-                         "protection type %u. Disabling disk!\n", type);
-               sdkp->capacity = 0;
-               return;
-       }
-
-       if (scsi_host_dif_capable(sdp->host, type))
-               sd_printk(KERN_NOTICE, sdkp,
-                         "Enabling DIF Type %u protection\n", type);
-       else
-               sd_printk(KERN_NOTICE, sdkp,
-                         "Disabling DIF Type %u protection\n", type);
+       return ret;
 }
 
 static void read_capacity_error(struct scsi_disk *sdkp, struct scsi_device *sdp,
@@ -1794,7 +1824,10 @@ static int read_capacity_16(struct scsi_disk *sdkp, struct scsi_device *sdp,
        sector_size = get_unaligned_be32(&buffer[8]);
        lba = get_unaligned_be64(&buffer[0]);
 
-       sd_read_protection_type(sdkp, buffer);
+       if (sd_read_protection_type(sdkp, buffer) < 0) {
+               sdkp->capacity = 0;
+               return -ENODEV;
+       }
 
        if ((sizeof(sdkp->capacity) == 4) && (lba >= 0xffffffffULL)) {
                sd_printk(KERN_ERR, sdkp, "Too big for this kernel. Use a "
@@ -2632,7 +2665,8 @@ static void sd_probe_async(void *data, async_cookie_t cookie)
        }
 
        add_disk(gd);
-       sd_dif_config_host(sdkp);
+       if (sdkp->capacity)
+               sd_dif_config_host(sdkp);
 
        sd_revalidate_disk(gd);