Commit d005af3b authored by Eric Biggers's avatar Eric Biggers Committed by Jaegeuk Kim
Browse files

f2fs: remove unused sbi argument from checksum functions 



Since __f2fs_crc32() now calls crc32() directly, it no longer uses its
sbi argument.  Remove that, and simplify its callers accordingly.

Signed-off-by: default avatarEric Biggers <ebiggers@google.com>
Reviewed-by: default avatarChao Yu <chao@kernel.org>
Signed-off-by: default avatarJaegeuk Kim <jaegeuk@kernel.org>
parent 13be8795

fs/f2fs/checkpoint.c

+6 −7
Original line number Diff line number Diff line
@@ -826,16 +826,15 @@ static void write_orphan_inodes(struct f2fs_sb_info *sbi, block_t start_blk) 
	}

}



static __u32 f2fs_checkpoint_chksum(struct f2fs_sb_info *sbi,

						struct f2fs_checkpoint *ckpt)

static __u32 f2fs_checkpoint_chksum(struct f2fs_checkpoint *ckpt)

{

	unsigned int chksum_ofs = le32_to_cpu(ckpt->checksum_offset);

	__u32 chksum;



	chksum = f2fs_crc32(sbi, ckpt, chksum_ofs);

	chksum = f2fs_crc32(ckpt, chksum_ofs);

	if (chksum_ofs < CP_CHKSUM_OFFSET) {

		chksum_ofs += sizeof(chksum);

		chksum = f2fs_chksum(sbi, chksum, (__u8 *)ckpt + chksum_ofs,

		chksum = f2fs_chksum(chksum, (__u8 *)ckpt + chksum_ofs,

				     F2FS_BLKSIZE - chksum_ofs);

	}

	return chksum;
@@ -862,7 +861,7 @@ static int get_checkpoint_version(struct f2fs_sb_info *sbi, block_t cp_addr, 
		return -EINVAL;

	}



	crc = f2fs_checkpoint_chksum(sbi, *cp_block);

	crc = f2fs_checkpoint_chksum(*cp_block);

	if (crc != cur_cp_crc(*cp_block)) {

		f2fs_folio_put(*cp_folio, true);

		f2fs_warn(sbi, "invalid crc value");
@@ -1505,7 +1504,7 @@ static int do_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc) 
	get_sit_bitmap(sbi, __bitmap_ptr(sbi, SIT_BITMAP));

	get_nat_bitmap(sbi, __bitmap_ptr(sbi, NAT_BITMAP));



	crc32 = f2fs_checkpoint_chksum(sbi, ckpt);

	crc32 = f2fs_checkpoint_chksum(ckpt);

	*((__le32 *)((unsigned char *)ckpt +

				le32_to_cpu(ckpt->checksum_offset)))

				= cpu_to_le32(crc32);

fs/f2fs/compress.c

+2 −3
Original line number Diff line number Diff line
@@ -679,8 +679,7 @@ static int f2fs_compress_pages(struct compress_ctx *cc) 
	cc->cbuf->clen = cpu_to_le32(cc->clen);



	if (fi->i_compress_flag & BIT(COMPRESS_CHKSUM))

		chksum = f2fs_crc32(F2FS_I_SB(cc->inode),

					cc->cbuf->cdata, cc->clen);

		chksum = f2fs_crc32(cc->cbuf->cdata, cc->clen);

	cc->cbuf->chksum = cpu_to_le32(chksum);



	for (i = 0; i < COMPRESS_DATA_RESERVED_SIZE; i++)
@@ -776,7 +775,7 @@ void f2fs_decompress_cluster(struct decompress_io_ctx *dic, bool in_task) 


	if (!ret && (fi->i_compress_flag & BIT(COMPRESS_CHKSUM))) {

		u32 provided = le32_to_cpu(dic->cbuf->chksum);

		u32 calculated = f2fs_crc32(sbi, dic->cbuf->cdata, dic->clen);

		u32 calculated = f2fs_crc32(dic->cbuf->cdata, dic->clen);



		if (provided != calculated) {

			if (!is_inode_flag_set(dic->inode, FI_COMPRESS_CORRUPT)) {

fs/f2fs/f2fs.h

+6 −14
Original line number Diff line number Diff line
@@ -1976,28 +1976,20 @@ static inline unsigned int f2fs_time_to_wait(struct f2fs_sb_info *sbi, 
/*

 * Inline functions

 */

static inline u32 __f2fs_crc32(struct f2fs_sb_info *sbi, u32 crc,

			      const void *address, unsigned int length)

{

	return crc32(crc, address, length);

}



static inline u32 f2fs_crc32(struct f2fs_sb_info *sbi, const void *address,

static inline u32 __f2fs_crc32(u32 crc, const void *address,

			       unsigned int length)

{

	return __f2fs_crc32(sbi, F2FS_SUPER_MAGIC, address, length);

	return crc32(crc, address, length);

}



static inline bool f2fs_crc_valid(struct f2fs_sb_info *sbi, __u32 blk_crc,

				  void *buf, size_t buf_size)

static inline u32 f2fs_crc32(const void *address, unsigned int length)

{

	return f2fs_crc32(sbi, buf, buf_size) == blk_crc;

	return __f2fs_crc32(F2FS_SUPER_MAGIC, address, length);

}



static inline u32 f2fs_chksum(struct f2fs_sb_info *sbi, u32 crc,

			      const void *address, unsigned int length)

static inline u32 f2fs_chksum(u32 crc, const void *address, unsigned int length)

{

	return __f2fs_crc32(sbi, crc, address, length);

	return __f2fs_crc32(crc, address, length);

}



static inline struct f2fs_inode_info *F2FS_I(struct inode *inode)

fs/f2fs/inode.c

+6 −7
Original line number Diff line number Diff line
@@ -144,14 +144,13 @@ static __u32 f2fs_inode_chksum(struct f2fs_sb_info *sbi, struct page *page) 
	unsigned int offset = offsetof(struct f2fs_inode, i_inode_checksum);

	unsigned int cs_size = sizeof(dummy_cs);



	chksum = f2fs_chksum(sbi, sbi->s_chksum_seed, (__u8 *)&ino,

							sizeof(ino));

	chksum_seed = f2fs_chksum(sbi, chksum, (__u8 *)&gen, sizeof(gen));

	chksum = f2fs_chksum(sbi->s_chksum_seed, (__u8 *)&ino, sizeof(ino));

	chksum_seed = f2fs_chksum(chksum, (__u8 *)&gen, sizeof(gen));



	chksum = f2fs_chksum(sbi, chksum_seed, (__u8 *)ri, offset);

	chksum = f2fs_chksum(sbi, chksum, (__u8 *)&dummy_cs, cs_size);

	chksum = f2fs_chksum(chksum_seed, (__u8 *)ri, offset);

	chksum = f2fs_chksum(chksum, (__u8 *)&dummy_cs, cs_size);

	offset += cs_size;

	chksum = f2fs_chksum(sbi, chksum, (__u8 *)ri + offset,

	chksum = f2fs_chksum(chksum, (__u8 *)ri + offset,

			     F2FS_BLKSIZE - offset);

	return chksum;

}

fs/f2fs/super.c

+4 −4
Original line number Diff line number Diff line
@@ -3564,7 +3564,7 @@ static int sanity_check_raw_super(struct f2fs_sb_info *sbi, 
			return -EFSCORRUPTED;

		}

		crc = le32_to_cpu(raw_super->crc);

		if (!f2fs_crc_valid(sbi, crc, raw_super, crc_offset)) {

		if (crc != f2fs_crc32(raw_super, crc_offset)) {

			f2fs_info(sbi, "Invalid SB checksum value: %u", crc);

			return -EFSCORRUPTED;

		}
@@ -4120,7 +4120,7 @@ int f2fs_commit_super(struct f2fs_sb_info *sbi, bool recover) 


	/* we should update superblock crc here */

	if (!recover && f2fs_sb_has_sb_chksum(sbi)) {

		crc = f2fs_crc32(sbi, F2FS_RAW_SUPER(sbi),

		crc = f2fs_crc32(F2FS_RAW_SUPER(sbi),

				offsetof(struct f2fs_super_block, crc));

		F2FS_RAW_SUPER(sbi)->crc = cpu_to_le32(crc);

	}
@@ -4581,7 +4581,7 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent) 


	/* precompute checksum seed for metadata */

	if (f2fs_sb_has_inode_chksum(sbi))

		sbi->s_chksum_seed = f2fs_chksum(sbi, ~0, raw_super->uuid,

		sbi->s_chksum_seed = f2fs_chksum(~0, raw_super->uuid,

						 sizeof(raw_super->uuid));



	default_options(sbi, false);