drivers/scsi/sd_dif.c

   1 /*
   2  * sd_dif.c - SCSI Data Integrity Field
   3  *
   4  * Copyright (C) 2007, 2008 Oracle Corporation
   5  * Written by: Martin K. Petersen <martin.petersen@oracle.com>
   6  *
   7  * This program is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License version
   9  * 2 as published by the Free Software Foundation.
  10  *
  11  * This program is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; see the file COPYING.  If not, write to
  18  * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139,
  19  * USA.
  20  *
  21  */
  22
  23 #include <linux/blkdev.h>
  24 #include <linux/t10-pi.h>
  25
  26 #include <scsi/scsi.h>
  27 #include <scsi/scsi_cmnd.h>
  28 #include <scsi/scsi_dbg.h>
  29 #include <scsi/scsi_device.h>
  30 #include <scsi/scsi_driver.h>
  31 #include <scsi/scsi_eh.h>
  32 #include <scsi/scsi_host.h>
  33 #include <scsi/scsi_ioctl.h>
  34 #include <scsi/scsicam.h>
  35
  36 #include "sd.h"
  37
  38 /*
  39  * Configure exchange of protection information between OS and HBA.
  40  */
  41 void sd_dif_config_host(struct scsi_disk *sdkp)
  42 {
  43         struct scsi_device *sdp = sdkp->device;
  44         struct gendisk *disk = sdkp->disk;
  45         u8 type = sdkp->protection_type;
  46         int dif, dix;
  47
  48         dif = scsi_host_dif_capable(sdp->host, type);
  49         dix = scsi_host_dix_capable(sdp->host, type);
  50
  51         if (!dix && scsi_host_dix_capable(sdp->host, 0)) {
  52                 dif = 0; dix = 1;
  53         }
  54
  55         if (!dix)
  56                 return;
  57
  58         /* Enable DMA of protection information */
  59         if (scsi_host_get_guard(sdkp->device->host) & SHOST_DIX_GUARD_IP) {
  60                 if (type == SD_DIF_TYPE3_PROTECTION)
  61                         blk_integrity_register(disk, &t10_pi_type3_ip);
  62                 else
  63                         blk_integrity_register(disk, &t10_pi_type1_ip);
  64
  65                 disk->integrity->flags |= BLK_INTEGRITY_IP_CHECKSUM;
  66         } else
  67                 if (type == SD_DIF_TYPE3_PROTECTION)
  68                         blk_integrity_register(disk, &t10_pi_type3_crc);
  69                 else
  70                         blk_integrity_register(disk, &t10_pi_type1_crc);
  71
  72         sd_printk(KERN_NOTICE, sdkp,
  73                   "Enabling DIX %s protection\n", disk->integrity->name);
  74
  75         /* Signal to block layer that we support sector tagging */
  76         if (dif && type) {
  77
  78                 disk->integrity->flags |= BLK_INTEGRITY_DEVICE_CAPABLE;
  79
  80                 if (!sdkp)
  81                         return;
  82
  83                 if (type == SD_DIF_TYPE3_PROTECTION)
  84                         disk->integrity->tag_size = sizeof(u16) + sizeof(u32);
  85                 else
  86                         disk->integrity->tag_size = sizeof(u16);
  87
  88                 sd_printk(KERN_NOTICE, sdkp, "DIF application tag size %u\n",
  89                           disk->integrity->tag_size);
  90         }
  91 }
  92
  93 /*
  94  * The virtual start sector is the one that was originally submitted
  95  * by the block layer.  Due to partitioning, MD/DM cloning, etc. the
  96  * actual physical start sector is likely to be different.  Remap
  97  * protection information to match the physical LBA.
  98  *
  99  * From a protocol perspective there's a slight difference between
 100  * Type 1 and 2.  The latter uses 32-byte CDBs exclusively, and the
 101  * reference tag is seeded in the CDB.  This gives us the potential to
 102  * avoid virt->phys remapping during write.  However, at read time we
 103  * don't know whether the virt sector is the same as when we wrote it
 104  * (we could be reading from real disk as opposed to MD/DM device.  So
 105  * we always remap Type 2 making it identical to Type 1.
 106  *
 107  * Type 3 does not have a reference tag so no remapping is required.
 108  */
 109 void sd_dif_prepare(struct request *rq, sector_t hw_sector,
 110                     unsigned int sector_sz)
 111 {
 112         const int tuple_sz = sizeof(struct t10_pi_tuple);
 113         struct bio *bio;
 114         struct scsi_disk *sdkp;
 115         struct t10_pi_tuple *pi;
 116         u32 phys, virt;
 117
 118         sdkp = rq->bio->bi_bdev->bd_disk->private_data;
 119
 120         if (sdkp->protection_type == SD_DIF_TYPE3_PROTECTION)
 121                 return;
 122
 123         phys = hw_sector & 0xffffffff;
 124
 125         __rq_for_each_bio(bio, rq) {
 126                 struct bio_integrity_payload *bip = bio_integrity(bio);
 127                 struct bio_vec iv;
 128                 struct bvec_iter iter;
 129                 unsigned int j;
 130
 131                 /* Already remapped? */
 132                 if (bip->bip_flags & BIP_MAPPED_INTEGRITY)
 133                         break;
 134
 135                 virt = bip_get_seed(bip) & 0xffffffff;
 136
 137                 bip_for_each_vec(iv, bip, iter) {
 138                         pi = kmap_atomic(iv.bv_page) + iv.bv_offset;
 139
 140                         for (j = 0; j < iv.bv_len; j += tuple_sz, pi++) {
 141
 142                                 if (be32_to_cpu(pi->ref_tag) == virt)
 143                                         pi->ref_tag = cpu_to_be32(phys);
 144
 145                                 virt++;
 146                                 phys++;
 147                         }
 148
 149                         kunmap_atomic(pi);
 150                 }
 151
 152                 bip->bip_flags |= BIP_MAPPED_INTEGRITY;
 153         }
 154 }
 155
 156 /*
 157  * Remap physical sector values in the reference tag to the virtual
 158  * values expected by the block layer.
 159  */
 160 void sd_dif_complete(struct scsi_cmnd *scmd, unsigned int good_bytes)
 161 {
 162         const int tuple_sz = sizeof(struct t10_pi_tuple);
 163         struct scsi_disk *sdkp;
 164         struct bio *bio;
 165         struct t10_pi_tuple *pi;
 166         unsigned int j, sectors, sector_sz;
 167         u32 phys, virt;
 168
 169         sdkp = scsi_disk(scmd->request->rq_disk);
 170
 171         if (sdkp->protection_type == SD_DIF_TYPE3_PROTECTION || good_bytes == 0)
 172                 return;
 173
 174         sector_sz = scmd->device->sector_size;
 175         sectors = good_bytes / sector_sz;
 176
 177         phys = blk_rq_pos(scmd->request) & 0xffffffff;
 178         if (sector_sz == 4096)
 179                 phys >>= 3;
 180
 181         __rq_for_each_bio(bio, scmd->request) {
 182                 struct bio_integrity_payload *bip = bio_integrity(bio);
 183                 struct bio_vec iv;
 184                 struct bvec_iter iter;
 185
 186                 virt = bip_get_seed(bip) & 0xffffffff;
 187
 188                 bip_for_each_vec(iv, bip, iter) {
 189                         pi = kmap_atomic(iv.bv_page) + iv.bv_offset;
 190
 191                         for (j = 0; j < iv.bv_len; j += tuple_sz, pi++) {
 192
 193                                 if (sectors == 0) {
 194                                         kunmap_atomic(pi);
 195                                         return;
 196                                 }
 197
 198                                 if (be32_to_cpu(pi->ref_tag) == phys)
 199                                         pi->ref_tag = cpu_to_be32(virt);
 200
 201                                 virt++;
 202                                 phys++;
 203                                 sectors--;
 204                         }
 205
 206                         kunmap_atomic(pi);
 207                 }
 208         }
 209 }
 210