2 * sd_dif.c - SCSI Data Integrity Field
4 * Copyright (C) 2007, 2008 Oracle Corporation
5 * Written by: Martin K. Petersen <martin.petersen@oracle.com>
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.
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.
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,
23 #include <linux/blkdev.h>
24 #include <linux/crc-t10dif.h>
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>
36 #include <net/checksum.h>
40 typedef __u16 (csum_fn
) (void *, unsigned int);
42 static __u16
sd_dif_crc_fn(void *data
, unsigned int len
)
44 return cpu_to_be16(crc_t10dif(data
, len
));
47 static __u16
sd_dif_ip_fn(void *data
, unsigned int len
)
49 return ip_compute_csum(data
, len
);
53 * Type 1 and Type 2 protection use the same format: 16 bit guard tag,
54 * 16 bit app tag, 32 bit reference tag.
56 static void sd_dif_type1_generate(struct blk_integrity_iter
*iter
, csum_fn
*fn
)
58 void *buf
= iter
->data_buf
;
59 struct sd_dif_tuple
*sdt
= iter
->prot_buf
;
60 sector_t seed
= iter
->seed
;
63 for (i
= 0 ; i
< iter
->data_size
; i
+= iter
->interval
, sdt
++) {
64 sdt
->guard_tag
= fn(buf
, iter
->interval
);
65 sdt
->ref_tag
= cpu_to_be32(seed
& 0xffffffff);
68 buf
+= iter
->interval
;
73 static int sd_dif_type1_generate_crc(struct blk_integrity_iter
*iter
)
75 sd_dif_type1_generate(iter
, sd_dif_crc_fn
);
79 static int sd_dif_type1_generate_ip(struct blk_integrity_iter
*iter
)
81 sd_dif_type1_generate(iter
, sd_dif_ip_fn
);
85 static int sd_dif_type1_verify(struct blk_integrity_iter
*iter
, csum_fn
*fn
)
87 void *buf
= iter
->data_buf
;
88 struct sd_dif_tuple
*sdt
= iter
->prot_buf
;
89 sector_t seed
= iter
->seed
;
93 for (i
= 0 ; i
< iter
->data_size
; i
+= iter
->interval
, sdt
++) {
94 /* Unwritten sectors */
95 if (sdt
->app_tag
== 0xffff)
98 if (be32_to_cpu(sdt
->ref_tag
) != (seed
& 0xffffffff)) {
100 "%s: ref tag error on sector %lu (rcvd %u)\n",
101 iter
->disk_name
, (unsigned long)seed
,
102 be32_to_cpu(sdt
->ref_tag
));
106 csum
= fn(buf
, iter
->interval
);
108 if (sdt
->guard_tag
!= csum
) {
109 printk(KERN_ERR
"%s: guard tag error on sector %lu " \
110 "(rcvd %04x, data %04x)\n", iter
->disk_name
,
112 be16_to_cpu(sdt
->guard_tag
), be16_to_cpu(csum
));
116 buf
+= iter
->interval
;
123 static int sd_dif_type1_verify_crc(struct blk_integrity_iter
*iter
)
125 return sd_dif_type1_verify(iter
, sd_dif_crc_fn
);
128 static int sd_dif_type1_verify_ip(struct blk_integrity_iter
*iter
)
130 return sd_dif_type1_verify(iter
, sd_dif_ip_fn
);
133 static struct blk_integrity dif_type1_integrity_crc
= {
134 .name
= "T10-DIF-TYPE1-CRC",
135 .generate_fn
= sd_dif_type1_generate_crc
,
136 .verify_fn
= sd_dif_type1_verify_crc
,
137 .tuple_size
= sizeof(struct sd_dif_tuple
),
141 static struct blk_integrity dif_type1_integrity_ip
= {
142 .name
= "T10-DIF-TYPE1-IP",
143 .generate_fn
= sd_dif_type1_generate_ip
,
144 .verify_fn
= sd_dif_type1_verify_ip
,
145 .tuple_size
= sizeof(struct sd_dif_tuple
),
151 * Type 3 protection has a 16-bit guard tag and 16 + 32 bits of opaque
154 static void sd_dif_type3_generate(struct blk_integrity_iter
*iter
, csum_fn
*fn
)
156 void *buf
= iter
->data_buf
;
157 struct sd_dif_tuple
*sdt
= iter
->prot_buf
;
160 for (i
= 0 ; i
< iter
->data_size
; i
+= iter
->interval
, sdt
++) {
161 sdt
->guard_tag
= fn(buf
, iter
->interval
);
165 buf
+= iter
->interval
;
169 static int sd_dif_type3_generate_crc(struct blk_integrity_iter
*iter
)
171 sd_dif_type3_generate(iter
, sd_dif_crc_fn
);
175 static int sd_dif_type3_generate_ip(struct blk_integrity_iter
*iter
)
177 sd_dif_type3_generate(iter
, sd_dif_ip_fn
);
181 static int sd_dif_type3_verify(struct blk_integrity_iter
*iter
, csum_fn
*fn
)
183 void *buf
= iter
->data_buf
;
184 struct sd_dif_tuple
*sdt
= iter
->prot_buf
;
185 sector_t seed
= iter
->seed
;
189 for (i
= 0 ; i
< iter
->data_size
; i
+= iter
->interval
, sdt
++) {
190 /* Unwritten sectors */
191 if (sdt
->app_tag
== 0xffff && sdt
->ref_tag
== 0xffffffff)
194 csum
= fn(buf
, iter
->interval
);
196 if (sdt
->guard_tag
!= csum
) {
197 printk(KERN_ERR
"%s: guard tag error on sector %lu " \
198 "(rcvd %04x, data %04x)\n", iter
->disk_name
,
200 be16_to_cpu(sdt
->guard_tag
), be16_to_cpu(csum
));
204 buf
+= iter
->interval
;
211 static int sd_dif_type3_verify_crc(struct blk_integrity_iter
*iter
)
213 return sd_dif_type3_verify(iter
, sd_dif_crc_fn
);
216 static int sd_dif_type3_verify_ip(struct blk_integrity_iter
*iter
)
218 return sd_dif_type3_verify(iter
, sd_dif_ip_fn
);
221 static struct blk_integrity dif_type3_integrity_crc
= {
222 .name
= "T10-DIF-TYPE3-CRC",
223 .generate_fn
= sd_dif_type3_generate_crc
,
224 .verify_fn
= sd_dif_type3_verify_crc
,
225 .tuple_size
= sizeof(struct sd_dif_tuple
),
229 static struct blk_integrity dif_type3_integrity_ip
= {
230 .name
= "T10-DIF-TYPE3-IP",
231 .generate_fn
= sd_dif_type3_generate_ip
,
232 .verify_fn
= sd_dif_type3_verify_ip
,
233 .tuple_size
= sizeof(struct sd_dif_tuple
),
238 * Configure exchange of protection information between OS and HBA.
240 void sd_dif_config_host(struct scsi_disk
*sdkp
)
242 struct scsi_device
*sdp
= sdkp
->device
;
243 struct gendisk
*disk
= sdkp
->disk
;
244 u8 type
= sdkp
->protection_type
;
247 dif
= scsi_host_dif_capable(sdp
->host
, type
);
248 dix
= scsi_host_dix_capable(sdp
->host
, type
);
250 if (!dix
&& scsi_host_dix_capable(sdp
->host
, 0)) {
257 /* Enable DMA of protection information */
258 if (scsi_host_get_guard(sdkp
->device
->host
) & SHOST_DIX_GUARD_IP
) {
259 if (type
== SD_DIF_TYPE3_PROTECTION
)
260 blk_integrity_register(disk
, &dif_type3_integrity_ip
);
262 blk_integrity_register(disk
, &dif_type1_integrity_ip
);
264 disk
->integrity
->flags
|= BLK_INTEGRITY_IP_CHECKSUM
;
266 if (type
== SD_DIF_TYPE3_PROTECTION
)
267 blk_integrity_register(disk
, &dif_type3_integrity_crc
);
269 blk_integrity_register(disk
, &dif_type1_integrity_crc
);
271 sd_printk(KERN_NOTICE
, sdkp
,
272 "Enabling DIX %s protection\n", disk
->integrity
->name
);
274 /* Signal to block layer that we support sector tagging */
277 disk
->integrity
->flags
|= BLK_INTEGRITY_DEVICE_CAPABLE
;
282 if (type
== SD_DIF_TYPE3_PROTECTION
)
283 disk
->integrity
->tag_size
= sizeof(u16
) + sizeof(u32
);
285 disk
->integrity
->tag_size
= sizeof(u16
);
287 sd_printk(KERN_NOTICE
, sdkp
, "DIF application tag size %u\n",
288 disk
->integrity
->tag_size
);
293 * The virtual start sector is the one that was originally submitted
294 * by the block layer. Due to partitioning, MD/DM cloning, etc. the
295 * actual physical start sector is likely to be different. Remap
296 * protection information to match the physical LBA.
298 * From a protocol perspective there's a slight difference between
299 * Type 1 and 2. The latter uses 32-byte CDBs exclusively, and the
300 * reference tag is seeded in the CDB. This gives us the potential to
301 * avoid virt->phys remapping during write. However, at read time we
302 * don't know whether the virt sector is the same as when we wrote it
303 * (we could be reading from real disk as opposed to MD/DM device. So
304 * we always remap Type 2 making it identical to Type 1.
306 * Type 3 does not have a reference tag so no remapping is required.
308 void sd_dif_prepare(struct request
*rq
, sector_t hw_sector
,
309 unsigned int sector_sz
)
311 const int tuple_sz
= sizeof(struct sd_dif_tuple
);
313 struct scsi_disk
*sdkp
;
314 struct sd_dif_tuple
*sdt
;
317 sdkp
= rq
->bio
->bi_bdev
->bd_disk
->private_data
;
319 if (sdkp
->protection_type
== SD_DIF_TYPE3_PROTECTION
)
322 phys
= hw_sector
& 0xffffffff;
324 __rq_for_each_bio(bio
, rq
) {
325 struct bio_integrity_payload
*bip
= bio_integrity(bio
);
327 struct bvec_iter iter
;
330 /* Already remapped? */
331 if (bip
->bip_flags
& BIP_MAPPED_INTEGRITY
)
334 virt
= bip_get_seed(bip
) & 0xffffffff;
336 bip_for_each_vec(iv
, bip
, iter
) {
337 sdt
= kmap_atomic(iv
.bv_page
)
340 for (j
= 0; j
< iv
.bv_len
; j
+= tuple_sz
, sdt
++) {
342 if (be32_to_cpu(sdt
->ref_tag
) == virt
)
343 sdt
->ref_tag
= cpu_to_be32(phys
);
352 bip
->bip_flags
|= BIP_MAPPED_INTEGRITY
;
357 * Remap physical sector values in the reference tag to the virtual
358 * values expected by the block layer.
360 void sd_dif_complete(struct scsi_cmnd
*scmd
, unsigned int good_bytes
)
362 const int tuple_sz
= sizeof(struct sd_dif_tuple
);
363 struct scsi_disk
*sdkp
;
365 struct sd_dif_tuple
*sdt
;
366 unsigned int j
, sectors
, sector_sz
;
369 sdkp
= scsi_disk(scmd
->request
->rq_disk
);
371 if (sdkp
->protection_type
== SD_DIF_TYPE3_PROTECTION
|| good_bytes
== 0)
374 sector_sz
= scmd
->device
->sector_size
;
375 sectors
= good_bytes
/ sector_sz
;
377 phys
= blk_rq_pos(scmd
->request
) & 0xffffffff;
378 if (sector_sz
== 4096)
381 __rq_for_each_bio(bio
, scmd
->request
) {
382 struct bio_integrity_payload
*bip
= bio_integrity(bio
);
384 struct bvec_iter iter
;
386 virt
= bip_get_seed(bip
) & 0xffffffff;
388 bip_for_each_vec(iv
, bip
, iter
) {
389 sdt
= kmap_atomic(iv
.bv_page
)
392 for (j
= 0; j
< iv
.bv_len
; j
+= tuple_sz
, sdt
++) {
399 if (be32_to_cpu(sdt
->ref_tag
) == phys
)
400 sdt
->ref_tag
= cpu_to_be32(virt
);