Commit fd546922 authored by Gao Xiang's avatar Gao Xiang Committed by Baokun Li
Browse files

erofs: simplify compression configuration parser 

stable inclusion
from stable-v6.6.14
commit 586814ed68f7cb478dc8e782364f2b2bdea0f76c
category: other
bugzilla: https://gitee.com/src-openeuler/kernel/issues/I932VX
CVE: CVE-2024-26590

Reference: https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git/commit/?id=586814ed68f7cb478dc8e782364f2b2bdea0f76c



--------------------------------

[ Upstream commit efb4fb02cef3ab410b603c8f0e1c67f61d55f542 ]

Move erofs_load_compr_cfgs() into decompressor.c as well as introduce
a callback instead of a hard-coded switch for each algorithm for
simplicity.

Reviewed-by: default avatarChao Yu <chao@kernel.org>
Signed-off-by: default avatarGao Xiang <hsiangkao@linux.alibaba.com>
Link: https://lore.kernel.org/r/20231022130957.11398-1-xiang@kernel.org


Stable-dep-of: 118a8cf504d7 ("erofs: fix inconsistent per-file compression format")
Signed-off-by: default avatarSasha Levin <sashal@kernel.org>
Signed-off-by: default avatarBaokun Li <libaokun1@huawei.com>
parent d84a2a68

fs/erofs/compress.h

+6 −0
Original line number Diff line number Diff line
@@ -21,6 +21,8 @@ struct z_erofs_decompress_req { 
};



struct z_erofs_decompressor {

	int (*config)(struct super_block *sb, struct erofs_super_block *dsb,

		      void *data, int size);

	int (*decompress)(struct z_erofs_decompress_req *rq,

			  struct page **pagepool);

	char *name;
@@ -92,6 +94,10 @@ int z_erofs_fixup_insize(struct z_erofs_decompress_req *rq, const char *padbuf, 
extern const struct z_erofs_decompressor erofs_decompressors[];



/* prototypes for specific algorithms */

int z_erofs_load_lzma_config(struct super_block *sb,

			struct erofs_super_block *dsb, void *data, int size);

int z_erofs_load_deflate_config(struct super_block *sb,

			struct erofs_super_block *dsb, void *data, int size);

int z_erofs_lzma_decompress(struct z_erofs_decompress_req *rq,

			    struct page **pagepool);

int z_erofs_deflate_decompress(struct z_erofs_decompress_req *rq,

fs/erofs/decompressor.c

+59 −3
Original line number Diff line number Diff line
@@ -24,11 +24,11 @@ struct z_erofs_lz4_decompress_ctx { 
	unsigned int oend;

};



int z_erofs_load_lz4_config(struct super_block *sb,

			    struct erofs_super_block *dsb,

			    struct z_erofs_lz4_cfgs *lz4, int size)

static int z_erofs_load_lz4_config(struct super_block *sb,

			    struct erofs_super_block *dsb, void *data, int size)

{

	struct erofs_sb_info *sbi = EROFS_SB(sb);

	struct z_erofs_lz4_cfgs *lz4 = data;

	u16 distance;



	if (lz4) {
@@ -370,19 +370,75 @@ const struct z_erofs_decompressor erofs_decompressors[] = { 
		.name = "interlaced"

	},

	[Z_EROFS_COMPRESSION_LZ4] = {

		.config = z_erofs_load_lz4_config,

		.decompress = z_erofs_lz4_decompress,

		.name = "lz4"

	},

#ifdef CONFIG_EROFS_FS_ZIP_LZMA

	[Z_EROFS_COMPRESSION_LZMA] = {

		.config = z_erofs_load_lzma_config,

		.decompress = z_erofs_lzma_decompress,

		.name = "lzma"

	},

#endif

#ifdef CONFIG_EROFS_FS_ZIP_DEFLATE

	[Z_EROFS_COMPRESSION_DEFLATE] = {

		.config = z_erofs_load_deflate_config,

		.decompress = z_erofs_deflate_decompress,

		.name = "deflate"

	},

#endif

};



int z_erofs_parse_cfgs(struct super_block *sb, struct erofs_super_block *dsb)

{

	struct erofs_sb_info *sbi = EROFS_SB(sb);

	struct erofs_buf buf = __EROFS_BUF_INITIALIZER;

	unsigned int algs, alg;

	erofs_off_t offset;

	int size, ret = 0;



	if (!erofs_sb_has_compr_cfgs(sbi)) {

		sbi->available_compr_algs = Z_EROFS_COMPRESSION_LZ4;

		return z_erofs_load_lz4_config(sb, dsb, NULL, 0);

	}



	sbi->available_compr_algs = le16_to_cpu(dsb->u1.available_compr_algs);

	if (sbi->available_compr_algs & ~Z_EROFS_ALL_COMPR_ALGS) {

		erofs_err(sb, "unidentified algorithms %x, please upgrade kernel",

			  sbi->available_compr_algs & ~Z_EROFS_ALL_COMPR_ALGS);

		return -EOPNOTSUPP;

	}



	erofs_init_metabuf(&buf, sb);

	offset = EROFS_SUPER_OFFSET + sbi->sb_size;

	alg = 0;

	for (algs = sbi->available_compr_algs; algs; algs >>= 1, ++alg) {

		void *data;



		if (!(algs & 1))

			continue;



		data = erofs_read_metadata(sb, &buf, &offset, &size);

		if (IS_ERR(data)) {

			ret = PTR_ERR(data);

			break;

		}



		if (alg >= ARRAY_SIZE(erofs_decompressors) ||

		    !erofs_decompressors[alg].config) {

			erofs_err(sb, "algorithm %d isn't enabled on this kernel",

				  alg);

			ret = -EOPNOTSUPP;

		} else {

			ret = erofs_decompressors[alg].config(sb,

					dsb, data, size);

		}



		kfree(data);

		if (ret)

			break;

	}

	erofs_put_metabuf(&buf);

	return ret;

}

fs/erofs/decompressor_deflate.c

+3 −2
Original line number Diff line number Diff line
@@ -77,9 +77,10 @@ int __init z_erofs_deflate_init(void) 
}



int z_erofs_load_deflate_config(struct super_block *sb,

				struct erofs_super_block *dsb,

				struct z_erofs_deflate_cfgs *dfl, int size)

			struct erofs_super_block *dsb, void *data, int size)

{

	struct z_erofs_deflate_cfgs *dfl = data;



	if (!dfl || size < sizeof(struct z_erofs_deflate_cfgs)) {

		erofs_err(sb, "invalid deflate cfgs, size=%u", size);

		return -EINVAL;

fs/erofs/decompressor_lzma.c

+2 −2
Original line number Diff line number Diff line
@@ -72,10 +72,10 @@ int __init z_erofs_lzma_init(void) 
}



int z_erofs_load_lzma_config(struct super_block *sb,

			     struct erofs_super_block *dsb,

			     struct z_erofs_lzma_cfgs *lzma, int size)

			struct erofs_super_block *dsb, void *data, int size)

{

	static DEFINE_MUTEX(lzma_resize_mutex);

	struct z_erofs_lzma_cfgs *lzma = data;

	unsigned int dict_size, i;

	struct z_erofs_lzma *strm, *head = NULL;

	int err;

fs/erofs/internal.h

+1 −37
Original line number Diff line number Diff line
@@ -469,9 +469,6 @@ int __init z_erofs_init_zip_subsystem(void); 
void z_erofs_exit_zip_subsystem(void);

int erofs_try_to_free_all_cached_pages(struct erofs_sb_info *sbi,

				       struct erofs_workgroup *egrp);

int z_erofs_load_lz4_config(struct super_block *sb,

			    struct erofs_super_block *dsb,

			    struct z_erofs_lz4_cfgs *lz4, int len);

int z_erofs_map_blocks_iter(struct inode *inode, struct erofs_map_blocks *map,

			    int flags);

void *erofs_get_pcpubuf(unsigned int requiredpages);
@@ -480,6 +477,7 @@ int erofs_pcpubuf_growsize(unsigned int nrpages); 
void __init erofs_pcpubuf_init(void);

void erofs_pcpubuf_exit(void);

int erofs_init_managed_cache(struct super_block *sb);

int z_erofs_parse_cfgs(struct super_block *sb, struct erofs_super_block *dsb);

#else

static inline void erofs_shrinker_register(struct super_block *sb) {}

static inline void erofs_shrinker_unregister(struct super_block *sb) {}
@@ -487,16 +485,6 @@ static inline int erofs_init_shrinker(void) { return 0; } 
static inline void erofs_exit_shrinker(void) {}

static inline int z_erofs_init_zip_subsystem(void) { return 0; }

static inline void z_erofs_exit_zip_subsystem(void) {}

static inline int z_erofs_load_lz4_config(struct super_block *sb,

				  struct erofs_super_block *dsb,

				  struct z_erofs_lz4_cfgs *lz4, int len)

{

	if (lz4 || dsb->u1.lz4_max_distance) {

		erofs_err(sb, "lz4 algorithm isn't enabled");

		return -EINVAL;

	}

	return 0;

}

static inline void erofs_pcpubuf_init(void) {}

static inline void erofs_pcpubuf_exit(void) {}

static inline int erofs_init_managed_cache(struct super_block *sb) { return 0; }
@@ -505,41 +493,17 @@ static inline int erofs_init_managed_cache(struct super_block *sb) { return 0; } 
#ifdef CONFIG_EROFS_FS_ZIP_LZMA

int __init z_erofs_lzma_init(void);

void z_erofs_lzma_exit(void);

int z_erofs_load_lzma_config(struct super_block *sb,

			     struct erofs_super_block *dsb,

			     struct z_erofs_lzma_cfgs *lzma, int size);

#else

static inline int z_erofs_lzma_init(void) { return 0; }

static inline int z_erofs_lzma_exit(void) { return 0; }

static inline int z_erofs_load_lzma_config(struct super_block *sb,

			     struct erofs_super_block *dsb,

			     struct z_erofs_lzma_cfgs *lzma, int size) {

	if (lzma) {

		erofs_err(sb, "lzma algorithm isn't enabled");

		return -EINVAL;

	}

	return 0;

}

#endif	/* !CONFIG_EROFS_FS_ZIP_LZMA */



#ifdef CONFIG_EROFS_FS_ZIP_DEFLATE

int __init z_erofs_deflate_init(void);

void z_erofs_deflate_exit(void);

int z_erofs_load_deflate_config(struct super_block *sb,

				struct erofs_super_block *dsb,

				struct z_erofs_deflate_cfgs *dfl, int size);

#else

static inline int z_erofs_deflate_init(void) { return 0; }

static inline int z_erofs_deflate_exit(void) { return 0; }

static inline int z_erofs_load_deflate_config(struct super_block *sb,

			struct erofs_super_block *dsb,

			struct z_erofs_deflate_cfgs *dfl, int size) {

	if (dfl) {

		erofs_err(sb, "deflate algorithm isn't enabled");

		return -EINVAL;

	}

	return 0;

}

#endif	/* !CONFIG_EROFS_FS_ZIP_DEFLATE */



#ifdef CONFIG_EROFS_FS_ONDEMAND