Commit d5178578 authored by Johannes Thumshirn's avatar Johannes Thumshirn Committed by David Sterba
Browse files

btrfs: directly call into crypto framework for checksumming 



Currently btrfs_csum_data() relied on the crc32c() wrapper around the
crypto framework for calculating the CRCs.

As we have our own crypto_shash structure in the fs_info now, we can
directly call into the crypto framework without going trough the wrapper.

This way we can even remove the btrfs_csum_data() and btrfs_csum_final()
wrappers.

The module dependency on crc32c is preserved via MODULE_SOFTDEP("pre:
crc32c"), which was previously provided by LIBCRC32C config option doing
the same.

Signed-off-by: default avatarJohannes Thumshirn <jthumshirn@suse.de>
Reviewed-by: default avatarDavid Sterba <dsterba@suse.com>
Signed-off-by: default avatarDavid Sterba <dsterba@suse.com>
parent 6d97c6e3

fs/btrfs/Kconfig

+2 −1
Original line number Diff line number Diff line
@@ -2,7 +2,8 @@ 


config BTRFS_FS

	tristate "Btrfs filesystem support"

	select LIBCRC32C

	select CRYPTO

	select CRYPTO_CRC32C

	select ZLIB_INFLATE

	select ZLIB_DEFLATE

	select LZO_COMPRESS

fs/btrfs/check-integrity.c

+7 −4
Original line number Diff line number Diff line
@@ -83,7 +83,7 @@ 
#include <linux/blkdev.h>

#include <linux/mm.h>

#include <linux/string.h>

#include <linux/crc32c.h>

#include <crypto/hash.h>

#include "ctree.h"

#include "disk-io.h"

#include "transaction.h"
@@ -1710,9 +1710,9 @@ static int btrfsic_test_for_metadata(struct btrfsic_state *state, 
				     char **datav, unsigned int num_pages)

{

	struct btrfs_fs_info *fs_info = state->fs_info;

	SHASH_DESC_ON_STACK(shash, fs_info->csum_shash);

	struct btrfs_header *h;

	u8 csum[BTRFS_CSUM_SIZE];

	u32 crc = ~(u32)0;

	unsigned int i;



	if (num_pages * PAGE_SIZE < state->metablock_size)
@@ -1723,14 +1723,17 @@ static int btrfsic_test_for_metadata(struct btrfsic_state *state, 
	if (memcmp(h->fsid, fs_info->fs_devices->fsid, BTRFS_FSID_SIZE))

		return 1;



	shash->tfm = fs_info->csum_shash;

	crypto_shash_init(shash);



	for (i = 0; i < num_pages; i++) {

		u8 *data = i ? datav[i] : (datav[i] + BTRFS_CSUM_SIZE);

		size_t sublen = i ? PAGE_SIZE :

				    (PAGE_SIZE - BTRFS_CSUM_SIZE);



		crc = btrfs_csum_data(data, crc, sublen);

		crypto_shash_update(shash, data, sublen);

	}

	btrfs_csum_final(crc, csum);

	crypto_shash_final(shash, csum);

	if (memcmp(csum, h->csum, state->csum_size))

		return 1;

fs/btrfs/compression.c

+11 −6
Original line number Diff line number Diff line
@@ -17,6 +17,7 @@ 
#include <linux/slab.h>

#include <linux/sched/mm.h>

#include <linux/log2.h>

#include <crypto/hash.h>

#include "ctree.h"

#include "disk-io.h"

#include "transaction.h"
@@ -58,29 +59,33 @@ static int check_compressed_csum(struct btrfs_inode *inode, 
				 u64 disk_start)

{

	struct btrfs_fs_info *fs_info = inode->root->fs_info;

	SHASH_DESC_ON_STACK(shash, fs_info->csum_shash);

	const u16 csum_size = btrfs_super_csum_size(fs_info->super_copy);

	int ret;

	struct page *page;

	unsigned long i;

	char *kaddr;

	u32 csum;

	u8 csum[BTRFS_CSUM_SIZE];

	u8 *cb_sum = cb->sums;



	if (inode->flags & BTRFS_INODE_NODATASUM)

		return 0;



	shash->tfm = fs_info->csum_shash;



	for (i = 0; i < cb->nr_pages; i++) {

		page = cb->compressed_pages[i];

		csum = ~(u32)0;



		crypto_shash_init(shash);

		kaddr = kmap_atomic(page);

		csum = btrfs_csum_data(kaddr, csum, PAGE_SIZE);

		btrfs_csum_final(csum, (u8 *)&csum);

		crypto_shash_update(shash, kaddr, PAGE_SIZE);

		kunmap_atomic(kaddr);

		crypto_shash_final(shash, (u8 *)&csum);



		if (memcmp(&csum, cb_sum, csum_size)) {

			btrfs_print_data_csum_error(inode, disk_start, csum,

					*(u32 *)cb_sum, cb->mirror_num);

			btrfs_print_data_csum_error(inode, disk_start,

						    *(u32 *)csum, *(u32 *)cb_sum,

						    cb->mirror_num);

			ret = -EIO;

			goto fail;

		}

fs/btrfs/disk-io.c

+23 −23
Original line number Diff line number Diff line
@@ -246,16 +246,6 @@ out: 
	return em;

}



u32 btrfs_csum_data(const char *data, u32 seed, size_t len)

{

	return crc32c(seed, data, len);

}



void btrfs_csum_final(u32 crc, u8 *result)

{

	put_unaligned_le32(~crc, result);

}



/*

 * Compute the csum of a btree block and store the result to provided buffer.

 *
@@ -263,6 +253,8 @@ void btrfs_csum_final(u32 crc, u8 *result) 
 */

static int csum_tree_block(struct extent_buffer *buf, u8 *result)

{

	struct btrfs_fs_info *fs_info = buf->fs_info;

	SHASH_DESC_ON_STACK(shash, fs_info->csum_shash);

	unsigned long len;

	unsigned long cur_len;

	unsigned long offset = BTRFS_CSUM_SIZE;
@@ -270,9 +262,12 @@ static int csum_tree_block(struct extent_buffer *buf, u8 *result) 
	unsigned long map_start;

	unsigned long map_len;

	int err;

	u32 crc = ~(u32)0;



	shash->tfm = fs_info->csum_shash;

	crypto_shash_init(shash);



	len = buf->len - offset;



	while (len > 0) {

		/*

		 * Note: we don't need to check for the err == 1 case here, as
@@ -285,14 +280,13 @@ static int csum_tree_block(struct extent_buffer *buf, u8 *result) 
		if (WARN_ON(err))

			return err;

		cur_len = min(len, map_len - (offset - map_start));

		crc = btrfs_csum_data(kaddr + offset - map_start,

				      crc, cur_len);

		crypto_shash_update(shash, kaddr + offset - map_start, cur_len);

		len -= cur_len;

		offset += cur_len;

	}

	memset(result, 0, BTRFS_CSUM_SIZE);



	btrfs_csum_final(crc, result);

	crypto_shash_final(shash, result);



	return 0;

}
@@ -372,17 +366,20 @@ static int btrfs_check_super_csum(struct btrfs_fs_info *fs_info, 
{

	struct btrfs_super_block *disk_sb =

		(struct btrfs_super_block *)raw_disk_sb;

	u32 crc = ~(u32)0;

	char result[BTRFS_CSUM_SIZE];

	SHASH_DESC_ON_STACK(shash, fs_info->csum_shash);



	shash->tfm = fs_info->csum_shash;

	crypto_shash_init(shash);



	/*

	 * The super_block structure does not span the whole

	 * BTRFS_SUPER_INFO_SIZE range, we expect that the unused space is

	 * filled with zeros and is included in the checksum.

	 */

	crc = btrfs_csum_data(raw_disk_sb + BTRFS_CSUM_SIZE,

			      crc, BTRFS_SUPER_INFO_SIZE - BTRFS_CSUM_SIZE);

	btrfs_csum_final(crc, result);

	crypto_shash_update(shash, raw_disk_sb + BTRFS_CSUM_SIZE,

			    BTRFS_SUPER_INFO_SIZE - BTRFS_CSUM_SIZE);

	crypto_shash_final(shash, result);



	if (memcmp(disk_sb->csum, result, btrfs_super_csum_size(disk_sb)))

		return 1;
@@ -3512,17 +3509,20 @@ struct buffer_head *btrfs_read_dev_super(struct block_device *bdev) 
static int write_dev_supers(struct btrfs_device *device,

			    struct btrfs_super_block *sb, int max_mirrors)

{

	struct btrfs_fs_info *fs_info = device->fs_info;

	SHASH_DESC_ON_STACK(shash, fs_info->csum_shash);

	struct buffer_head *bh;

	int i;

	int ret;

	int errors = 0;

	u32 crc;

	u64 bytenr;

	int op_flags;



	if (max_mirrors == 0)

		max_mirrors = BTRFS_SUPER_MIRROR_MAX;



	shash->tfm = fs_info->csum_shash;



	for (i = 0; i < max_mirrors; i++) {

		bytenr = btrfs_sb_offset(i);

		if (bytenr + BTRFS_SUPER_INFO_SIZE >=
@@ -3531,10 +3531,10 @@ static int write_dev_supers(struct btrfs_device *device, 


		btrfs_set_super_bytenr(sb, bytenr);



		crc = ~(u32)0;

		crc = btrfs_csum_data((const char *)sb + BTRFS_CSUM_SIZE, crc,

		crypto_shash_init(shash);

		crypto_shash_update(shash, (const char *)sb + BTRFS_CSUM_SIZE,

				    BTRFS_SUPER_INFO_SIZE - BTRFS_CSUM_SIZE);

		btrfs_csum_final(crc, sb->csum);

		crypto_shash_final(shash, sb->csum);



		/* One reference for us, and we leave it for the caller */

		bh = __getblk(device->bdev, bytenr / BTRFS_BDEV_BLOCKSIZE,

fs/btrfs/disk-io.h

+0 −2
Original line number Diff line number Diff line
@@ -115,8 +115,6 @@ int btrfs_buffer_uptodate(struct extent_buffer *buf, u64 parent_transid, 
			  int atomic);

int btrfs_read_buffer(struct extent_buffer *buf, u64 parent_transid, int level,

		      struct btrfs_key *first_key);

u32 btrfs_csum_data(const char *data, u32 seed, size_t len);

void btrfs_csum_final(u32 crc, u8 *result);

blk_status_t btrfs_bio_wq_end_io(struct btrfs_fs_info *info, struct bio *bio,

			enum btrfs_wq_endio_type metadata);

blk_status_t btrfs_wq_submit_bio(struct btrfs_fs_info *fs_info, struct bio *bio,

CRA Git | Maintained and supported by SUSTech CRA and CCSE