Merge branch 'for-3.18/core' of git://git.kernel.dk/linux-block

Pull core block layer changes from Jens Axboe:
 "This is the core block IO pull request for 3.18.  Apart from the new
  and improved flush machinery for blk-mq, this is all mostly bug fixes
  and cleanups.

   - blk-mq timeout updates and fixes from Christoph.

   - Removal of REQ_END, also from Christoph.  We pass it through the
     ->queue_rq() hook for blk-mq instead, freeing up one of the request
     bits.  The space was overly tight on 32-bit, so Martin also killed
     REQ_KERNEL since it's no longer used.

   - blk integrity updates and fixes from Martin and Gu Zheng.

   - Update to the flush machinery for blk-mq from Ming Lei.  Now we
     have a per hardware context flush request, which both cleans up the
     code should scale better for flush intensive workloads on blk-mq.

   - Improve the error printing, from Rob Elliott.

   - Backing device improvements and cleanups from Tejun.

   - Fixup of a misplaced rq_complete() tracepoint from Hannes.

   - Make blk_get_request() return error pointers, fixing up issues
     where we NULL deref when a device goes bad or missing.  From Joe
     Lawrence.

   - Prep work for drastically reducing the memory consumption of dm
     devices from Junichi Nomura.  This allows creating clone bio sets
     without preallocating a lot of memory.

   - Fix a blk-mq hang on certain combinations of queue depths and
     hardware queues from me.

   - Limit memory consumption for blk-mq devices for crash dump
     scenarios and drivers that use crazy high depths (certain SCSI
     shared tag setups).  We now just use a single queue and limited
     depth for that"

* 'for-3.18/core' of git://git.kernel.dk/linux-block: (58 commits)
  block: Remove REQ_KERNEL
  blk-mq: allocate cpumask on the home node
  bio-integrity: remove the needless fail handle of bip_slab creating
  block: include func name in __get_request prints
  block: make blk_update_request print prefix match ratelimited prefix
  blk-merge: don't compute bi_phys_segments from bi_vcnt for cloned bio
  block: fix alignment_offset math that assumes io_min is a power-of-2
  blk-mq: Make bt_clear_tag() easier to read
  blk-mq: fix potential hang if rolling wakeup depth is too high
  block: add bioset_create_nobvec()
  block: use bio_clone_fast() in blk_rq_prep_clone()
  block: misplaced rq_complete tracepoint
  sd: Honor block layer integrity handling flags
  block: Replace strnicmp with strncasecmp
  block: Add T10 Protection Information functions
  block: Don't merge requests if integrity flags differ
  block: Integrity checksum flag
  block: Relocate bio integrity flags
  block: Add a disk flag to block integrity profile
  block: Add prefix to block integrity profile flags
  ...

14 files changed, 187 insertions, 354 deletions

diff --git a/drivers/scsi/Kconfig b/drivers/scsi/Kconfig
index 296619b7426c..3a820f61ce65 100644
--- a/drivers/scsi/Kconfig
+++ b/drivers/scsi/Kconfig
@@ -73,7 +73,6 @@ comment "SCSI support type (disk, tape, CD-ROM)"
 config BLK_DEV_SD
         tristate "SCSI disk support"
         depends on SCSI
-        select CRC_T10DIF if BLK_DEV_INTEGRITY
         ---help---
           If you want to use SCSI hard disks, Fibre Channel disks,
           Serial ATA (SATA) or Parallel ATA (PATA) hard disks,
diff --git a/drivers/scsi/device_handler/scsi_dh_alua.c b/drivers/scsi/device_handler/scsi_dh_alua.c
index 7bcf67eec921..e99507ed0e3c 100644
--- a/drivers/scsi/device_handler/scsi_dh_alua.c
+++ b/drivers/scsi/device_handler/scsi_dh_alua.c
@@ -115,7 +115,7 @@ static struct request *get_alua_req(struct scsi_device *sdev,
 
         rq = blk_get_request(q, rw, GFP_NOIO);
 
-        if (!rq) {
+        if (IS_ERR(rq)) {
                 sdev_printk(KERN_INFO, sdev,
                             "%s: blk_get_request failed\n", __func__);
                 return NULL;
diff --git a/drivers/scsi/device_handler/scsi_dh_emc.c b/drivers/scsi/device_handler/scsi_dh_emc.c
index 6f07f7fe3aa1..84765384c47c 100644
--- a/drivers/scsi/device_handler/scsi_dh_emc.c
+++ b/drivers/scsi/device_handler/scsi_dh_emc.c
@@ -275,7 +275,7 @@ static struct request *get_req(struct scsi_device *sdev, int cmd,
 
         rq = blk_get_request(sdev->request_queue,
                         (cmd != INQUIRY) ? WRITE : READ, GFP_NOIO);
-        if (!rq) {
+        if (IS_ERR(rq)) {
                 sdev_printk(KERN_INFO, sdev, "get_req: blk_get_request failed");
                 return NULL;
         }
diff --git a/drivers/scsi/device_handler/scsi_dh_hp_sw.c b/drivers/scsi/device_handler/scsi_dh_hp_sw.c
index e9d9fea9e272..4ee2759f5299 100644
--- a/drivers/scsi/device_handler/scsi_dh_hp_sw.c
+++ b/drivers/scsi/device_handler/scsi_dh_hp_sw.c
@@ -117,7 +117,7 @@ static int hp_sw_tur(struct scsi_device *sdev, struct hp_sw_dh_data *h)
 
 retry:
         req = blk_get_request(sdev->request_queue, WRITE, GFP_NOIO);
-        if (!req)
+        if (IS_ERR(req))
                 return SCSI_DH_RES_TEMP_UNAVAIL;
 
         blk_rq_set_block_pc(req);
@@ -247,7 +247,7 @@ static int hp_sw_start_stop(struct hp_sw_dh_data *h)
         struct request *req;
 
         req = blk_get_request(h->sdev->request_queue, WRITE, GFP_ATOMIC);
-        if (!req)
+        if (IS_ERR(req))
                 return SCSI_DH_RES_TEMP_UNAVAIL;
 
         blk_rq_set_block_pc(req);
diff --git a/drivers/scsi/device_handler/scsi_dh_rdac.c b/drivers/scsi/device_handler/scsi_dh_rdac.c
index 826069db9848..1b5bc9293e37 100644
--- a/drivers/scsi/device_handler/scsi_dh_rdac.c
+++ b/drivers/scsi/device_handler/scsi_dh_rdac.c
@@ -274,7 +274,7 @@ static struct request *get_rdac_req(struct scsi_device *sdev,
 
         rq = blk_get_request(q, rw, GFP_NOIO);
 
-        if (!rq) {
+        if (IS_ERR(rq)) {
                 sdev_printk(KERN_INFO, sdev,
                                 "get_rdac_req: blk_get_request failed.\n");
                 return NULL;
diff --git a/drivers/scsi/osd/osd_initiator.c b/drivers/scsi/osd/osd_initiator.c
index 5f4cbf0c4759..fd19fd8468ac 100644
--- a/drivers/scsi/osd/osd_initiator.c
+++ b/drivers/scsi/osd/osd_initiator.c
@@ -1567,8 +1567,8 @@ static struct request *_make_request(struct request_queue *q, bool has_write,
                 struct request *req;
 
                 req = blk_get_request(q, has_write ? WRITE : READ, flags);
-                if (unlikely(!req))
-                        return ERR_PTR(-ENOMEM);
+                if (IS_ERR(req))
+                        return req;
 
                 blk_rq_set_block_pc(req);
                 return req;
diff --git a/drivers/scsi/osst.c b/drivers/scsi/osst.c
index 0727ea7cc387..dff37a250d79 100644
--- a/drivers/scsi/osst.c
+++ b/drivers/scsi/osst.c
@@ -362,7 +362,7 @@ static int osst_execute(struct osst_request *SRpnt, const unsigned char *cmd,
         int write = (data_direction == DMA_TO_DEVICE);
 
         req = blk_get_request(SRpnt->stp->device->request_queue, write, GFP_KERNEL);
-        if (!req)
+        if (IS_ERR(req))
                 return DRIVER_ERROR << 24;
 
         blk_rq_set_block_pc(req);
diff --git a/drivers/scsi/scsi_error.c b/drivers/scsi/scsi_error.c
index 6b20ef3fee54..9a6f8468225f 100644
--- a/drivers/scsi/scsi_error.c
+++ b/drivers/scsi/scsi_error.c
@@ -1961,6 +1961,8 @@ static void scsi_eh_lock_door(struct scsi_device *sdev)
          * request becomes available
          */
         req = blk_get_request(sdev->request_queue, READ, GFP_KERNEL);
+        if (IS_ERR(req))
+                return;
 
         blk_rq_set_block_pc(req);
 
diff --git a/drivers/scsi/scsi_lib.c b/drivers/scsi/scsi_lib.c
index db8c449282f9..9eff8a375132 100644
--- a/drivers/scsi/scsi_lib.c
+++ b/drivers/scsi/scsi_lib.c
@@ -221,7 +221,7 @@ int scsi_execute(struct scsi_device *sdev, const unsigned char *cmd,
         int ret = DRIVER_ERROR << 24;
 
         req = blk_get_request(sdev->request_queue, write, __GFP_WAIT);
-        if (!req)
+        if (IS_ERR(req))
                 return ret;
         blk_rq_set_block_pc(req);
 
@@ -715,7 +715,7 @@ static bool scsi_end_request(struct request *req, int error,
 
         if (req->mq_ctx) {
                 /*
-                 * In the MQ case the command gets freed by __blk_mq_end_io,
+                 * In the MQ case the command gets freed by __blk_mq_end_request,
                  * so we have to do all cleanup that depends on it earlier.
                  *
                  * We also can't kick the queues from irq context, so we
@@ -723,7 +723,7 @@ static bool scsi_end_request(struct request *req, int error,
                  */
                 scsi_mq_uninit_cmd(cmd);
 
-                __blk_mq_end_io(req, error);
+                __blk_mq_end_request(req, error);
 
                 if (scsi_target(sdev)->single_lun ||
                     !list_empty(&sdev->host->starved_list))
@@ -1847,6 +1847,8 @@ static int scsi_mq_prep_fn(struct request *req)
                 next_rq->special = bidi_sdb;
         }
 
+        blk_mq_start_request(req);
+
         return scsi_setup_cmnd(sdev, req);
 }
 
@@ -1856,7 +1858,8 @@ static void scsi_mq_done(struct scsi_cmnd *cmd)
         blk_mq_complete_request(cmd->request);
 }
 
-static int scsi_queue_rq(struct blk_mq_hw_ctx *hctx, struct request *req)
+static int scsi_queue_rq(struct blk_mq_hw_ctx *hctx, struct request *req,
+                bool last)
 {
         struct request_queue *q = req->q;
         struct scsi_device *sdev = q->queuedata;
@@ -1880,11 +1883,14 @@ static int scsi_queue_rq(struct blk_mq_hw_ctx *hctx, struct request *req)
         if (!scsi_host_queue_ready(q, shost, sdev))
                 goto out_dec_target_busy;
 
+
         if (!(req->cmd_flags & REQ_DONTPREP)) {
                 ret = prep_to_mq(scsi_mq_prep_fn(req));
                 if (ret)
                         goto out_dec_host_busy;
                 req->cmd_flags |= REQ_DONTPREP;
+        } else {
+                blk_mq_start_request(req);
         }
 
         scsi_init_cmd_errh(cmd);
@@ -1931,6 +1937,14 @@ out:
         return ret;
 }
 
+static enum blk_eh_timer_return scsi_timeout(struct request *req,
+                bool reserved)
+{
+        if (reserved)
+                return BLK_EH_RESET_TIMER;
+        return scsi_times_out(req);
+}
+
 static int scsi_init_request(void *data, struct request *rq,
                 unsigned int hctx_idx, unsigned int request_idx,
                 unsigned int numa_node)
@@ -2042,7 +2056,7 @@ static struct blk_mq_ops scsi_mq_ops = {
         .map_queue      = blk_mq_map_queue,
         .queue_rq       = scsi_queue_rq,
         .complete       = scsi_softirq_done,
-        .timeout        = scsi_times_out,
+        .timeout        = scsi_timeout,
         .init_request   = scsi_init_request,
         .exit_request   = scsi_exit_request,
 };
diff --git a/drivers/scsi/sd.c b/drivers/scsi/sd.c
index 0cb5c9f0c743..7ee86028a535 100644
--- a/drivers/scsi/sd.c
+++ b/drivers/scsi/sd.c
@@ -610,29 +610,44 @@ static void scsi_disk_put(struct scsi_disk *sdkp)
         mutex_unlock(&sd_ref_mutex);
 }
 
-static void sd_prot_op(struct scsi_cmnd *scmd, unsigned int dif)
-{
-        unsigned int prot_op = SCSI_PROT_NORMAL;
-        unsigned int dix = scsi_prot_sg_count(scmd);
-
-        if (scmd->sc_data_direction == DMA_FROM_DEVICE) {
-                if (dif && dix)
-                        prot_op = SCSI_PROT_READ_PASS;
-                else if (dif && !dix)
-                        prot_op = SCSI_PROT_READ_STRIP;
-                else if (!dif && dix)
-                        prot_op = SCSI_PROT_READ_INSERT;
-        } else {
-                if (dif && dix)
-                        prot_op = SCSI_PROT_WRITE_PASS;
-                else if (dif && !dix)
-                        prot_op = SCSI_PROT_WRITE_INSERT;
-                else if (!dif && dix)
-                        prot_op = SCSI_PROT_WRITE_STRIP;
+
+
+static unsigned char sd_setup_protect_cmnd(struct scsi_cmnd *scmd,
+                                           unsigned int dix, unsigned int dif)
+{
+        struct bio *bio = scmd->request->bio;
+        unsigned int prot_op = sd_prot_op(rq_data_dir(scmd->request), dix, dif);
+        unsigned int protect = 0;
+
+        if (dix) {                              /* DIX Type 0, 1, 2, 3 */
+                if (bio_integrity_flagged(bio, BIP_IP_CHECKSUM))
+                        scmd->prot_flags |= SCSI_PROT_IP_CHECKSUM;
+
+                if (bio_integrity_flagged(bio, BIP_CTRL_NOCHECK) == false)
+                        scmd->prot_flags |= SCSI_PROT_GUARD_CHECK;
+        }
+
+        if (dif != SD_DIF_TYPE3_PROTECTION) {   /* DIX/DIF Type 0, 1, 2 */
+                scmd->prot_flags |= SCSI_PROT_REF_INCREMENT;
+
+                if (bio_integrity_flagged(bio, BIP_CTRL_NOCHECK) == false)
+                        scmd->prot_flags |= SCSI_PROT_REF_CHECK;
+        }
+
+        if (dif) {                              /* DIX/DIF Type 1, 2, 3 */
+                scmd->prot_flags |= SCSI_PROT_TRANSFER_PI;
+
+                if (bio_integrity_flagged(bio, BIP_DISK_NOCHECK))
+                        protect = 3 << 5;       /* Disable target PI checking */
+                else
+                        protect = 1 << 5;       /* Enable target PI checking */
         }
 
         scsi_set_prot_op(scmd, prot_op);
         scsi_set_prot_type(scmd, dif);
+        scmd->prot_flags &= sd_prot_flag_mask(prot_op);
+
+        return protect;
 }
 
 static void sd_config_discard(struct scsi_disk *sdkp, unsigned int mode)
@@ -893,7 +908,8 @@ static int sd_setup_read_write_cmnd(struct scsi_cmnd *SCpnt)
         sector_t block = blk_rq_pos(rq);
         sector_t threshold;
         unsigned int this_count = blk_rq_sectors(rq);
-        int ret, host_dif;
+        unsigned int dif, dix;
+        int ret;
         unsigned char protect;
 
         ret = scsi_init_io(SCpnt, GFP_ATOMIC);
@@ -995,7 +1011,7 @@ static int sd_setup_read_write_cmnd(struct scsi_cmnd *SCpnt)
                 SCpnt->cmnd[0] = WRITE_6;
 
                 if (blk_integrity_rq(rq))
-                        sd_dif_prepare(rq, block, sdp->sector_size);
+                        sd_dif_prepare(SCpnt);
 
         } else if (rq_data_dir(rq) == READ) {
                 SCpnt->cmnd[0] = READ_6;
@@ -1010,14 +1026,15 @@ static int sd_setup_read_write_cmnd(struct scsi_cmnd *SCpnt)
                                         "writing" : "reading", this_count,
                                         blk_rq_sectors(rq)));
 
-        /* Set RDPROTECT/WRPROTECT if disk is formatted with DIF */
-        host_dif = scsi_host_dif_capable(sdp->host, sdkp->protection_type);
-        if (host_dif)
-                protect = 1 << 5;
+        dix = scsi_prot_sg_count(SCpnt);
+        dif = scsi_host_dif_capable(SCpnt->device->host, sdkp->protection_type);
+
+        if (dif || dix)
+                protect = sd_setup_protect_cmnd(SCpnt, dix, dif);
         else
                 protect = 0;
 
-        if (host_dif == SD_DIF_TYPE2_PROTECTION) {
+        if (protect && sdkp->protection_type == SD_DIF_TYPE2_PROTECTION) {
                 SCpnt->cmnd = mempool_alloc(sd_cdb_pool, GFP_ATOMIC);
 
                 if (unlikely(SCpnt->cmnd == NULL)) {
@@ -1102,10 +1119,6 @@ static int sd_setup_read_write_cmnd(struct scsi_cmnd *SCpnt)
         }
         SCpnt->sdb.length = this_count * sdp->sector_size;
 
-        /* If DIF or DIX is enabled, tell HBA how to handle request */
-        if (host_dif || scsi_prot_sg_count(SCpnt))
-                sd_prot_op(SCpnt, host_dif);
-
         /*
          * We shouldn't disconnect in the middle of a sector, so with a dumb
          * host adapter, it's safe to assume that we can at least transfer
diff --git a/drivers/scsi/sd.h b/drivers/scsi/sd.h
index 4c3ab8377fd3..467377884b63 100644
--- a/drivers/scsi/sd.h
+++ b/drivers/scsi/sd.h
@@ -167,6 +167,68 @@ enum sd_dif_target_protection_types {
 };
 
 /*
+ * Look up the DIX operation based on whether the command is read or
+ * write and whether dix and dif are enabled.
+ */
+static inline unsigned int sd_prot_op(bool write, bool dix, bool dif)
+{
+        /* Lookup table: bit 2 (write), bit 1 (dix), bit 0 (dif) */
+        const unsigned int ops[] = {    /* wrt dix dif */
+                SCSI_PROT_NORMAL,       /*  0   0   0  */
+                SCSI_PROT_READ_STRIP,   /*  0   0   1  */
+                SCSI_PROT_READ_INSERT,  /*  0   1   0  */
+                SCSI_PROT_READ_PASS,    /*  0   1   1  */
+                SCSI_PROT_NORMAL,       /*  1   0   0  */
+                SCSI_PROT_WRITE_INSERT, /*  1   0   1  */
+                SCSI_PROT_WRITE_STRIP,  /*  1   1   0  */
+                SCSI_PROT_WRITE_PASS,   /*  1   1   1  */
+        };
+
+        return ops[write << 2 | dix << 1 | dif];
+}
+
+/*
+ * Returns a mask of the protection flags that are valid for a given DIX
+ * operation.
+ */
+static inline unsigned int sd_prot_flag_mask(unsigned int prot_op)
+{
+        const unsigned int flag_mask[] = {
+                [SCSI_PROT_NORMAL]              = 0,
+
+                [SCSI_PROT_READ_STRIP]          = SCSI_PROT_TRANSFER_PI |
+                                                  SCSI_PROT_GUARD_CHECK |
+                                                  SCSI_PROT_REF_CHECK |
+                                                  SCSI_PROT_REF_INCREMENT,
+
+                [SCSI_PROT_READ_INSERT]         = SCSI_PROT_REF_INCREMENT |
+                                                  SCSI_PROT_IP_CHECKSUM,
+
+                [SCSI_PROT_READ_PASS]           = SCSI_PROT_TRANSFER_PI |
+                                                  SCSI_PROT_GUARD_CHECK |
+                                                  SCSI_PROT_REF_CHECK |
+                                                  SCSI_PROT_REF_INCREMENT |
+                                                  SCSI_PROT_IP_CHECKSUM,
+
+                [SCSI_PROT_WRITE_INSERT]        = SCSI_PROT_TRANSFER_PI |
+                                                  SCSI_PROT_REF_INCREMENT,
+
+                [SCSI_PROT_WRITE_STRIP]         = SCSI_PROT_GUARD_CHECK |
+                                                  SCSI_PROT_REF_CHECK |
+                                                  SCSI_PROT_REF_INCREMENT |
+                                                  SCSI_PROT_IP_CHECKSUM,
+
+                [SCSI_PROT_WRITE_PASS]          = SCSI_PROT_TRANSFER_PI |
+                                                  SCSI_PROT_GUARD_CHECK |
+                                                  SCSI_PROT_REF_CHECK |
+                                                  SCSI_PROT_REF_INCREMENT |
+                                                  SCSI_PROT_IP_CHECKSUM,
+        };
+
+        return flag_mask[prot_op];
+}
+
+/*
  * Data Integrity Field tuple.
  */
 struct sd_dif_tuple {
@@ -178,7 +240,7 @@ struct sd_dif_tuple {
 #ifdef CONFIG_BLK_DEV_INTEGRITY
 
 extern void sd_dif_config_host(struct scsi_disk *);
-extern void sd_dif_prepare(struct request *rq, sector_t, unsigned int);
+extern void sd_dif_prepare(struct scsi_cmnd *scmd);
 extern void sd_dif_complete(struct scsi_cmnd *, unsigned int);
 
 #else /* CONFIG_BLK_DEV_INTEGRITY */
@@ -186,7 +248,7 @@ extern void sd_dif_complete(struct scsi_cmnd *, unsigned int);
 static inline void sd_dif_config_host(struct scsi_disk *disk)
 {
 }
-static inline int sd_dif_prepare(struct request *rq, sector_t s, unsigned int a)
+static inline int sd_dif_prepare(struct scsi_cmnd *scmd)
 {
         return 0;
 }
diff --git a/drivers/scsi/sd_dif.c b/drivers/scsi/sd_dif.c
index a7a691d0af7d..14c7d42a11c2 100644
--- a/drivers/scsi/sd_dif.c
+++ b/drivers/scsi/sd_dif.c
@@ -21,7 +21,7 @@
  */
 
 #include <linux/blkdev.h>
-#include <linux/crc-t10dif.h>
+#include <linux/t10-pi.h>
 
 #include <scsi/scsi.h>
 #include <scsi/scsi_cmnd.h>
@@ -33,268 +33,8 @@
 #include <scsi/scsi_ioctl.h>
 #include <scsi/scsicam.h>
 
-#include <net/checksum.h>
-
 #include "sd.h"
 
-typedef __u16 (csum_fn) (void *, unsigned int);
-
-static __u16 sd_dif_crc_fn(void *data, unsigned int len)
-{
-        return cpu_to_be16(crc_t10dif(data, len));
-}
-
-static __u16 sd_dif_ip_fn(void *data, unsigned int len)
-{
-        return ip_compute_csum(data, len);
-}
-
-/*
- * Type 1 and Type 2 protection use the same format: 16 bit guard tag,
- * 16 bit app tag, 32 bit reference tag.
- */
-static void sd_dif_type1_generate(struct blk_integrity_exchg *bix, csum_fn *fn)
-{
-        void *buf = bix->data_buf;
-        struct sd_dif_tuple *sdt = bix->prot_buf;
-        sector_t sector = bix->sector;
-        unsigned int i;
-
-        for (i = 0 ; i < bix->data_size ; i += bix->sector_size, sdt++) {
-                sdt->guard_tag = fn(buf, bix->sector_size);
-                sdt->ref_tag = cpu_to_be32(sector & 0xffffffff);
-                sdt->app_tag = 0;
-
-                buf += bix->sector_size;
-                sector++;
-        }
-}
-
-static void sd_dif_type1_generate_crc(struct blk_integrity_exchg *bix)
-{
-        sd_dif_type1_generate(bix, sd_dif_crc_fn);
-}
-
-static void sd_dif_type1_generate_ip(struct blk_integrity_exchg *bix)
-{
-        sd_dif_type1_generate(bix, sd_dif_ip_fn);
-}
-
-static int sd_dif_type1_verify(struct blk_integrity_exchg *bix, csum_fn *fn)
-{
-        void *buf = bix->data_buf;
-        struct sd_dif_tuple *sdt = bix->prot_buf;
-        sector_t sector = bix->sector;
-        unsigned int i;
-        __u16 csum;
-
-        for (i = 0 ; i < bix->data_size ; i += bix->sector_size, sdt++) {
-                /* Unwritten sectors */
-                if (sdt->app_tag == 0xffff)
-                        return 0;
-
-                if (be32_to_cpu(sdt->ref_tag) != (sector & 0xffffffff)) {
-                        printk(KERN_ERR
-                               "%s: ref tag error on sector %lu (rcvd %u)\n",
-                               bix->disk_name, (unsigned long)sector,
-                               be32_to_cpu(sdt->ref_tag));
-                        return -EIO;
-                }
-
-                csum = fn(buf, bix->sector_size);
-
-                if (sdt->guard_tag != csum) {
-                        printk(KERN_ERR "%s: guard tag error on sector %lu " \
-                               "(rcvd %04x, data %04x)\n", bix->disk_name,
-                               (unsigned long)sector,
-                               be16_to_cpu(sdt->guard_tag), be16_to_cpu(csum));
-                        return -EIO;
-                }
-
-                buf += bix->sector_size;
-                sector++;
-        }
-
-        return 0;
-}
-
-static int sd_dif_type1_verify_crc(struct blk_integrity_exchg *bix)
-{
-        return sd_dif_type1_verify(bix, sd_dif_crc_fn);
-}
-
-static int sd_dif_type1_verify_ip(struct blk_integrity_exchg *bix)
-{
-        return sd_dif_type1_verify(bix, sd_dif_ip_fn);
-}
-
-/*
- * Functions for interleaving and deinterleaving application tags
- */
-static void sd_dif_type1_set_tag(void *prot, void *tag_buf, unsigned int sectors)
-{
-        struct sd_dif_tuple *sdt = prot;
-        u8 *tag = tag_buf;
-        unsigned int i, j;
-
-        for (i = 0, j = 0 ; i < sectors ; i++, j += 2, sdt++) {
-                sdt->app_tag = tag[j] << 8 | tag[j+1];
-                BUG_ON(sdt->app_tag == 0xffff);
-        }
-}
-
-static void sd_dif_type1_get_tag(void *prot, void *tag_buf, unsigned int sectors)
-{
-        struct sd_dif_tuple *sdt = prot;
-        u8 *tag = tag_buf;
-        unsigned int i, j;
-
-        for (i = 0, j = 0 ; i < sectors ; i++, j += 2, sdt++) {
-                tag[j] = (sdt->app_tag & 0xff00) >> 8;
-                tag[j+1] = sdt->app_tag & 0xff;
-        }
-}
-
-static struct blk_integrity dif_type1_integrity_crc = {
-        .name                   = "T10-DIF-TYPE1-CRC",
-        .generate_fn            = sd_dif_type1_generate_crc,
-        .verify_fn              = sd_dif_type1_verify_crc,
-        .get_tag_fn             = sd_dif_type1_get_tag,
-        .set_tag_fn             = sd_dif_type1_set_tag,
-        .tuple_size             = sizeof(struct sd_dif_tuple),
-        .tag_size               = 0,
-};
-
-static struct blk_integrity dif_type1_integrity_ip = {
-        .name                   = "T10-DIF-TYPE1-IP",
-        .generate_fn            = sd_dif_type1_generate_ip,
-        .verify_fn              = sd_dif_type1_verify_ip,
-        .get_tag_fn             = sd_dif_type1_get_tag,
-        .set_tag_fn             = sd_dif_type1_set_tag,
-        .tuple_size             = sizeof(struct sd_dif_tuple),
-        .tag_size               = 0,
-};
-
-
-/*
- * Type 3 protection has a 16-bit guard tag and 16 + 32 bits of opaque
- * tag space.
- */
-static void sd_dif_type3_generate(struct blk_integrity_exchg *bix, csum_fn *fn)
-{
-        void *buf = bix->data_buf;
-        struct sd_dif_tuple *sdt = bix->prot_buf;
-        unsigned int i;
-
-        for (i = 0 ; i < bix->data_size ; i += bix->sector_size, sdt++) {
-                sdt->guard_tag = fn(buf, bix->sector_size);
-                sdt->ref_tag = 0;
-                sdt->app_tag = 0;
-
-                buf += bix->sector_size;
-        }
-}
-
-static void sd_dif_type3_generate_crc(struct blk_integrity_exchg *bix)
-{
-        sd_dif_type3_generate(bix, sd_dif_crc_fn);
-}
-
-static void sd_dif_type3_generate_ip(struct blk_integrity_exchg *bix)
-{
-        sd_dif_type3_generate(bix, sd_dif_ip_fn);
-}
-
-static int sd_dif_type3_verify(struct blk_integrity_exchg *bix, csum_fn *fn)
-{
-        void *buf = bix->data_buf;
-        struct sd_dif_tuple *sdt = bix->prot_buf;
-        sector_t sector = bix->sector;
-        unsigned int i;
-        __u16 csum;
-
-        for (i = 0 ; i < bix->data_size ; i += bix->sector_size, sdt++) {
-                /* Unwritten sectors */
-                if (sdt->app_tag == 0xffff && sdt->ref_tag == 0xffffffff)
-                        return 0;
-
-                csum = fn(buf, bix->sector_size);
-
-                if (sdt->guard_tag != csum) {
-                        printk(KERN_ERR "%s: guard tag error on sector %lu " \
-                               "(rcvd %04x, data %04x)\n", bix->disk_name,
-                               (unsigned long)sector,
-                               be16_to_cpu(sdt->guard_tag), be16_to_cpu(csum));
-                        return -EIO;
-                }
-
-                buf += bix->sector_size;
-                sector++;
-        }
-
-        return 0;
-}
-
-static int sd_dif_type3_verify_crc(struct blk_integrity_exchg *bix)
-{
-        return sd_dif_type3_verify(bix, sd_dif_crc_fn);
-}
-
-static int sd_dif_type3_verify_ip(struct blk_integrity_exchg *bix)
-{
-        return sd_dif_type3_verify(bix, sd_dif_ip_fn);
-}
-
-static void sd_dif_type3_set_tag(void *prot, void *tag_buf, unsigned int sectors)
-{
-        struct sd_dif_tuple *sdt = prot;
-        u8 *tag = tag_buf;
-        unsigned int i, j;
-
-        for (i = 0, j = 0 ; i < sectors ; i++, j += 6, sdt++) {
-                sdt->app_tag = tag[j] << 8 | tag[j+1];
-                sdt->ref_tag = tag[j+2] << 24 | tag[j+3] << 16 |
-                        tag[j+4] << 8 | tag[j+5];
-        }
-}
-
-static void sd_dif_type3_get_tag(void *prot, void *tag_buf, unsigned int sectors)
-{
-        struct sd_dif_tuple *sdt = prot;
-        u8 *tag = tag_buf;
-        unsigned int i, j;
-
-        for (i = 0, j = 0 ; i < sectors ; i++, j += 2, sdt++) {
-                tag[j] = (sdt->app_tag & 0xff00) >> 8;
-                tag[j+1] = sdt->app_tag & 0xff;
-                tag[j+2] = (sdt->ref_tag & 0xff000000) >> 24;
-                tag[j+3] = (sdt->ref_tag & 0xff0000) >> 16;
-                tag[j+4] = (sdt->ref_tag & 0xff00) >> 8;
-                tag[j+5] = sdt->ref_tag & 0xff;
-                BUG_ON(sdt->app_tag == 0xffff || sdt->ref_tag == 0xffffffff);
-        }
-}
-
-static struct blk_integrity dif_type3_integrity_crc = {
-        .name                   = "T10-DIF-TYPE3-CRC",
-        .generate_fn            = sd_dif_type3_generate_crc,
-        .verify_fn              = sd_dif_type3_verify_crc,
-        .get_tag_fn             = sd_dif_type3_get_tag,
-        .set_tag_fn             = sd_dif_type3_set_tag,
-        .tuple_size             = sizeof(struct sd_dif_tuple),
-        .tag_size               = 0,
-};
-
-static struct blk_integrity dif_type3_integrity_ip = {
-        .name                   = "T10-DIF-TYPE3-IP",
-        .generate_fn            = sd_dif_type3_generate_ip,
-        .verify_fn              = sd_dif_type3_verify_ip,
-        .get_tag_fn             = sd_dif_type3_get_tag,
-        .set_tag_fn             = sd_dif_type3_set_tag,
-        .tuple_size             = sizeof(struct sd_dif_tuple),
-        .tag_size               = 0,
-};
-
 /*
  * Configure exchange of protection information between OS and HBA.
  */
@@ -316,22 +56,30 @@ void sd_dif_config_host(struct scsi_disk *sdkp)
                 return;
 
         /* Enable DMA of protection information */
-        if (scsi_host_get_guard(sdkp->device->host) & SHOST_DIX_GUARD_IP)
+        if (scsi_host_get_guard(sdkp->device->host) & SHOST_DIX_GUARD_IP) {
                 if (type == SD_DIF_TYPE3_PROTECTION)
-                        blk_integrity_register(disk, &dif_type3_integrity_ip);
+                        blk_integrity_register(disk, &t10_pi_type3_ip);
                 else
-                        blk_integrity_register(disk, &dif_type1_integrity_ip);
-        else
+                        blk_integrity_register(disk, &t10_pi_type1_ip);
+
+                disk->integrity->flags |= BLK_INTEGRITY_IP_CHECKSUM;
+        } else
                 if (type == SD_DIF_TYPE3_PROTECTION)
-                        blk_integrity_register(disk, &dif_type3_integrity_crc);
+                        blk_integrity_register(disk, &t10_pi_type3_crc);
                 else
-                        blk_integrity_register(disk, &dif_type1_integrity_crc);
+                        blk_integrity_register(disk, &t10_pi_type1_crc);
 
         sd_printk(KERN_NOTICE, sdkp,
                   "Enabling DIX %s protection\n", disk->integrity->name);
 
         /* Signal to block layer that we support sector tagging */
-        if (dif && type && sdkp->ATO) {
+        if (dif && type) {
+
+                disk->integrity->flags |= BLK_INTEGRITY_DEVICE_CAPABLE;
+
+                if (!sdkp)
+                        return;
+
                 if (type == SD_DIF_TYPE3_PROTECTION)
                         disk->integrity->tag_size = sizeof(u16) + sizeof(u32);
                 else
@@ -358,50 +106,49 @@ void sd_dif_config_host(struct scsi_disk *sdkp)
  *
  * Type 3 does not have a reference tag so no remapping is required.
  */
-void sd_dif_prepare(struct request *rq, sector_t hw_sector,
-                    unsigned int sector_sz)
+void sd_dif_prepare(struct scsi_cmnd *scmd)
 {
-        const int tuple_sz = sizeof(struct sd_dif_tuple);
+        const int tuple_sz = sizeof(struct t10_pi_tuple);
         struct bio *bio;
         struct scsi_disk *sdkp;
-        struct sd_dif_tuple *sdt;
+        struct t10_pi_tuple *pi;
         u32 phys, virt;
 
-        sdkp = rq->bio->bi_bdev->bd_disk->private_data;
+        sdkp = scsi_disk(scmd->request->rq_disk);
 
         if (sdkp->protection_type == SD_DIF_TYPE3_PROTECTION)
                 return;
 
-        phys = hw_sector & 0xffffffff;
+        phys = scsi_prot_ref_tag(scmd);
 
-        __rq_for_each_bio(bio, rq) {
+        __rq_for_each_bio(bio, scmd->request) {
+                struct bio_integrity_payload *bip = bio_integrity(bio);
                 struct bio_vec iv;
                 struct bvec_iter iter;
                 unsigned int j;
 
                 /* Already remapped? */
-                if (bio_flagged(bio, BIO_MAPPED_INTEGRITY))
+                if (bip->bip_flags & BIP_MAPPED_INTEGRITY)
                         break;
 
-                virt = bio->bi_integrity->bip_iter.bi_sector & 0xffffffff;
+                virt = bip_get_seed(bip) & 0xffffffff;
 
-                bip_for_each_vec(iv, bio->bi_integrity, iter) {
-                        sdt = kmap_atomic(iv.bv_page)
-                                + iv.bv_offset;
+                bip_for_each_vec(iv, bip, iter) {
+                        pi = kmap_atomic(iv.bv_page) + iv.bv_offset;
 
-                        for (j = 0; j < iv.bv_len; j += tuple_sz, sdt++) {
+                        for (j = 0; j < iv.bv_len; j += tuple_sz, pi++) {
 
-                                if (be32_to_cpu(sdt->ref_tag) == virt)
-                                        sdt->ref_tag = cpu_to_be32(phys);
+                                if (be32_to_cpu(pi->ref_tag) == virt)
+                                        pi->ref_tag = cpu_to_be32(phys);
 
                                 virt++;
                                 phys++;
                         }
 
-                        kunmap_atomic(sdt);
+                        kunmap_atomic(pi);
                 }
 
-                bio->bi_flags |= (1 << BIO_MAPPED_INTEGRITY);
+                bip->bip_flags |= BIP_MAPPED_INTEGRITY;
         }
 }
 
@@ -411,11 +158,11 @@ void sd_dif_prepare(struct request *rq, sector_t hw_sector,
  */
 void sd_dif_complete(struct scsi_cmnd *scmd, unsigned int good_bytes)
 {
-        const int tuple_sz = sizeof(struct sd_dif_tuple);
+        const int tuple_sz = sizeof(struct t10_pi_tuple);
         struct scsi_disk *sdkp;
         struct bio *bio;
-        struct sd_dif_tuple *sdt;
-        unsigned int j, sectors, sector_sz;
+        struct t10_pi_tuple *pi;
+        unsigned int j, intervals;
         u32 phys, virt;
 
         sdkp = scsi_disk(scmd->request->rq_disk);
@@ -423,39 +170,35 @@ void sd_dif_complete(struct scsi_cmnd *scmd, unsigned int good_bytes)
         if (sdkp->protection_type == SD_DIF_TYPE3_PROTECTION || good_bytes == 0)
                 return;
 
-        sector_sz = scmd->device->sector_size;
-        sectors = good_bytes / sector_sz;
-
-        phys = blk_rq_pos(scmd->request) & 0xffffffff;
-        if (sector_sz == 4096)
-                phys >>= 3;
+        intervals = good_bytes / scsi_prot_interval(scmd);
+        phys = scsi_prot_ref_tag(scmd);
 
         __rq_for_each_bio(bio, scmd->request) {
+                struct bio_integrity_payload *bip = bio_integrity(bio);
                 struct bio_vec iv;
                 struct bvec_iter iter;
 
-                virt = bio->bi_integrity->bip_iter.bi_sector & 0xffffffff;
+                virt = bip_get_seed(bip) & 0xffffffff;
 
-                bip_for_each_vec(iv, bio->bi_integrity, iter) {
-                        sdt = kmap_atomic(iv.bv_page)
-                                + iv.bv_offset;
+                bip_for_each_vec(iv, bip, iter) {
+                        pi = kmap_atomic(iv.bv_page) + iv.bv_offset;
 
-                        for (j = 0; j < iv.bv_len; j += tuple_sz, sdt++) {
+                        for (j = 0; j < iv.bv_len; j += tuple_sz, pi++) {
 
-                                if (sectors == 0) {
-                                        kunmap_atomic(sdt);
+                                if (intervals == 0) {
+                                        kunmap_atomic(pi);
                                         return;
                                 }
 
-                                if (be32_to_cpu(sdt->ref_tag) == phys)
-                                        sdt->ref_tag = cpu_to_be32(virt);
+                                if (be32_to_cpu(pi->ref_tag) == phys)
+                                        pi->ref_tag = cpu_to_be32(virt);
 
                                 virt++;
                                 phys++;
-                                sectors--;
+                                intervals--;
                         }
 
-                        kunmap_atomic(sdt);
+                        kunmap_atomic(pi);
                 }
         }
 }
diff --git a/drivers/scsi/sg.c b/drivers/scsi/sg.c
index 01cf88888797..60354449d9ed 100644
--- a/drivers/scsi/sg.c
+++ b/drivers/scsi/sg.c
@@ -1711,9 +1711,9 @@ sg_start_req(Sg_request *srp, unsigned char *cmd)
         }
 
         rq = blk_get_request(q, rw, GFP_ATOMIC);
-        if (!rq) {
+        if (IS_ERR(rq)) {
                 kfree(long_cmdp);
-                return -ENOMEM;
+                return PTR_ERR(rq);
         }
 
         blk_rq_set_block_pc(rq);
diff --git a/drivers/scsi/st.c b/drivers/scsi/st.c
index d3fd6e8fb378..4daa372ed381 100644
--- a/drivers/scsi/st.c
+++ b/drivers/scsi/st.c
@@ -490,7 +490,7 @@ static int st_scsi_execute(struct st_request *SRpnt, const unsigned char *cmd,
 
         req = blk_get_request(SRpnt->stp->device->request_queue, write,
                               GFP_KERNEL);
-        if (!req)
+        if (IS_ERR(req))
                 return DRIVER_ERROR << 24;
 
         blk_rq_set_block_pc(req);