Commit c88f5e55 authored by Mikulas Patocka's avatar Mikulas Patocka Committed by Mike Snitzer
Browse files

dm-integrity: recheck the integrity tag after a failure 

If a userspace process reads (with O_DIRECT) multiple blocks into the same
buffer, dm-integrity reports an error [1]. The error is reported in a log
and it may cause RAID leg being kicked out of the array.

This commit fixes dm-integrity, so that if integrity verification fails,
the data is read again into a kernel buffer (where userspace can't modify
it) and the integrity tag is rechecked. If the recheck succeeds, the
content of the kernel buffer is copied into the user buffer; if the
recheck fails, an integrity error is reported.

[1] https://people.redhat.com/~mpatocka/testcases/blk-auth-modify/read2.c



Signed-off-by: default avatarMikulas Patocka <mpatocka@redhat.com>
Cc: stable@vger.kernel.org
Signed-off-by: default avatarMike Snitzer <snitzer@kernel.org>
parent 54be6c6c

drivers/md/dm-integrity.c

+84 −9
Original line number Diff line number Diff line
@@ -278,6 +278,8 @@ struct dm_integrity_c { 


	atomic64_t number_of_mismatches;



	mempool_t recheck_pool;



	struct notifier_block reboot_notifier;

};
@@ -1689,6 +1691,79 @@ static void integrity_sector_checksum(struct dm_integrity_c *ic, sector_t sector 
	get_random_bytes(result, ic->tag_size);

}



static void integrity_recheck(struct dm_integrity_io *dio)

{

	struct bio *bio = dm_bio_from_per_bio_data(dio, sizeof(struct dm_integrity_io));

	struct dm_integrity_c *ic = dio->ic;

	struct bvec_iter iter;

	struct bio_vec bv;

	sector_t sector, logical_sector, area, offset;

	char checksum_onstack[max_t(size_t, HASH_MAX_DIGESTSIZE, MAX_TAG_SIZE)];

	struct page *page;

	void *buffer;



	get_area_and_offset(ic, dio->range.logical_sector, &area, &offset);

	dio->metadata_block = get_metadata_sector_and_offset(ic, area, offset,

							     &dio->metadata_offset);

	sector = get_data_sector(ic, area, offset);

	logical_sector = dio->range.logical_sector;



	page = mempool_alloc(&ic->recheck_pool, GFP_NOIO);

	buffer = page_to_virt(page);



	__bio_for_each_segment(bv, bio, iter, dio->bio_details.bi_iter) {

		unsigned pos = 0;



		do {

			char *mem;

			int r;

			struct dm_io_request io_req;

			struct dm_io_region io_loc;

			io_req.bi_opf = REQ_OP_READ;

			io_req.mem.type = DM_IO_KMEM;

			io_req.mem.ptr.addr = buffer;

			io_req.notify.fn = NULL;

			io_req.client = ic->io;

			io_loc.bdev = ic->dev->bdev;

			io_loc.sector = sector;

			io_loc.count = ic->sectors_per_block;



			r = dm_io(&io_req, 1, &io_loc, NULL);

			if (unlikely(r)) {

				dio->bi_status = errno_to_blk_status(r);

				goto free_ret;

			}



			integrity_sector_checksum(ic, logical_sector, buffer,

						  checksum_onstack);

			r = dm_integrity_rw_tag(ic, checksum_onstack, &dio->metadata_block,

						&dio->metadata_offset, ic->tag_size, TAG_CMP);

			if (r) {

				if (r > 0) {

					DMERR_LIMIT("%pg: Checksum failed at sector 0x%llx",

						    bio->bi_bdev, logical_sector);

					atomic64_inc(&ic->number_of_mismatches);

					dm_audit_log_bio(DM_MSG_PREFIX, "integrity-checksum",

							 bio, logical_sector, 0);

					r = -EILSEQ;

				}

				dio->bi_status = errno_to_blk_status(r);

				goto free_ret;

			}



			mem = bvec_kmap_local(&bv);

			memcpy(mem + pos, buffer, ic->sectors_per_block << SECTOR_SHIFT);

			kunmap_local(mem);



			pos += ic->sectors_per_block << SECTOR_SHIFT;

			sector += ic->sectors_per_block;

			logical_sector += ic->sectors_per_block;

		} while (pos < bv.bv_len);

	}

free_ret:

	mempool_free(page, &ic->recheck_pool);

}



static void integrity_metadata(struct work_struct *w)

{

	struct dm_integrity_io *dio = container_of(w, struct dm_integrity_io, work);
@@ -1776,15 +1851,8 @@ static void integrity_metadata(struct work_struct *w) 
						checksums_ptr - checksums, dio->op == REQ_OP_READ ? TAG_CMP : TAG_WRITE);

			if (unlikely(r)) {

				if (r > 0) {

					sector_t s;



					s = sector - ((r + ic->tag_size - 1) / ic->tag_size);

					DMERR_LIMIT("%pg: Checksum failed at sector 0x%llx",

						    bio->bi_bdev, s);

					r = -EILSEQ;

					atomic64_inc(&ic->number_of_mismatches);

					dm_audit_log_bio(DM_MSG_PREFIX, "integrity-checksum",

							 bio, s, 0);

					integrity_recheck(dio);

					goto skip_io;

				}

				if (likely(checksums != checksums_onstack))

					kfree(checksums);
@@ -4261,6 +4329,12 @@ static int dm_integrity_ctr(struct dm_target *ti, unsigned int argc, char **argv 
		goto bad;

	}



	r = mempool_init_page_pool(&ic->recheck_pool, 1, 0);

	if (r) {

		ti->error = "Cannot allocate mempool";

		goto bad;

	}



	ic->metadata_wq = alloc_workqueue("dm-integrity-metadata",

					  WQ_MEM_RECLAIM, METADATA_WORKQUEUE_MAX_ACTIVE);

	if (!ic->metadata_wq) {
@@ -4609,6 +4683,7 @@ static void dm_integrity_dtr(struct dm_target *ti) 
	kvfree(ic->bbs);

	if (ic->bufio)

		dm_bufio_client_destroy(ic->bufio);

	mempool_exit(&ic->recheck_pool);

	mempool_exit(&ic->journal_io_mempool);

	if (ic->io)

		dm_io_client_destroy(ic->io);