blob: 2198abee619eeaebe939b920c01975220efff7ed [file] [log] [blame]
Martin K. Petersenaf55ff62008-07-17 04:28:35 -04001/*
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/crc-t10dif.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 <net/checksum.h>
37
38#include "sd.h"
39
40typedef __u16 (csum_fn) (void *, unsigned int);
41
42static __u16 sd_dif_crc_fn(void *data, unsigned int len)
43{
44 return cpu_to_be16(crc_t10dif(data, len));
45}
46
47static __u16 sd_dif_ip_fn(void *data, unsigned int len)
48{
49 return ip_compute_csum(data, len);
50}
51
52/*
53 * Type 1 and Type 2 protection use the same format: 16 bit guard tag,
54 * 16 bit app tag, 32 bit reference tag.
55 */
Martin K. Petersen18593082014-09-26 19:20:01 -040056static void sd_dif_type1_generate(struct blk_integrity_iter *iter, csum_fn *fn)
Martin K. Petersenaf55ff62008-07-17 04:28:35 -040057{
Martin K. Petersen18593082014-09-26 19:20:01 -040058 void *buf = iter->data_buf;
59 struct sd_dif_tuple *sdt = iter->prot_buf;
60 sector_t seed = iter->seed;
Martin K. Petersenaf55ff62008-07-17 04:28:35 -040061 unsigned int i;
62
Martin K. Petersen18593082014-09-26 19:20:01 -040063 for (i = 0 ; i < iter->data_size ; i += iter->interval, sdt++) {
64 sdt->guard_tag = fn(buf, iter->interval);
Martin K. Petersen3be91c42014-09-26 19:19:59 -040065 sdt->ref_tag = cpu_to_be32(seed & 0xffffffff);
Martin K. Petersenaf55ff62008-07-17 04:28:35 -040066 sdt->app_tag = 0;
67
Martin K. Petersen18593082014-09-26 19:20:01 -040068 buf += iter->interval;
Martin K. Petersen3be91c42014-09-26 19:19:59 -040069 seed++;
Martin K. Petersenaf55ff62008-07-17 04:28:35 -040070 }
71}
72
Martin K. Petersen18593082014-09-26 19:20:01 -040073static int sd_dif_type1_generate_crc(struct blk_integrity_iter *iter)
Martin K. Petersenaf55ff62008-07-17 04:28:35 -040074{
Martin K. Petersen18593082014-09-26 19:20:01 -040075 sd_dif_type1_generate(iter, sd_dif_crc_fn);
76 return 0;
Martin K. Petersenaf55ff62008-07-17 04:28:35 -040077}
78
Martin K. Petersen18593082014-09-26 19:20:01 -040079static int sd_dif_type1_generate_ip(struct blk_integrity_iter *iter)
Martin K. Petersenaf55ff62008-07-17 04:28:35 -040080{
Martin K. Petersen18593082014-09-26 19:20:01 -040081 sd_dif_type1_generate(iter, sd_dif_ip_fn);
82 return 0;
Martin K. Petersenaf55ff62008-07-17 04:28:35 -040083}
84
Martin K. Petersen18593082014-09-26 19:20:01 -040085static int sd_dif_type1_verify(struct blk_integrity_iter *iter, csum_fn *fn)
Martin K. Petersenaf55ff62008-07-17 04:28:35 -040086{
Martin K. Petersen18593082014-09-26 19:20:01 -040087 void *buf = iter->data_buf;
88 struct sd_dif_tuple *sdt = iter->prot_buf;
89 sector_t seed = iter->seed;
Martin K. Petersenaf55ff62008-07-17 04:28:35 -040090 unsigned int i;
91 __u16 csum;
92
Martin K. Petersen18593082014-09-26 19:20:01 -040093 for (i = 0 ; i < iter->data_size ; i += iter->interval, sdt++) {
Martin K. Petersenaf55ff62008-07-17 04:28:35 -040094 /* Unwritten sectors */
95 if (sdt->app_tag == 0xffff)
96 return 0;
97
Martin K. Petersen3be91c42014-09-26 19:19:59 -040098 if (be32_to_cpu(sdt->ref_tag) != (seed & 0xffffffff)) {
Martin K. Petersenaf55ff62008-07-17 04:28:35 -040099 printk(KERN_ERR
100 "%s: ref tag error on sector %lu (rcvd %u)\n",
Martin K. Petersen18593082014-09-26 19:20:01 -0400101 iter->disk_name, (unsigned long)seed,
Martin K. Petersenaf55ff62008-07-17 04:28:35 -0400102 be32_to_cpu(sdt->ref_tag));
103 return -EIO;
104 }
105
Martin K. Petersen18593082014-09-26 19:20:01 -0400106 csum = fn(buf, iter->interval);
Martin K. Petersenaf55ff62008-07-17 04:28:35 -0400107
108 if (sdt->guard_tag != csum) {
109 printk(KERN_ERR "%s: guard tag error on sector %lu " \
Martin K. Petersen18593082014-09-26 19:20:01 -0400110 "(rcvd %04x, data %04x)\n", iter->disk_name,
Martin K. Petersen3be91c42014-09-26 19:19:59 -0400111 (unsigned long)seed,
Martin K. Petersenaf55ff62008-07-17 04:28:35 -0400112 be16_to_cpu(sdt->guard_tag), be16_to_cpu(csum));
113 return -EIO;
114 }
115
Martin K. Petersen18593082014-09-26 19:20:01 -0400116 buf += iter->interval;
Martin K. Petersen3be91c42014-09-26 19:19:59 -0400117 seed++;
Martin K. Petersenaf55ff62008-07-17 04:28:35 -0400118 }
119
120 return 0;
121}
122
Martin K. Petersen18593082014-09-26 19:20:01 -0400123static int sd_dif_type1_verify_crc(struct blk_integrity_iter *iter)
Martin K. Petersenaf55ff62008-07-17 04:28:35 -0400124{
Martin K. Petersen18593082014-09-26 19:20:01 -0400125 return sd_dif_type1_verify(iter, sd_dif_crc_fn);
Martin K. Petersenaf55ff62008-07-17 04:28:35 -0400126}
127
Martin K. Petersen18593082014-09-26 19:20:01 -0400128static int sd_dif_type1_verify_ip(struct blk_integrity_iter *iter)
Martin K. Petersenaf55ff62008-07-17 04:28:35 -0400129{
Martin K. Petersen18593082014-09-26 19:20:01 -0400130 return sd_dif_type1_verify(iter, sd_dif_ip_fn);
Martin K. Petersenaf55ff62008-07-17 04:28:35 -0400131}
132
Martin K. Petersenaf55ff62008-07-17 04:28:35 -0400133static 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,
Martin K. Petersenaf55ff62008-07-17 04:28:35 -0400137 .tuple_size = sizeof(struct sd_dif_tuple),
138 .tag_size = 0,
139};
140
141static 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,
Martin K. Petersenaf55ff62008-07-17 04:28:35 -0400145 .tuple_size = sizeof(struct sd_dif_tuple),
146 .tag_size = 0,
147};
148
149
150/*
151 * Type 3 protection has a 16-bit guard tag and 16 + 32 bits of opaque
152 * tag space.
153 */
Martin K. Petersen18593082014-09-26 19:20:01 -0400154static void sd_dif_type3_generate(struct blk_integrity_iter *iter, csum_fn *fn)
Martin K. Petersenaf55ff62008-07-17 04:28:35 -0400155{
Martin K. Petersen18593082014-09-26 19:20:01 -0400156 void *buf = iter->data_buf;
157 struct sd_dif_tuple *sdt = iter->prot_buf;
Martin K. Petersenaf55ff62008-07-17 04:28:35 -0400158 unsigned int i;
159
Martin K. Petersen18593082014-09-26 19:20:01 -0400160 for (i = 0 ; i < iter->data_size ; i += iter->interval, sdt++) {
161 sdt->guard_tag = fn(buf, iter->interval);
Martin K. Petersenaf55ff62008-07-17 04:28:35 -0400162 sdt->ref_tag = 0;
163 sdt->app_tag = 0;
164
Martin K. Petersen18593082014-09-26 19:20:01 -0400165 buf += iter->interval;
Martin K. Petersenaf55ff62008-07-17 04:28:35 -0400166 }
167}
168
Martin K. Petersen18593082014-09-26 19:20:01 -0400169static int sd_dif_type3_generate_crc(struct blk_integrity_iter *iter)
Martin K. Petersenaf55ff62008-07-17 04:28:35 -0400170{
Martin K. Petersen18593082014-09-26 19:20:01 -0400171 sd_dif_type3_generate(iter, sd_dif_crc_fn);
172 return 0;
Martin K. Petersenaf55ff62008-07-17 04:28:35 -0400173}
174
Martin K. Petersen18593082014-09-26 19:20:01 -0400175static int sd_dif_type3_generate_ip(struct blk_integrity_iter *iter)
Martin K. Petersenaf55ff62008-07-17 04:28:35 -0400176{
Martin K. Petersen18593082014-09-26 19:20:01 -0400177 sd_dif_type3_generate(iter, sd_dif_ip_fn);
178 return 0;
Martin K. Petersenaf55ff62008-07-17 04:28:35 -0400179}
180
Martin K. Petersen18593082014-09-26 19:20:01 -0400181static int sd_dif_type3_verify(struct blk_integrity_iter *iter, csum_fn *fn)
Martin K. Petersenaf55ff62008-07-17 04:28:35 -0400182{
Martin K. Petersen18593082014-09-26 19:20:01 -0400183 void *buf = iter->data_buf;
184 struct sd_dif_tuple *sdt = iter->prot_buf;
185 sector_t seed = iter->seed;
Martin K. Petersenaf55ff62008-07-17 04:28:35 -0400186 unsigned int i;
187 __u16 csum;
188
Martin K. Petersen18593082014-09-26 19:20:01 -0400189 for (i = 0 ; i < iter->data_size ; i += iter->interval, sdt++) {
Martin K. Petersenaf55ff62008-07-17 04:28:35 -0400190 /* Unwritten sectors */
191 if (sdt->app_tag == 0xffff && sdt->ref_tag == 0xffffffff)
192 return 0;
193
Martin K. Petersen18593082014-09-26 19:20:01 -0400194 csum = fn(buf, iter->interval);
Martin K. Petersenaf55ff62008-07-17 04:28:35 -0400195
196 if (sdt->guard_tag != csum) {
197 printk(KERN_ERR "%s: guard tag error on sector %lu " \
Martin K. Petersen18593082014-09-26 19:20:01 -0400198 "(rcvd %04x, data %04x)\n", iter->disk_name,
Martin K. Petersen3be91c42014-09-26 19:19:59 -0400199 (unsigned long)seed,
Martin K. Petersenaf55ff62008-07-17 04:28:35 -0400200 be16_to_cpu(sdt->guard_tag), be16_to_cpu(csum));
201 return -EIO;
202 }
203
Martin K. Petersen18593082014-09-26 19:20:01 -0400204 buf += iter->interval;
Martin K. Petersen3be91c42014-09-26 19:19:59 -0400205 seed++;
Martin K. Petersenaf55ff62008-07-17 04:28:35 -0400206 }
207
208 return 0;
209}
210
Martin K. Petersen18593082014-09-26 19:20:01 -0400211static int sd_dif_type3_verify_crc(struct blk_integrity_iter *iter)
Martin K. Petersenaf55ff62008-07-17 04:28:35 -0400212{
Martin K. Petersen18593082014-09-26 19:20:01 -0400213 return sd_dif_type3_verify(iter, sd_dif_crc_fn);
Martin K. Petersenaf55ff62008-07-17 04:28:35 -0400214}
215
Martin K. Petersen18593082014-09-26 19:20:01 -0400216static int sd_dif_type3_verify_ip(struct blk_integrity_iter *iter)
Martin K. Petersenaf55ff62008-07-17 04:28:35 -0400217{
Martin K. Petersen18593082014-09-26 19:20:01 -0400218 return sd_dif_type3_verify(iter, sd_dif_ip_fn);
Martin K. Petersenaf55ff62008-07-17 04:28:35 -0400219}
220
Martin K. Petersenaf55ff62008-07-17 04:28:35 -0400221static 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,
Martin K. Petersenaf55ff62008-07-17 04:28:35 -0400225 .tuple_size = sizeof(struct sd_dif_tuple),
226 .tag_size = 0,
227};
228
229static 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,
Martin K. Petersenaf55ff62008-07-17 04:28:35 -0400233 .tuple_size = sizeof(struct sd_dif_tuple),
234 .tag_size = 0,
235};
236
237/*
238 * Configure exchange of protection information between OS and HBA.
239 */
240void sd_dif_config_host(struct scsi_disk *sdkp)
241{
242 struct scsi_device *sdp = sdkp->device;
243 struct gendisk *disk = sdkp->disk;
244 u8 type = sdkp->protection_type;
Martin K. Petersen9e066882008-09-19 18:47:21 -0400245 int dif, dix;
Martin K. Petersenaf55ff62008-07-17 04:28:35 -0400246
Martin K. Petersen9e066882008-09-19 18:47:21 -0400247 dif = scsi_host_dif_capable(sdp->host, type);
248 dix = scsi_host_dix_capable(sdp->host, type);
Martin K. Petersenaf55ff62008-07-17 04:28:35 -0400249
Martin K. Petersen9e066882008-09-19 18:47:21 -0400250 if (!dix && scsi_host_dix_capable(sdp->host, 0)) {
251 dif = 0; dix = 1;
Martin K. Petersenaf55ff62008-07-17 04:28:35 -0400252 }
253
Martin K. Petersen9e066882008-09-19 18:47:21 -0400254 if (!dix)
255 return;
256
Martin K. Petersenaf55ff62008-07-17 04:28:35 -0400257 /* Enable DMA of protection information */
Martin K. Petersenaae7df52014-09-26 19:20:05 -0400258 if (scsi_host_get_guard(sdkp->device->host) & SHOST_DIX_GUARD_IP) {
Martin K. Petersenaf55ff62008-07-17 04:28:35 -0400259 if (type == SD_DIF_TYPE3_PROTECTION)
260 blk_integrity_register(disk, &dif_type3_integrity_ip);
261 else
262 blk_integrity_register(disk, &dif_type1_integrity_ip);
Martin K. Petersenaae7df52014-09-26 19:20:05 -0400263
264 disk->integrity->flags |= BLK_INTEGRITY_IP_CHECKSUM;
265 } else
Martin K. Petersenaf55ff62008-07-17 04:28:35 -0400266 if (type == SD_DIF_TYPE3_PROTECTION)
267 blk_integrity_register(disk, &dif_type3_integrity_crc);
268 else
269 blk_integrity_register(disk, &dif_type1_integrity_crc);
270
Martin K. Petersencbdc1442008-10-01 01:37:21 -0400271 sd_printk(KERN_NOTICE, sdkp,
Martin K. Petersen9e066882008-09-19 18:47:21 -0400272 "Enabling DIX %s protection\n", disk->integrity->name);
Martin K. Petersenaf55ff62008-07-17 04:28:35 -0400273
274 /* Signal to block layer that we support sector tagging */
Martin K. Petersen3aec2f42014-09-26 19:20:03 -0400275 if (dif && type) {
276
277 disk->integrity->flags |= BLK_INTEGRITY_DEVICE_CAPABLE;
278
279 if (!sdkp)
280 return;
281
Martin K. Petersenaf55ff62008-07-17 04:28:35 -0400282 if (type == SD_DIF_TYPE3_PROTECTION)
283 disk->integrity->tag_size = sizeof(u16) + sizeof(u32);
284 else
285 disk->integrity->tag_size = sizeof(u16);
286
Martin K. Petersencbdc1442008-10-01 01:37:21 -0400287 sd_printk(KERN_NOTICE, sdkp, "DIF application tag size %u\n",
Martin K. Petersenaf55ff62008-07-17 04:28:35 -0400288 disk->integrity->tag_size);
289 }
290}
291
292/*
Martin K. Petersenaf55ff62008-07-17 04:28:35 -0400293 * 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.
297 *
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.
305 *
306 * Type 3 does not have a reference tag so no remapping is required.
307 */
Martin K. Petersen8c579ab2012-08-28 14:29:33 -0400308void sd_dif_prepare(struct request *rq, sector_t hw_sector,
309 unsigned int sector_sz)
Martin K. Petersenaf55ff62008-07-17 04:28:35 -0400310{
311 const int tuple_sz = sizeof(struct sd_dif_tuple);
312 struct bio *bio;
313 struct scsi_disk *sdkp;
314 struct sd_dif_tuple *sdt;
Martin K. Petersenaf55ff62008-07-17 04:28:35 -0400315 u32 phys, virt;
316
Martin K. Petersenaf55ff62008-07-17 04:28:35 -0400317 sdkp = rq->bio->bi_bdev->bd_disk->private_data;
318
319 if (sdkp->protection_type == SD_DIF_TYPE3_PROTECTION)
Martin K. Petersen8c579ab2012-08-28 14:29:33 -0400320 return;
Martin K. Petersenaf55ff62008-07-17 04:28:35 -0400321
Martin K. Petersenaf55ff62008-07-17 04:28:35 -0400322 phys = hw_sector & 0xffffffff;
323
324 __rq_for_each_bio(bio, rq) {
Martin K. Petersen18593082014-09-26 19:20:01 -0400325 struct bio_integrity_payload *bip = bio_integrity(bio);
Kent Overstreetd57a5f72013-11-23 17:20:16 -0800326 struct bio_vec iv;
327 struct bvec_iter iter;
328 unsigned int j;
Martin K. Petersenaf55ff62008-07-17 04:28:35 -0400329
Martin K. Petersen495d2b32010-10-15 15:49:20 +0200330 /* Already remapped? */
Martin K. Petersenb1f0138852014-09-26 19:20:04 -0400331 if (bip->bip_flags & BIP_MAPPED_INTEGRITY)
Martin K. Petersen495d2b32010-10-15 15:49:20 +0200332 break;
333
Martin K. Petersen18593082014-09-26 19:20:01 -0400334 virt = bip_get_seed(bip) & 0xffffffff;
Martin K. Petersenaf55ff62008-07-17 04:28:35 -0400335
Martin K. Petersen18593082014-09-26 19:20:01 -0400336 bip_for_each_vec(iv, bip, iter) {
Kent Overstreetd57a5f72013-11-23 17:20:16 -0800337 sdt = kmap_atomic(iv.bv_page)
338 + iv.bv_offset;
Martin K. Petersenaf55ff62008-07-17 04:28:35 -0400339
Kent Overstreetd57a5f72013-11-23 17:20:16 -0800340 for (j = 0; j < iv.bv_len; j += tuple_sz, sdt++) {
Martin K. Petersenaf55ff62008-07-17 04:28:35 -0400341
Martin K. Petersen8c579ab2012-08-28 14:29:33 -0400342 if (be32_to_cpu(sdt->ref_tag) == virt)
343 sdt->ref_tag = cpu_to_be32(phys);
Martin K. Petersenaf55ff62008-07-17 04:28:35 -0400344
Martin K. Petersenaf55ff62008-07-17 04:28:35 -0400345 virt++;
346 phys++;
347 }
348
Cong Wang77dfce02011-11-25 23:14:23 +0800349 kunmap_atomic(sdt);
Martin K. Petersenaf55ff62008-07-17 04:28:35 -0400350 }
Martin K. Petersen495d2b32010-10-15 15:49:20 +0200351
Martin K. Petersenb1f0138852014-09-26 19:20:04 -0400352 bip->bip_flags |= BIP_MAPPED_INTEGRITY;
Martin K. Petersenaf55ff62008-07-17 04:28:35 -0400353 }
Martin K. Petersenaf55ff62008-07-17 04:28:35 -0400354}
355
356/*
357 * Remap physical sector values in the reference tag to the virtual
358 * values expected by the block layer.
359 */
360void sd_dif_complete(struct scsi_cmnd *scmd, unsigned int good_bytes)
361{
362 const int tuple_sz = sizeof(struct sd_dif_tuple);
363 struct scsi_disk *sdkp;
364 struct bio *bio;
365 struct sd_dif_tuple *sdt;
Kent Overstreetd57a5f72013-11-23 17:20:16 -0800366 unsigned int j, sectors, sector_sz;
Martin K. Petersenaf55ff62008-07-17 04:28:35 -0400367 u32 phys, virt;
368
369 sdkp = scsi_disk(scmd->request->rq_disk);
370
371 if (sdkp->protection_type == SD_DIF_TYPE3_PROTECTION || good_bytes == 0)
372 return;
373
374 sector_sz = scmd->device->sector_size;
375 sectors = good_bytes / sector_sz;
376
Tejun Heo83096eb2009-05-07 22:24:39 +0900377 phys = blk_rq_pos(scmd->request) & 0xffffffff;
Martin K. Petersenaf55ff62008-07-17 04:28:35 -0400378 if (sector_sz == 4096)
379 phys >>= 3;
380
381 __rq_for_each_bio(bio, scmd->request) {
Martin K. Petersen18593082014-09-26 19:20:01 -0400382 struct bio_integrity_payload *bip = bio_integrity(bio);
Kent Overstreetd57a5f72013-11-23 17:20:16 -0800383 struct bio_vec iv;
384 struct bvec_iter iter;
Martin K. Petersenaf55ff62008-07-17 04:28:35 -0400385
Martin K. Petersen18593082014-09-26 19:20:01 -0400386 virt = bip_get_seed(bip) & 0xffffffff;
Martin K. Petersenaf55ff62008-07-17 04:28:35 -0400387
Martin K. Petersen18593082014-09-26 19:20:01 -0400388 bip_for_each_vec(iv, bip, iter) {
Kent Overstreetd57a5f72013-11-23 17:20:16 -0800389 sdt = kmap_atomic(iv.bv_page)
390 + iv.bv_offset;
Martin K. Petersenaf55ff62008-07-17 04:28:35 -0400391
Kent Overstreetd57a5f72013-11-23 17:20:16 -0800392 for (j = 0; j < iv.bv_len; j += tuple_sz, sdt++) {
Martin K. Petersenaf55ff62008-07-17 04:28:35 -0400393
394 if (sectors == 0) {
Cong Wang77dfce02011-11-25 23:14:23 +0800395 kunmap_atomic(sdt);
Martin K. Petersenaf55ff62008-07-17 04:28:35 -0400396 return;
397 }
398
Martin K. Petersen8c579ab2012-08-28 14:29:33 -0400399 if (be32_to_cpu(sdt->ref_tag) == phys)
Martin K. Petersenaf55ff62008-07-17 04:28:35 -0400400 sdt->ref_tag = cpu_to_be32(virt);
401
402 virt++;
403 phys++;
404 sectors--;
405 }
406
Cong Wang77dfce02011-11-25 23:14:23 +0800407 kunmap_atomic(sdt);
Martin K. Petersenaf55ff62008-07-17 04:28:35 -0400408 }
409 }
410}
411