xref: /linux/block/t10-pi.c (revision 067012974c8ae31a8886046df082aeba93592972) 
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * t10_pi.c - Functions for generating and verifying T10 Protection
4  *	      Information.
5  */
6 
7 #include <linux/t10-pi.h>
8 #include <linux/blkdev.h>
9 #include <linux/crc-t10dif.h>
10 #include <linux/module.h>
11 #include <net/checksum.h>
12 
13 typedef __be16 (csum_fn) (void *, unsigned int);
14 
15 static __be16 t10_pi_crc_fn(void *data, unsigned int len)
16 {
17 	return cpu_to_be16(crc_t10dif(data, len));
18 }
19 
20 static __be16 t10_pi_ip_fn(void *data, unsigned int len)
21 {
22 	return (__force __be16)ip_compute_csum(data, len);
23 }
24 
25 /*
26  * Type 1 and Type 2 protection use the same format: 16 bit guard tag,
27  * 16 bit app tag, 32 bit reference tag. Type 3 does not define the ref
28  * tag.
29  */
30 static blk_status_t t10_pi_generate(struct blk_integrity_iter *iter,
31 		csum_fn *fn, enum t10_dif_type type)
32 {
33 	unsigned int i;
34 
35 	for (i = 0 ; i < iter->data_size ; i += iter->interval) {
36 		struct t10_pi_tuple *pi = iter->prot_buf;
37 
38 		pi->guard_tag = fn(iter->data_buf, iter->interval);
39 		pi->app_tag = 0;
40 
41 		if (type == T10_PI_TYPE1_PROTECTION)
42 			pi->ref_tag = cpu_to_be32(lower_32_bits(iter->seed));
43 		else
44 			pi->ref_tag = 0;
45 
46 		iter->data_buf += iter->interval;
47 		iter->prot_buf += sizeof(struct t10_pi_tuple);
48 		iter->seed++;
49 	}
50 
51 	return BLK_STS_OK;
52 }
53 
54 static blk_status_t t10_pi_verify(struct blk_integrity_iter *iter,
55 		csum_fn *fn, enum t10_dif_type type)
56 {
57 	unsigned int i;
58 
59 	BUG_ON(type == T10_PI_TYPE0_PROTECTION);
60 
61 	for (i = 0 ; i < iter->data_size ; i += iter->interval) {
62 		struct t10_pi_tuple *pi = iter->prot_buf;
63 		__be16 csum;
64 
65 		if (type == T10_PI_TYPE1_PROTECTION ||
66 		    type == T10_PI_TYPE2_PROTECTION) {
67 			if (pi->app_tag == T10_PI_APP_ESCAPE)
68 				goto next;
69 
70 			if (be32_to_cpu(pi->ref_tag) !=
71 			    lower_32_bits(iter->seed)) {
72 				pr_err("%s: ref tag error at location %llu " \
73 				       "(rcvd %u)\n", iter->disk_name,
74 				       (unsigned long long)
75 				       iter->seed, be32_to_cpu(pi->ref_tag));
76 				return BLK_STS_PROTECTION;
77 			}
78 		} else if (type == T10_PI_TYPE3_PROTECTION) {
79 			if (pi->app_tag == T10_PI_APP_ESCAPE &&
80 			    pi->ref_tag == T10_PI_REF_ESCAPE)
81 				goto next;
82 		}
83 
84 		csum = fn(iter->data_buf, iter->interval);
85 
86 		if (pi->guard_tag != csum) {
87 			pr_err("%s: guard tag error at sector %llu " \
88 			       "(rcvd %04x, want %04x)\n", iter->disk_name,
89 			       (unsigned long long)iter->seed,
90 			       be16_to_cpu(pi->guard_tag), be16_to_cpu(csum));
91 			return BLK_STS_PROTECTION;
92 		}
93 
94 next:
95 		iter->data_buf += iter->interval;
96 		iter->prot_buf += sizeof(struct t10_pi_tuple);
97 		iter->seed++;
98 	}
99 
100 	return BLK_STS_OK;
101 }
102 
103 static blk_status_t t10_pi_type1_generate_crc(struct blk_integrity_iter *iter)
104 {
105 	return t10_pi_generate(iter, t10_pi_crc_fn, T10_PI_TYPE1_PROTECTION);
106 }
107 
108 static blk_status_t t10_pi_type1_generate_ip(struct blk_integrity_iter *iter)
109 {
110 	return t10_pi_generate(iter, t10_pi_ip_fn, T10_PI_TYPE1_PROTECTION);
111 }
112 
113 static blk_status_t t10_pi_type1_verify_crc(struct blk_integrity_iter *iter)
114 {
115 	return t10_pi_verify(iter, t10_pi_crc_fn, T10_PI_TYPE1_PROTECTION);
116 }
117 
118 static blk_status_t t10_pi_type1_verify_ip(struct blk_integrity_iter *iter)
119 {
120 	return t10_pi_verify(iter, t10_pi_ip_fn, T10_PI_TYPE1_PROTECTION);
121 }
122 
123 /**
124  * t10_pi_type1_prepare - prepare PI prior submitting request to device
125  * @rq:              request with PI that should be prepared
126  *
127  * For Type 1/Type 2, the virtual start sector is the one that was
128  * originally submitted by the block layer for the ref_tag usage. Due to
129  * partitioning, MD/DM cloning, etc. the actual physical start sector is
130  * likely to be different. Remap protection information to match the
131  * physical LBA.
132  */
133 static void t10_pi_type1_prepare(struct request *rq)
134 {
135 	const int tuple_sz = rq->q->integrity.tuple_size;
136 	u32 ref_tag = t10_pi_ref_tag(rq);
137 	struct bio *bio;
138 
139 	__rq_for_each_bio(bio, rq) {
140 		struct bio_integrity_payload *bip = bio_integrity(bio);
141 		u32 virt = bip_get_seed(bip) & 0xffffffff;
142 		struct bio_vec iv;
143 		struct bvec_iter iter;
144 
145 		/* Already remapped? */
146 		if (bip->bip_flags & BIP_MAPPED_INTEGRITY)
147 			break;
148 
149 		bip_for_each_vec(iv, bip, iter) {
150 			void *p, *pmap;
151 			unsigned int j;
152 
153 			pmap = kmap_atomic(iv.bv_page);
154 			p = pmap + iv.bv_offset;
155 			for (j = 0; j < iv.bv_len; j += tuple_sz) {
156 				struct t10_pi_tuple *pi = p;
157 
158 				if (be32_to_cpu(pi->ref_tag) == virt)
159 					pi->ref_tag = cpu_to_be32(ref_tag);
160 				virt++;
161 				ref_tag++;
162 				p += tuple_sz;
163 			}
164 
165 			kunmap_atomic(pmap);
166 		}
167 
168 		bip->bip_flags |= BIP_MAPPED_INTEGRITY;
169 	}
170 }
171 
172 /**
173  * t10_pi_type1_complete - prepare PI prior returning request to the blk layer
174  * @rq:              request with PI that should be prepared
175  * @nr_bytes:        total bytes to prepare
176  *
177  * For Type 1/Type 2, the virtual start sector is the one that was
178  * originally submitted by the block layer for the ref_tag usage. Due to
179  * partitioning, MD/DM cloning, etc. the actual physical start sector is
180  * likely to be different. Since the physical start sector was submitted
181  * to the device, we should remap it back to virtual values expected by the
182  * block layer.
183  */
184 static void t10_pi_type1_complete(struct request *rq, unsigned int nr_bytes)
185 {
186 	unsigned intervals = nr_bytes >> rq->q->integrity.interval_exp;
187 	const int tuple_sz = rq->q->integrity.tuple_size;
188 	u32 ref_tag = t10_pi_ref_tag(rq);
189 	struct bio *bio;
190 
191 	__rq_for_each_bio(bio, rq) {
192 		struct bio_integrity_payload *bip = bio_integrity(bio);
193 		u32 virt = bip_get_seed(bip) & 0xffffffff;
194 		struct bio_vec iv;
195 		struct bvec_iter iter;
196 
197 		bip_for_each_vec(iv, bip, iter) {
198 			void *p, *pmap;
199 			unsigned int j;
200 
201 			pmap = kmap_atomic(iv.bv_page);
202 			p = pmap + iv.bv_offset;
203 			for (j = 0; j < iv.bv_len && intervals; j += tuple_sz) {
204 				struct t10_pi_tuple *pi = p;
205 
206 				if (be32_to_cpu(pi->ref_tag) == ref_tag)
207 					pi->ref_tag = cpu_to_be32(virt);
208 				virt++;
209 				ref_tag++;
210 				intervals--;
211 				p += tuple_sz;
212 			}
213 
214 			kunmap_atomic(pmap);
215 		}
216 	}
217 }
218 
219 static blk_status_t t10_pi_type3_generate_crc(struct blk_integrity_iter *iter)
220 {
221 	return t10_pi_generate(iter, t10_pi_crc_fn, T10_PI_TYPE3_PROTECTION);
222 }
223 
224 static blk_status_t t10_pi_type3_generate_ip(struct blk_integrity_iter *iter)
225 {
226 	return t10_pi_generate(iter, t10_pi_ip_fn, T10_PI_TYPE3_PROTECTION);
227 }
228 
229 static blk_status_t t10_pi_type3_verify_crc(struct blk_integrity_iter *iter)
230 {
231 	return t10_pi_verify(iter, t10_pi_crc_fn, T10_PI_TYPE3_PROTECTION);
232 }
233 
234 static blk_status_t t10_pi_type3_verify_ip(struct blk_integrity_iter *iter)
235 {
236 	return t10_pi_verify(iter, t10_pi_ip_fn, T10_PI_TYPE3_PROTECTION);
237 }
238 
239 /* Type 3 does not have a reference tag so no remapping is required. */
240 static void t10_pi_type3_prepare(struct request *rq)
241 {
242 }
243 
244 /* Type 3 does not have a reference tag so no remapping is required. */
245 static void t10_pi_type3_complete(struct request *rq, unsigned int nr_bytes)
246 {
247 }
248 
249 const struct blk_integrity_profile t10_pi_type1_crc = {
250 	.name			= "T10-DIF-TYPE1-CRC",
251 	.generate_fn		= t10_pi_type1_generate_crc,
252 	.verify_fn		= t10_pi_type1_verify_crc,
253 	.prepare_fn		= t10_pi_type1_prepare,
254 	.complete_fn		= t10_pi_type1_complete,
255 };
256 EXPORT_SYMBOL(t10_pi_type1_crc);
257 
258 const struct blk_integrity_profile t10_pi_type1_ip = {
259 	.name			= "T10-DIF-TYPE1-IP",
260 	.generate_fn		= t10_pi_type1_generate_ip,
261 	.verify_fn		= t10_pi_type1_verify_ip,
262 	.prepare_fn		= t10_pi_type1_prepare,
263 	.complete_fn		= t10_pi_type1_complete,
264 };
265 EXPORT_SYMBOL(t10_pi_type1_ip);
266 
267 const struct blk_integrity_profile t10_pi_type3_crc = {
268 	.name			= "T10-DIF-TYPE3-CRC",
269 	.generate_fn		= t10_pi_type3_generate_crc,
270 	.verify_fn		= t10_pi_type3_verify_crc,
271 	.prepare_fn		= t10_pi_type3_prepare,
272 	.complete_fn		= t10_pi_type3_complete,
273 };
274 EXPORT_SYMBOL(t10_pi_type3_crc);
275 
276 const struct blk_integrity_profile t10_pi_type3_ip = {
277 	.name			= "T10-DIF-TYPE3-IP",
278 	.generate_fn		= t10_pi_type3_generate_ip,
279 	.verify_fn		= t10_pi_type3_verify_ip,
280 	.prepare_fn		= t10_pi_type3_prepare,
281 	.complete_fn		= t10_pi_type3_complete,
282 };
283 EXPORT_SYMBOL(t10_pi_type3_ip);
284 
285 MODULE_LICENSE("GPL");
286