btrfs: switch to library APIs for checksums
Subsystems (2)
PATCH v2 1/1 btrfs: switch to library APIs for checksums
Make btrfs use the library APIs instead of crypto_shash, for all checksum computations. This has many benefits:
- Allows future checksum types, e.g. XXH3 or CRC64, to be more easily supported. Only a library API will be needed, not crypto_shash too.
- Eliminates the overhead of the generic crypto layer, including an indirect call for every function call and other API overhead. A microbenchmark of btrfs_check_read_bio() with crc32c checksums shows a speedup from 658 cycles to 608 cycles per 4096-byte block.
- Decreases the stack usage of btrfs by reducing the size of checksum contexts from 384 bytes to 240 bytes, and by eliminating the need for some functions to declare a checksum context at all.
- Increases reliability. The library functions always succeed and return void. In contrast, crypto_shash can fail and return errors. Also, the library functions are guaranteed to be available when btrfs is loaded; there's no longer any need to use module softdeps to try to work around the crypto modules sometimes not being loaded.
- Fixes a bug where blake2b checksums didn't work on kernels booted with fips=1. Since btrfs checksums are for integrity only, it's fine for them to use non-FIPS-approved algorithms.
Note that with having to handle 4 algorithms instead of just 1-2, this commit does result in a slightly positive diffstat. That being said, this wouldn't have been the case if btrfs had actually checked for errors from crypto_shash, which technically it should have been doing.
---
v2: rebased onto latest mainline, now that both the crypto library and
btrfs pull requests for 6.19 have been merged
fs/btrfs/Kconfig | 8 ++-- fs/btrfs/compression.c | 1 - fs/btrfs/disk-io.c | 68 ++++++++---------------------- fs/btrfs/file-item.c | 4 -- fs/btrfs/fs.c | 96 ++++++++++++++++++++++++++++++++++++------ fs/btrfs/fs.h | 23 +++++++--- fs/btrfs/inode.c | 10 ++--- fs/btrfs/scrub.c | 16 +++---- fs/btrfs/super.c | 4 -- fs/btrfs/sysfs.c | 6 +-- 10 files changed, 133 insertions(+), 103 deletions(-)
fs/btrfs/Kconfig +3 -5
@@ -2,24 +2,22 @@ config BTRFS_FS tristate "Btrfs filesystem support" select BLK_CGROUP_PUNT_BIO select CRC32 - select CRYPTO - select CRYPTO_CRC32C - select CRYPTO_XXHASH - select CRYPTO_SHA256 - select CRYPTO_BLAKE2B + select CRYPTO_LIB_BLAKE2B + select CRYPTO_LIB_SHA256 select ZLIB_INFLATE select ZLIB_DEFLATE select LZO_COMPRESS select LZO_DECOMPRESS select ZSTD_COMPRESS select ZSTD_DECOMPRESS select FS_IOMAP select RAID6_PQ select XOR_BLOCKS + select XXHASH depends on PAGE_SIZE_LESS_THAN_256KB help Btrfs is a general purpose copy-on-write filesystem with extents, writable snapshotting, support for multiple devices and many more
fs/btrfs/compression.c +0 -1
@@ -19,11 +19,10 @@#include <linux/psi.h> #include <linux/slab.h> #include <linux/sched/mm.h> #include <linux/log2.h> #include <linux/shrinker.h> -#include <crypto/hash.h> #include "misc.h" #include "ctree.h" #include "fs.h" #include "btrfs_inode.h" #include "bio.h"
fs/btrfs/disk-io.c +17 -51
206 lines not on this page · raw message
fs/btrfs/file-item.c +0 -4
@@ -6,11 +6,10 @@#include <linux/bio.h> #include <linux/slab.h> #include <linux/pagemap.h> #include <linux/highmem.h> #include <linux/sched/mm.h> -#include <crypto/hash.h> #include "messages.h" #include "ctree.h" #include "disk-io.h" #include "transaction.h" #include "bio.h"
@@ -767,11 +766,10 @@ int btrfs_lookup_csums_bitmap(struct btrfs_root *root, struct btrfs_path *path,static void csum_one_bio (struct btrfs_bio *bbio,struct bvec_iter *src) {struct btrfs_inode *inode = bbio->inode;struct btrfs_fs_info *fs_info = inode->root->fs_info; -SHASH_DESC_ON_STACK (shash, fs_info->csum_shash);struct bio *bio = &bbio->bio;struct btrfs_ordered_sum *sums = bbio->sums;struct bvec_iter iter = *src;phys_addr_t paddr;const u32 blocksize = fs_info->sectorsize;
@@ -779,12 +777,10 @@ static void csum_one_bio(struct btrfs_bio *bbio, struct bvec_iter *src)const u32 nr_steps = blocksize / step;phys_addr_t paddrs[BTRFS_MAX_BLOCKSIZE /PAGE_SIZE ];u32 offset =0 ;int index =0 ; - shash->tfm = fs_info->csum_shash; -btrfs_bio_for_each_block (paddr, bio, &iter, step) { paddrs[(offset / step) % nr_steps] = paddr; offset += step;if (IS_ALIGNED (offset, blocksize)) {
fs/btrfs/fs.c +82 -14
129 lines not on this page · raw message
fs/btrfs/fs.h +18 -5
@@ -1,10 +1,12 @@/* SPDX-License-Identifier: GPL-2.0 */ #ifndef BTRFS_FS_H #define BTRFS_FS_H +#include <crypto/blake2b.h> +#include <crypto/sha2.h> #include <linux/blkdev.h> #include <linux/sizes.h> #include <linux/time64.h> #include <linux/compiler.h> #include <linux/math.h>
@@ -22,10 +24,11 @@#include <linux/workqueue.h> #include <linux/wait.h> #include <linux/wait_bit.h> #include <linux/sched.h> #include <linux/rbtree.h> +#include <linux/xxhash.h> #include <uapi/linux/btrfs.h> #include <uapi/linux/btrfs_tree.h> #include "extent-io-tree.h" #include "async-thread.h" #include "block-rsv.h"
@@ -33,11 +36,10 @@struct inode ;struct super_block ;struct kobject ;struct reloc_control ; -struct crypto_shash ;struct ulist ;struct btrfs_device ;struct btrfs_block_group ;struct btrfs_root ;struct btrfs_fs_devices ;
@@ -840,13 +842,14 @@ struct btrfs_fs_info {u32 sectorsize;/* ilog2 of sectorsize, use to avoid 64bit division */ u32 sectorsize_bits;u32 block_min_order;u32 block_max_order; +u32 stripesize;u32 csum_size;u32 csums_per_leaf; -u32 stripesize; +u16 csum_type;/* * Maximum size of an extent. BTRFS_MAX_EXTENT_SIZE on regular * filesystem, on zoned it depends on the device constraints. */
@@ -854,12 +857,10 @@ struct btrfs_fs_info {/* Block groups and devices containing active swapfiles. */ spinlock_t swapfile_pins_lock;struct rb_root swapfile_pins; -struct crypto_shash *csum_shash; -/* Type of exclusive operation running, protected by super_lock */ enum btrfs_exclusive_operation exclusive_operation;/* * Zone size > 0 when in ZONED mode, otherwise it's used for a check
@@ -1047,12 +1048,24 @@ void btrfs_exclop_balance(struct btrfs_fs_info *fs_info,int btrfs_check_ioctl_vol_args_path (const struct btrfs_ioctl_vol_args *vol_args);u16 btrfs_csum_type_size (u16 type);int btrfs_super_csum_size (const struct btrfs_super_block *s);const char *btrfs_super_csum_name (u16 csum_type); -const char *btrfs_super_csum_driver (u16 csum_type); size_t __attribute_const__ btrfs_get_num_csums(void); +struct btrfs_csum_ctx { +u16 csum_type; +union { +u32 crc32; +struct xxh64_state xxh64; +struct sha256_ctx sha256; +struct blake2b_ctx blake2b; + }; +}; +void btrfs_csum (u16 csum_type,const u8 *data,size_t len,u8 *out); +void btrfs_csum_init (struct btrfs_csum_ctx *ctx,u16 csum_type); +void btrfs_csum_update (struct btrfs_csum_ctx *ctx,const u8 *data,size_t len); +void btrfs_csum_final (struct btrfs_csum_ctx *ctx,u8 *out);static inline bool btrfs_is_empty_uuid (const u8 *uuid) {return uuid_is_null ((const uuid_t *)uuid); }
fs/btrfs/inode.c +4 -6
@@ -1,11 +1,10 @@// SPDX-License-Identifier: GPL-2.0 /* * Copyright (C) 2007 Oracle. All rights reserved. */ -#include <crypto/hash.h> #include <linux/kernel.h> #include <linux/bio.h> #include <linux/blk-cgroup.h> #include <linux/file.h> #include <linux/fs.h>
@@ -3392,24 +3391,23 @@ void btrfs_calculate_block_csum_pages(struct btrfs_fs_info *fs_info, const phys_addr_t paddrs[], u8 *dest) { const u32 blocksize = fs_info->sectorsize;const u32 step =min (blocksize,PAGE_SIZE );const u32 nr_steps = blocksize / step; -SHASH_DESC_ON_STACK (shash, fs_info->csum_shash); +struct btrfs_csum_ctx csum; - shash->tfm = fs_info->csum_shash; -crypto_shash_init (shash); +btrfs_csum_init (&csum, fs_info->csum_type);for (int i =0 ; i < nr_steps; i++) {const phys_addr_t paddr = paddrs[i];void *kaddr;ASSERT (offset_in_page (paddr) + step <=PAGE_SIZE ); kaddr =kmap_local_page (phys_to_page (paddr)) +offset_in_page (paddr); -crypto_shash_update (shash, kaddr, step); +btrfs_csum_update (&csum, kaddr, step);kunmap_local (kaddr); } -crypto_shash_final (shash, dest); +btrfs_csum_final (&csum, dest); }/* * Verify the checksum for a single sector without any extra action that depend * on the type of I/O.
fs/btrfs/scrub.c +7 -9
@@ -4,11 +4,10 @@*/ #include <linux/blkdev.h> #include <linux/ratelimit.h> #include <linux/sched/mm.h> -#include <crypto/hash.h> #include "ctree.h" #include "discard.h" #include "volumes.h" #include "disk-io.h" #include "ordered-data.h"
@@ -716,11 +715,11 @@ static void scrub_verify_one_metadata(struct scrub_stripe *stripe, int sector_nrstruct btrfs_fs_info *fs_info = stripe->bg->fs_info;const u32 sectors_per_tree = fs_info->nodesize >> fs_info->sectorsize_bits;const u64 logical = stripe->logical + (sector_nr << fs_info->sectorsize_bits);void *first_kaddr =scrub_stripe_get_kaddr (stripe, sector_nr);struct btrfs_header *header = first_kaddr; -SHASH_DESC_ON_STACK (shash, fs_info->csum_shash); +struct btrfs_csum_ctx csum;u8 on_disk_csum[BTRFS_CSUM_SIZE ];u8 calculated_csum[BTRFS_CSUM_SIZE ];/* * Here we don't have a good way to attach the pages (and subpages)
@@ -758,21 +757,20 @@ static void scrub_verify_one_metadata(struct scrub_stripe *stripe, int sector_nr header->chunk_tree_uuid, fs_info->chunk_tree_uuid);return ; }/* Now check tree block csum. */ - shash->tfm = fs_info->csum_shash; -crypto_shash_init (shash); -crypto_shash_update (shash, first_kaddr +BTRFS_CSUM_SIZE , - fs_info->sectorsize -BTRFS_CSUM_SIZE ); +btrfs_csum_init (&csum, fs_info->csum_type); +btrfs_csum_update (&csum, first_kaddr +BTRFS_CSUM_SIZE , + fs_info->sectorsize -BTRFS_CSUM_SIZE );for (int i = sector_nr +1 ; i < sector_nr + sectors_per_tree; i++) { -crypto_shash_update (shash,scrub_stripe_get_kaddr (stripe, i), - fs_info->sectorsize); +btrfs_csum_update (&csum,scrub_stripe_get_kaddr (stripe, i), + fs_info->sectorsize); } -crypto_shash_final (shash, calculated_csum); +btrfs_csum_final (&csum, calculated_csum);if (memcmp (calculated_csum, on_disk_csum, fs_info->csum_size) !=0 ) {scrub_bitmap_set_meta_error (stripe, sector_nr, sectors_per_tree);scrub_bitmap_set_error (stripe, sector_nr, sectors_per_tree); btrfs_warn_rl(fs_info, "scrub: tree block %llu mirror %u has bad csum, has " BTRFS_CSUM_FMT " want " BTRFS_CSUM_FMT,
fs/btrfs/super.c +0 -4
@@ -2700,9 +2700,5 @@ static int __init init_btrfs_fs(void)late_initcall (init_btrfs_fs); module_exit(exit_btrfs_fs) MODULE_DESCRIPTION("B-Tree File System (BTRFS)");MODULE_LICENSE ("GPL" ); -MODULE_SOFTDEP ("pre: crc32c" ); -MODULE_SOFTDEP ("pre: xxhash64" ); -MODULE_SOFTDEP ("pre: sha256" ); -MODULE_SOFTDEP ("pre: blake2b-256" );
fs/btrfs/sysfs.c +2 -4
@@ -9,11 +9,10 @@#include <linux/spinlock.h> #include <linux/completion.h> #include <linux/bug.h> #include <linux/list.h> #include <linux/string_choices.h> -#include <crypto/hash.h> #include "messages.h" #include "ctree.h" #include "discard.h" #include "disk-io.h" #include "send.h"
@@ -1302,14 +1301,13 @@ BTRFS_ATTR(, metadata_uuid, btrfs_metadata_uuid_show);static ssize_t btrfs_checksum_show (struct kobject *kobj,struct kobj_attribute *a,char *buf) {struct btrfs_fs_info *fs_info =to_fs_info (kobj);u16 csum_type =btrfs_super_csum_type (fs_info->super_copy); +const char *csum_name =btrfs_super_csum_name (csum_type); -return sysfs_emit (buf,"%s (%s)\n" , -btrfs_super_csum_name (csum_type), -crypto_shash_driver_name (fs_info->csum_shash)); +return sysfs_emit (buf,"%s (%s-lib)\n" , csum_name, csum_name); } BTRFS_ATTR(, checksum, btrfs_checksum_show); static ssize_t btrfs_exclusive_operation_show(struct kobject *kobj,
base-commit: 43dfc13ca972988e620a6edb72956981b75ab6b0
Signature · 1 line
2.52.0
Quoted 38 lines · Eric Biggers
Make btrfs use the library APIs instead of
crypto_shash, for all checksum computations. This has many benefits:- Allows future checksum types, e.g. XXH3 or CRC64, to be more easily supported. Only a library API will be needed, not
crypto_shashtoo.- Eliminates the overhead of the generic crypto layer, including an indirect call for every function call and other API overhead. A microbenchmark of
btrfs_check_read_bio()with crc32c checksums shows a speedup from 658 cycles to 608 cycles per 4096-byte block.- Decreases the stack usage of btrfs by reducing the size of checksum contexts from 384 bytes to 240 bytes, and by eliminating the need for some functions to declare a checksum context at all.
- Increases reliability. The library functions always succeed and return void. In contrast,
crypto_shashcan fail and return errors. Also, the library functions are guaranteed to be available when btrfs is loaded; there's no longer any need to use module softdeps to try to work around the crypto modules sometimes not being loaded.- Fixes a bug where blake2b checksums didn't work on kernels booted with fips=1. Since btrfs checksums are for integrity only, it's fine for them to use non-FIPS-approved algorithms.
Note that with having to handle 4 algorithms instead of just 1-2, this commit does result in a slightly positive diffstat. That being said, this wouldn't have been the case if btrfs had actually checked for errors from
crypto_shash, which technically it should have been doing.Reviewed-by Ard Biesheuvel <[email protected]>Signed-off-by Eric Biggers <[email protected]>---
v2: rebased onto latest mainline, now that both the crypto library and
btrfs pull requests for 6.19 have been merged
Quoted 12 lines
fs/btrfs/Kconfig | 8 ++-- fs/btrfs/compression.c | 1 - fs/btrfs/disk-io.c | 68 ++++++++---------------------- fs/btrfs/file-item.c | 4 -- fs/btrfs/fs.c | 96 ++++++++++++++++++++++++++++++++++++------ fs/btrfs/fs.h | 23 +++++++--- fs/btrfs/inode.c | 10 ++--- fs/btrfs/scrub.c | 16 +++---- fs/btrfs/super.c | 4 -- fs/btrfs/sysfs.c | 6 +-- 10 files changed, 133 insertions(+), 103 deletions(-)
This patch looks reasonable to me and seems to work as expected.
Signature · 1 line
真実はいつも一つ!/ Always, there's only one truth!
Quoted 30 lines · Eric Biggers
Make btrfs use the library APIs instead of
crypto_shash, for all checksum computations. This has many benefits:- Allows future checksum types, e.g. XXH3 or CRC64, to be more easily supported. Only a library API will be needed, not
crypto_shashtoo.- Eliminates the overhead of the generic crypto layer, including an indirect call for every function call and other API overhead. A microbenchmark of
btrfs_check_read_bio()with crc32c checksums shows a speedup from 658 cycles to 608 cycles per 4096-byte block.- Decreases the stack usage of btrfs by reducing the size of checksum contexts from 384 bytes to 240 bytes, and by eliminating the need for some functions to declare a checksum context at all.
- Increases reliability. The library functions always succeed and return void. In contrast,
crypto_shashcan fail and return errors. Also, the library functions are guaranteed to be available when btrfs is loaded; there's no longer any need to use module softdeps to try to work around the crypto modules sometimes not being loaded.- Fixes a bug where blake2b checksums didn't work on kernels booted with fips=1. Since btrfs checksums are for integrity only, it's fine for them to use non-FIPS-approved algorithms.
Note that with having to handle 4 algorithms instead of just 1-2, this commit does result in a slightly positive diffstat. That being said, this wouldn't have been the case if btrfs had actually checked for errors from
crypto_shash, which technically it should have been doing.
Quoted 6 lines
Reviewed-by Ard Biesheuvel <[email protected]>Signed-off-by Eric Biggers <[email protected]>---
v2: rebased onto latest mainline, now that both the crypto library and
btrfs pull requests for 6.19 have been merged
Added to for-next as we're now based on recent master, thanks.