[PATCH 3/4] erofs-utils: lib: migrate pclustersize configurations

Gao Xiang hsiangkao at linux.alibaba.com
Tue Sep 23 16:28:47 AEST 2025


Also convert their units from bytes to blocks.

Signed-off-by: Gao Xiang <hsiangkao at linux.alibaba.com>
---
 include/erofs/compress_hints.h |   8 +-
 include/erofs/config.h         |   4 -
 include/erofs/importer.h       |   4 +
 lib/compress.c                 | 129 ++++++++++++++++-----------------
 lib/compress_hints.c           |  39 +++++-----
 lib/compressor.c               |   6 +-
 lib/compressor.h               |   6 +-
 lib/compressor_liblzma.c       |   4 +-
 lib/compressor_libzstd.c       |   4 +-
 lib/config.c                   |   1 -
 lib/importer.c                 |   4 +-
 lib/inode.c                    |  21 +++---
 lib/liberofs_compress.h        |   3 +-
 mkfs/main.c                    |  18 ++---
 14 files changed, 127 insertions(+), 124 deletions(-)

diff --git a/include/erofs/compress_hints.h b/include/erofs/compress_hints.h
index 9f0d8ae..6ccc03d 100644
--- a/include/erofs/compress_hints.h
+++ b/include/erofs/compress_hints.h
@@ -11,9 +11,9 @@ extern "C"
 {
 #endif
 
-#include "erofs/internal.h"
 #include <sys/types.h>
 #include <regex.h>
+#include "erofs/importer.h"
 
 struct erofs_compress_hints {
 	struct list_head list;
@@ -23,9 +23,11 @@ struct erofs_compress_hints {
 	unsigned char algorithmtype;
 };
 
-bool z_erofs_apply_compress_hints(struct erofs_inode *inode);
+bool z_erofs_apply_compress_hints(struct erofs_importer *im,
+				  struct erofs_inode *inode);
 void erofs_cleanup_compress_hints(void);
-int erofs_load_compress_hints(struct erofs_sb_info *sbi);
+int erofs_load_compress_hints(struct erofs_importer *im,
+			      struct erofs_sb_info *sbi);
 
 #ifdef __cplusplus
 }
diff --git a/include/erofs/config.h b/include/erofs/config.h
index 67f5aa3..59cf4f2 100644
--- a/include/erofs/config.h
+++ b/include/erofs/config.h
@@ -70,10 +70,6 @@ struct erofs_configure {
 	u8 c_mkfs_metabox_algid;
 	/* < 0, xattr disabled and INT_MAX, always use inline xattrs */
 	int c_inline_xattr_tolerance;
-	u32 c_mkfs_pclustersize_max;
-	u32 c_mkfs_pclustersize_def;
-	u32 c_mkfs_pclustersize_packed;
-	s32 c_mkfs_pclustersize_metabox;
 	u32 c_max_decompressed_extent_bytes;
 	u64 c_unix_timestamp;
 	const char *mount_point;
diff --git a/include/erofs/importer.h b/include/erofs/importer.h
index a5a4c8c..6033e68 100644
--- a/include/erofs/importer.h
+++ b/include/erofs/importer.h
@@ -25,6 +25,10 @@ struct erofs_importer_params {
 	u32 uid_offset;
 	u32 gid_offset;
 	u32 fsalignblks;
+	u32 pclusterblks_max;
+	u32 pclusterblks_def;
+	u32 pclusterblks_packed;
+	s32 pclusterblks_metabox;
 	char force_inodeversion;
 	bool ignore_mtime;
 	bool no_datainline;
diff --git a/lib/compress.c b/lib/compress.c
index 6820042..988c444 100644
--- a/lib/compress.c
+++ b/lib/compress.c
@@ -35,6 +35,7 @@ struct z_erofs_extent_item {
 };
 
 struct z_erofs_compress_ictx {		/* inode context */
+	struct erofs_importer *im;
 	struct erofs_inode *inode;
 	struct erofs_compress_cfg *ccfg;
 	int fd;
@@ -455,25 +456,26 @@ static int write_uncompressed_extents(struct z_erofs_compress_sctx *ctx,
 	return count;
 }
 
-static unsigned int z_erofs_get_max_pclustersize(struct erofs_inode *inode)
+static unsigned int z_erofs_get_pclustersize(struct z_erofs_compress_ictx *ictx)
 {
-	if (erofs_is_packed_inode(inode)) {
-		return cfg.c_mkfs_pclustersize_packed;
-	} else if (erofs_is_metabox_inode(inode)) {
-		return cfg.c_mkfs_pclustersize_metabox;
-#ifndef NDEBUG
-	} else if (cfg.c_random_pclusterblks) {
-		unsigned int pclusterblks =
-			cfg.c_mkfs_pclustersize_max >> inode->sbi->blkszbits;
+	struct erofs_importer_params *params = ictx->im->params;
+	struct erofs_inode *inode = ictx->inode;
+	unsigned int blkszbits = inode->sbi->blkszbits;
 
-		return (1 + rand() % pclusterblks) << inode->sbi->blkszbits;
+	if (erofs_is_packed_inode(inode))
+		return params->pclusterblks_packed << blkszbits;
+	if (erofs_is_metabox_inode(inode))
+		return params->pclusterblks_metabox << blkszbits;
+#ifndef NDEBUG
+	if (cfg.c_random_pclusterblks)
+		return (1 + rand() % params->pclusterblks_max) << blkszbits;
 #endif
-	} else if (cfg.c_compress_hints_file) {
-		z_erofs_apply_compress_hints(inode);
+	if (cfg.c_compress_hints_file) {
+		z_erofs_apply_compress_hints(ictx->im, inode);
 		DBG_BUGON(!inode->z_physical_clusterblks);
-		return inode->z_physical_clusterblks << inode->sbi->blkszbits;
+		return inode->z_physical_clusterblks << blkszbits;
 	}
-	return cfg.c_mkfs_pclustersize_def;
+	return params->pclusterblks_def << blkszbits;
 }
 
 static int z_erofs_fill_inline_data(struct erofs_inode *inode, void *data,
@@ -539,7 +541,7 @@ static bool z_erofs_fixup_deduped_fragment(struct z_erofs_compress_sctx *ctx)
 	/* try to fix again if it gets larger (should be rare) */
 	if (inode->fragment_size < newsize) {
 		ctx->pclustersize = min_t(erofs_off_t,
-				z_erofs_get_max_pclustersize(inode),
+				z_erofs_get_pclustersize(ictx),
 				roundup(newsize - inode->fragment_size,
 					erofs_blksiz(sbi)));
 		return false;
@@ -1443,27 +1445,6 @@ err_free_priv:
 	return NULL;
 }
 
-int z_erofs_mt_wq_tls_init_compr(struct erofs_sb_info *sbi,
-				 struct erofs_compress_wq_tls *tls,
-				 unsigned int alg_id, char *alg_name,
-				 unsigned int comp_level,
-				 unsigned int dict_size)
-{
-	struct erofs_compress_cfg *lc = &tls->ccfg[alg_id];
-	int ret;
-
-	if (__erofs_likely(lc->enable))
-		return 0;
-
-	ret = erofs_compressor_init(sbi, &lc->handle, alg_name,
-				    comp_level, dict_size);
-	if (ret)
-		return ret;
-	lc->algorithmtype = alg_id;
-	lc->enable = true;
-	return 0;
-}
-
 void *z_erofs_mt_wq_tls_free(struct erofs_workqueue *wq, void *priv)
 {
 	struct erofs_compress_wq_tls *tls = priv;
@@ -1488,15 +1469,23 @@ void z_erofs_mt_workfn(struct erofs_work *work, void *tlsp)
 	struct z_erofs_compress_ictx *ictx = sctx->ictx;
 	struct erofs_inode *inode = ictx->inode;
 	struct erofs_sb_info *sbi = inode->sbi;
-	int ret = 0;
+	struct erofs_compress_cfg *lc = &tls->ccfg[cwork->alg_id];
+	int ret;
 
-	ret = z_erofs_mt_wq_tls_init_compr(sbi, tls, cwork->alg_id,
-					   cwork->alg_name, cwork->comp_level,
-					   cwork->dict_size);
-	if (ret)
-		goto out;
+	if (__erofs_unlikely(!lc->enable)) {
+		unsigned int pclustersize_max =
+			ictx->im->params->pclusterblks_max << sbi->blkszbits;
 
-	sctx->pclustersize = z_erofs_get_max_pclustersize(inode);
+		ret = erofs_compressor_init(sbi, &lc->handle,
+					    cwork->alg_name, cwork->comp_level,
+					    cwork->dict_size, pclustersize_max);
+		if (ret)
+			goto out;
+		lc->algorithmtype = cwork->alg_id;
+		lc->enable = true;
+	}
+
+	sctx->pclustersize = z_erofs_get_pclustersize(ictx);
 	DBG_BUGON(sctx->pclustersize > Z_EROFS_PCLUSTER_MAX_SIZE);
 	sctx->queue = tls->queue;
 	sctx->destbuf = tls->destbuf;
@@ -1794,7 +1783,8 @@ int z_erofs_mt_global_exit(void)
 }
 #endif
 
-void *erofs_begin_compressed_file(struct erofs_inode *inode, int fd, u64 fpos)
+void *erofs_begin_compressed_file(struct erofs_importer *im,
+				  struct erofs_inode *inode, int fd, u64 fpos)
 {
 	struct erofs_sb_info *sbi = inode->sbi;
 	struct z_erofs_compress_ictx *ictx;
@@ -1833,6 +1823,8 @@ void *erofs_begin_compressed_file(struct erofs_inode *inode, int fd, u64 fpos)
 		if (!ictx)
 			return ERR_PTR(-ENOMEM);
 	}
+	ictx->im = im;
+	ictx->inode = inode;
 	ictx->fd = fd;
 	if (erofs_is_metabox_inode(inode))
 		ictx->ccfg = &sbi->zmgr->ccfg[cfg.c_mkfs_metabox_algid];
@@ -1842,7 +1834,7 @@ void *erofs_begin_compressed_file(struct erofs_inode *inode, int fd, u64 fpos)
 	inode->z_algorithmtype[1] = 0;
 	ictx->data_unaligned = erofs_sb_has_48bit(sbi) &&
 		cfg.c_max_decompressed_extent_bytes <=
-			z_erofs_get_max_pclustersize(inode);
+			z_erofs_get_pclustersize(ictx);
 	if (cfg.c_fragments && !cfg.c_dedupe && !ictx->data_unaligned)
 		inode->z_advise |= Z_EROFS_ADVISE_INTERLACED_PCLUSTER;
 
@@ -1865,7 +1857,6 @@ void *erofs_begin_compressed_file(struct erofs_inode *inode, int fd, u64 fpos)
 			}
 		}
 	}
-	ictx->inode = inode;
 	ictx->fpos = fpos;
 	init_list_head(&ictx->extents);
 	ictx->fix_dedupedfrag = false;
@@ -1929,7 +1920,7 @@ int erofs_write_compressed_file(struct z_erofs_compress_ictx *ictx)
 		.remaining = inode->i_size - inode->fragment_size,
 		.seg_idx = 0,
 		.pivot = &dummy_pivot,
-		.pclustersize = z_erofs_get_max_pclustersize(inode),
+		.pclustersize = z_erofs_get_pclustersize(ictx),
 	};
 	init_list_head(&sctx.extents);
 
@@ -1958,11 +1949,11 @@ out:
 	return ret;
 }
 
-static int z_erofs_build_compr_cfgs(struct erofs_sb_info *sbi,
-				    struct erofs_buffer_head *sb_bh,
+static int z_erofs_build_compr_cfgs(struct erofs_importer *im,
 				    u32 *max_dict_size)
 {
-	struct erofs_buffer_head *bh = sb_bh;
+	struct erofs_sb_info *sbi = im->sbi;
+	struct erofs_buffer_head *bh = sbi->bh_sb;
 	int ret = 0;
 
 	if (sbi->available_compr_algs & (1 << Z_EROFS_COMPRESSION_LZ4)) {
@@ -1974,8 +1965,7 @@ static int z_erofs_build_compr_cfgs(struct erofs_sb_info *sbi,
 			.lz4 = {
 				.max_distance =
 					cpu_to_le16(sbi->lz4.max_distance),
-				.max_pclusterblks =
-					cfg.c_mkfs_pclustersize_max >> sbi->blkszbits,
+				.max_pclusterblks = im->params->pclusterblks_max,
 			}
 		};
 
@@ -2066,7 +2056,9 @@ static int z_erofs_build_compr_cfgs(struct erofs_sb_info *sbi,
 
 int z_erofs_compress_init(struct erofs_importer *im)
 {
+	const struct erofs_importer_params *params = im->params;
 	struct erofs_sb_info *sbi = im->sbi;
+	unsigned int pclustersize_max = params->pclusterblks_max << sbi->blkszbits;
 	u32 max_dict_size[Z_EROFS_COMPRESSION_MAX] = {};
 	u32 available_compr_algs = 0;
 	bool newzmgr = false;
@@ -2085,7 +2077,8 @@ int z_erofs_compress_init(struct erofs_importer *im)
 
 		ret = erofs_compressor_init(sbi, c, cfg.c_compr_opts[i].alg,
 					    cfg.c_compr_opts[i].level,
-					    cfg.c_compr_opts[i].dict_size);
+					    cfg.c_compr_opts[i].dict_size,
+					    pclustersize_max);
 		if (ret)
 			return ret;
 
@@ -2110,10 +2103,9 @@ int z_erofs_compress_init(struct erofs_importer *im)
 			return -EOPNOTSUPP;
 		}
 		if ((available_compr_algs & BIT(Z_EROFS_COMPRESSION_LZ4)) &&
-		    (sbi->lz4.max_pclusterblks << sbi->blkszbits) <
-			cfg.c_mkfs_pclustersize_max) {
-			erofs_err("pclustersize %u is too large on incremental builds",
-				  cfg.c_mkfs_pclustersize_max);
+		    sbi->lz4.max_pclusterblks < params->pclusterblks_max) {
+			erofs_err("pcluster size (%u blocks) cannot increase on incremental builds",
+				  params->pclusterblks_max);
 			return -EOPNOTSUPP;
 		}
 	} else {
@@ -2129,28 +2121,29 @@ int z_erofs_compress_init(struct erofs_importer *im)
 	 * if big pcluster is enabled, an extra CBLKCNT lcluster index needs
 	 * to be loaded in order to get those compressed block counts.
 	 */
-	if (cfg.c_mkfs_pclustersize_max > erofs_blksiz(sbi)) {
-		if (cfg.c_mkfs_pclustersize_max > Z_EROFS_PCLUSTER_MAX_SIZE) {
-			erofs_err("unsupported pclustersize %u (too large)",
-				  cfg.c_mkfs_pclustersize_max);
+	if (params->pclusterblks_max) {
+		if (pclustersize_max > Z_EROFS_PCLUSTER_MAX_SIZE) {
+			erofs_err("pcluster size (%u blocks) is too large",
+				  params->pclusterblks_max);
 			return -EINVAL;
 		}
 		erofs_sb_set_big_pcluster(sbi);
 	}
-	if (cfg.c_mkfs_pclustersize_packed > cfg.c_mkfs_pclustersize_max) {
-		erofs_err("invalid pclustersize for the packed file %u",
-			  cfg.c_mkfs_pclustersize_packed);
+
+	if (params->pclusterblks_packed > params->pclusterblks_max) {
+		erofs_err("pcluster size (%u blocks) for packed inode exceeds maximum",
+			  params->pclusterblks_packed);
 		return -EINVAL;
 	}
 
-	if (cfg.c_mkfs_pclustersize_metabox > (s32)cfg.c_mkfs_pclustersize_max) {
-		erofs_err("invalid pclustersize for the metabox file %u",
-			  cfg.c_mkfs_pclustersize_metabox);
+	if (params->pclusterblks_metabox > (s32)params->pclusterblks_max) {
+		erofs_err("pcluster size (%u blocks) for metabox inode exceeds maximum",
+			  params->pclusterblks_metabox, params->pclusterblks_max);
 		return -EINVAL;
 	}
 
 	if (sbi->bh_sb && erofs_sb_has_compr_cfgs(sbi)) {
-		ret = z_erofs_build_compr_cfgs(sbi, sbi->bh_sb, max_dict_size);
+		ret = z_erofs_build_compr_cfgs(im, max_dict_size);
 		if (ret)
 			return ret;
 	}
diff --git a/lib/compress_hints.c b/lib/compress_hints.c
index e79bd48..15f3e54 100644
--- a/lib/compress_hints.c
+++ b/lib/compress_hints.c
@@ -45,17 +45,19 @@ static int erofs_insert_compress_hints(const char *s, unsigned int blks,
 	return ret;
 }
 
-bool z_erofs_apply_compress_hints(struct erofs_inode *inode)
+bool z_erofs_apply_compress_hints(struct erofs_importer *im,
+				  struct erofs_inode *inode)
 {
-	const char *s;
+	const struct erofs_importer_params *params = im->params;
+	unsigned int pclusterblks = params->pclusterblks_def;
+	unsigned int algorithmtype;
 	struct erofs_compress_hints *r;
-	unsigned int pclusterblks, algorithmtype;
+	const char *s;
 
 	if (inode->z_physical_clusterblks)
 		return true;
 
 	s = erofs_fspath(inode->i_srcpath);
-	pclusterblks = cfg.c_mkfs_pclustersize_def >> inode->sbi->blkszbits;
 	algorithmtype = 0;
 
 	list_for_each_entry(r, &compress_hints_head, list) {
@@ -86,11 +88,13 @@ void erofs_cleanup_compress_hints(void)
 	}
 }
 
-int erofs_load_compress_hints(struct erofs_sb_info *sbi)
+int erofs_load_compress_hints(struct erofs_importer *im,
+			      struct erofs_sb_info *sbi)
 {
+	struct erofs_importer_params *params = im->params;
 	char buf[PATH_MAX + 100];
 	FILE *f;
-	unsigned int line, max_pclustersize = 0;
+	unsigned int line, max_pclusterblks = 0;
 	int ret = 0;
 
 	if (!cfg.c_compress_hints_file)
@@ -101,7 +105,7 @@ int erofs_load_compress_hints(struct erofs_sb_info *sbi)
 		return -errno;
 
 	for (line = 1; fgets(buf, sizeof(buf), f); ++line) {
-		unsigned int pclustersize, ccfg;
+		unsigned int pclustersize, pclusterblks, ccfg;
 		char *alg, *pattern;
 
 		if (*buf == '#' || *buf == '\n')
@@ -134,22 +138,21 @@ int erofs_load_compress_hints(struct erofs_sb_info *sbi)
 		}
 
 		if (pclustersize % erofs_blksiz(sbi)) {
-			erofs_warn("invalid physical clustersize %u, "
-				   "use default pclusterblks %u",
-				   pclustersize, cfg.c_mkfs_pclustersize_def);
+			erofs_warn("invalid physical clustersize %u, use default pclustersize (%u blocks)",
+				   pclustersize, params->pclusterblks_max);
 			continue;
 		}
-		erofs_insert_compress_hints(pattern,
-				pclustersize / erofs_blksiz(sbi), ccfg);
+		pclusterblks = pclustersize >> sbi->blkszbits;
+		erofs_insert_compress_hints(pattern, pclusterblks, ccfg);
 
-		if (pclustersize > max_pclustersize)
-			max_pclustersize = pclustersize;
+		if (pclusterblks > max_pclusterblks)
+			max_pclusterblks = pclusterblks;
 	}
 
-	if (cfg.c_mkfs_pclustersize_max < max_pclustersize) {
-		cfg.c_mkfs_pclustersize_max = max_pclustersize;
-		erofs_warn("update max pclustersize to %u",
-			   cfg.c_mkfs_pclustersize_max);
+	if (params->pclusterblks_max < max_pclusterblks) {
+		erofs_warn("update max pclustersize to %u blocks",
+			   max_pclusterblks);
+		params->pclusterblks_max = max_pclusterblks;
 	}
 out:
 	fclose(f);
diff --git a/lib/compressor.c b/lib/compressor.c
index 6d8c1c2..efcead1 100644
--- a/lib/compressor.c
+++ b/lib/compressor.c
@@ -97,7 +97,8 @@ int erofs_compress(const struct erofs_compress *c,
 }
 
 int erofs_compressor_init(struct erofs_sb_info *sbi, struct erofs_compress *c,
-			  char *alg_name, int compression_level, u32 dict_size)
+			  char *alg_name, int compression_level,
+			  u32 dict_size, u32 pclustersize_max)
 {
 	int ret, i;
 
@@ -135,7 +136,8 @@ int erofs_compressor_init(struct erofs_sb_info *sbi, struct erofs_compress *c,
 		}
 
 		if (erofs_algs[i].c->setdictsize) {
-			ret = erofs_algs[i].c->setdictsize(c, dict_size);
+			ret = erofs_algs[i].c->setdictsize(c, dict_size,
+							   pclustersize_max);
 			if (ret) {
 				erofs_err("failed to set dict size %u for %s",
 					  dict_size, alg_name);
diff --git a/lib/compressor.h b/lib/compressor.h
index 5f86f15..c008206 100644
--- a/lib/compressor.h
+++ b/lib/compressor.h
@@ -21,7 +21,8 @@ struct erofs_compressor {
 	int (*exit)(struct erofs_compress *c);
 	void (*reset)(struct erofs_compress *c);
 	int (*setlevel)(struct erofs_compress *c, int compression_level);
-	int (*setdictsize)(struct erofs_compress *c, u32 dict_size);
+	int (*setdictsize)(struct erofs_compress *c, u32 dict_size,
+			   u32 pclustersize_max);
 
 	int (*compress_destsize)(const struct erofs_compress *c,
 				 const void *src, unsigned int *srcsize,
@@ -68,7 +69,8 @@ int erofs_compress(const struct erofs_compress *c,
 		   void *dst, unsigned int dstcapacity);
 
 int erofs_compressor_init(struct erofs_sb_info *sbi, struct erofs_compress *c,
-			  char *alg_name, int compression_level, u32 dict_size);
+			  char *alg_name, int compression_level, u32 dict_size,
+			  u32 pclustersize_max);
 int erofs_compressor_exit(struct erofs_compress *c);
 void erofs_compressor_reset(struct erofs_compress *c);
 
diff --git a/lib/compressor_liblzma.c b/lib/compressor_liblzma.c
index c4ba585..e6026b2 100644
--- a/lib/compressor_liblzma.c
+++ b/lib/compressor_liblzma.c
@@ -68,14 +68,14 @@ static int erofs_compressor_liblzma_setlevel(struct erofs_compress *c,
 }
 
 static int erofs_compressor_liblzma_setdictsize(struct erofs_compress *c,
-						u32 dict_size)
+						u32 dict_size, u32 pclustersize_max)
 {
 	if (!dict_size) {
 		if (erofs_compressor_lzma.default_dictsize) {
 			dict_size = erofs_compressor_lzma.default_dictsize;
 		} else {
 			dict_size = min_t(u32, Z_EROFS_LZMA_MAX_DICT_SIZE,
-					  cfg.c_mkfs_pclustersize_max << 2);
+					  pclustersize_max << 2);
 			if (dict_size < 32768)
 				dict_size = 32768;
 		}
diff --git a/lib/compressor_libzstd.c b/lib/compressor_libzstd.c
index 3233d72..feef409 100644
--- a/lib/compressor_libzstd.c
+++ b/lib/compressor_libzstd.c
@@ -115,14 +115,14 @@ static int erofs_compressor_libzstd_setlevel(struct erofs_compress *c,
 }
 
 static int erofs_compressor_libzstd_setdictsize(struct erofs_compress *c,
-						u32 dict_size)
+						u32 dict_size, u32 pclustersize_max)
 {
 	if (!dict_size) {
 		if (erofs_compressor_libzstd.default_dictsize) {
 			dict_size = erofs_compressor_libzstd.default_dictsize;
 		} else {
 			dict_size = min_t(u32, Z_EROFS_ZSTD_MAX_DICT_SIZE,
-					  cfg.c_mkfs_pclustersize_max << 3);
+					  pclustersize_max << 3);
 			dict_size = 1 << ilog2(dict_size);
 		}
 	}
diff --git a/lib/config.c b/lib/config.c
index b1d076d..1da5354 100644
--- a/lib/config.c
+++ b/lib/config.c
@@ -32,7 +32,6 @@ void erofs_init_configure(void)
 	cfg.c_inline_xattr_tolerance = 2;
 	cfg.c_unix_timestamp = -1;
 	cfg.c_max_decompressed_extent_bytes = -1;
-	cfg.c_mkfs_pclustersize_metabox = -1;
 	erofs_stdout_tty = isatty(STDOUT_FILENO);
 }
 
diff --git a/lib/importer.c b/lib/importer.c
index 7c3d147..e0ab505 100644
--- a/lib/importer.c
+++ b/lib/importer.c
@@ -53,8 +53,8 @@ int erofs_importer_init(struct erofs_importer *im)
 
 	if (cfg.c_fragments || cfg.c_extra_ea_name_prefixes) {
 		subsys = "packedfile";
-		if (!cfg.c_mkfs_pclustersize_packed)
-			cfg.c_mkfs_pclustersize_packed = cfg.c_mkfs_pclustersize_def;
+		if (!params->pclusterblks_packed)
+			params->pclusterblks_packed = params->pclusterblks_def;
 
 		err = erofs_packedfile_init(sbi, cfg.c_fragments);
 		if (err)
diff --git a/lib/inode.c b/lib/inode.c
index fef7128..102cc64 100644
--- a/lib/inode.c
+++ b/lib/inode.c
@@ -600,13 +600,14 @@ int erofs_write_file_from_buffer(struct erofs_inode *inode, char *buf)
 }
 
 /* rules to decide whether a file could be compressed or not */
-static bool erofs_file_is_compressible(struct erofs_inode *inode)
+static bool erofs_file_is_compressible(struct erofs_importer *im,
+				       struct erofs_inode *inode)
 {
 	if (erofs_is_metabox_inode(inode) &&
-	    cfg.c_mkfs_pclustersize_metabox < 0)
+	    !im->params->pclusterblks_metabox)
 		return false;
 	if (cfg.c_compress_hints_file)
-		return z_erofs_apply_compress_hints(inode);
+		return z_erofs_apply_compress_hints(im, inode);
 	return true;
 }
 
@@ -1804,9 +1805,9 @@ static int erofs_mkfs_handle_inode(struct erofs_importer *im,
 				return -errno;
 
 			if (cfg.c_compr_opts[0].alg &&
-			    erofs_file_is_compressible(inode)) {
-				ctx.ictx = erofs_begin_compressed_file(inode,
-								ctx.fd, 0);
+			    erofs_file_is_compressible(im, inode)) {
+				ctx.ictx = erofs_begin_compressed_file(im,
+							inode, ctx.fd, 0);
 				if (IS_ERR(ctx.ictx))
 					return PTR_ERR(ctx.ictx);
 			}
@@ -1870,8 +1871,8 @@ static int erofs_rebuild_handle_inode(struct erofs_importer *im,
 				return ret;
 
 			if (cfg.c_compr_opts[0].alg &&
-			    erofs_file_is_compressible(inode)) {
-				ctx.ictx = erofs_begin_compressed_file(inode,
+			    erofs_file_is_compressible(im, inode)) {
+				ctx.ictx = erofs_begin_compressed_file(im, inode,
 							ctx.fd, ctx.fpos);
 				if (IS_ERR(ctx.ictx))
 					return PTR_ERR(ctx.ictx);
@@ -2137,8 +2138,8 @@ struct erofs_inode *erofs_mkfs_build_special_from_fd(struct erofs_importer *im,
 	}
 
 	if (cfg.c_compr_opts[0].alg &&
-	    erofs_file_is_compressible(inode)) {
-		ictx = erofs_begin_compressed_file(inode, fd, 0);
+	    erofs_file_is_compressible(im, inode)) {
+		ictx = erofs_begin_compressed_file(im, inode, fd, 0);
 		if (IS_ERR(ictx))
 			return ERR_CAST(ictx);
 
diff --git a/lib/liberofs_compress.h b/lib/liberofs_compress.h
index 7f49e5d..e0f4d24 100644
--- a/lib/liberofs_compress.h
+++ b/lib/liberofs_compress.h
@@ -15,7 +15,8 @@
 struct z_erofs_compress_ictx;
 
 void z_erofs_drop_inline_pcluster(struct erofs_inode *inode);
-void *erofs_begin_compressed_file(struct erofs_inode *inode, int fd, u64 fpos);
+void *erofs_begin_compressed_file(struct erofs_importer *im,
+				  struct erofs_inode *inode, int fd, u64 fpos);
 int erofs_write_compressed_file(struct z_erofs_compress_ictx *ictx);
 
 int z_erofs_compress_init(struct erofs_importer *im);
diff --git a/mkfs/main.c b/mkfs/main.c
index 13c4761..a738907 100644
--- a/mkfs/main.c
+++ b/mkfs/main.c
@@ -1416,8 +1416,8 @@ static int mkfs_parse_options_cfg(struct erofs_importer_params *params,
 				  pclustersize_max);
 			return -EINVAL;
 		}
-		cfg.c_mkfs_pclustersize_max = pclustersize_max;
-		cfg.c_mkfs_pclustersize_def = cfg.c_mkfs_pclustersize_max;
+		params->pclusterblks_max = pclustersize_max >> mkfs_blkszbits;
+		params->pclusterblks_def = params->pclusterblks_max;
 	}
 	if (cfg.c_chunkbits && cfg.c_chunkbits < mkfs_blkszbits) {
 		erofs_err("chunksize %u must be larger than block size",
@@ -1447,7 +1447,7 @@ static int mkfs_parse_options_cfg(struct erofs_importer_params *params,
 				  pclustersize_packed);
 			return -EINVAL;
 		}
-		cfg.c_mkfs_pclustersize_packed = pclustersize_packed;
+		params->pclusterblks_packed = pclustersize_packed >> mkfs_blkszbits;
 	}
 
 	if (pclustersize_metabox >= 0) {
@@ -1458,7 +1458,7 @@ static int mkfs_parse_options_cfg(struct erofs_importer_params *params,
 				  pclustersize_metabox);
 			return -EINVAL;
 		}
-		cfg.c_mkfs_pclustersize_metabox = pclustersize_metabox;
+		params->pclusterblks_metabox = pclustersize_metabox >> mkfs_blkszbits;
 		cfg.c_mkfs_metabox_algid = metabox_algorithmid;
 		erofs_sb_set_metabox(&g_sbi);
 	}
@@ -1468,7 +1468,7 @@ static int mkfs_parse_options_cfg(struct erofs_importer_params *params,
 	return 0;
 }
 
-static void erofs_mkfs_default_options(void)
+static void erofs_mkfs_default_options(struct erofs_importer_params *params)
 {
 	cfg.c_showprogress = true;
 	cfg.c_legacy_compress = false;
@@ -1478,8 +1478,8 @@ static void erofs_mkfs_default_options(void)
 	cfg.c_mkfs_segment_size = 16ULL * 1024 * 1024;
 #endif
 	mkfs_blkszbits = ilog2(min_t(u32, getpagesize(), EROFS_MAX_BLOCK_SIZE));
-	cfg.c_mkfs_pclustersize_max = 1U << mkfs_blkszbits;
-	cfg.c_mkfs_pclustersize_def = cfg.c_mkfs_pclustersize_max;
+	params->pclusterblks_max = 1U;
+	params->pclusterblks_def = 1U;
 	g_sbi.feature_incompat = EROFS_FEATURE_INCOMPAT_ZERO_PADDING;
 	g_sbi.feature_compat = EROFS_FEATURE_COMPAT_SB_CHKSUM |
 			     EROFS_FEATURE_COMPAT_MTIME;
@@ -1635,8 +1635,8 @@ int main(int argc, char **argv)
 	err = liberofs_global_init();
 	if (err)
 		return 1;
-	erofs_mkfs_default_options();
 	erofs_importer_preset(&importer_params);
+	erofs_mkfs_default_options(&importer_params);
 
 	err = mkfs_parse_options_cfg(&importer_params, argc, argv);
 	erofs_show_progs(argc, argv);
@@ -1745,7 +1745,7 @@ int main(int argc, char **argv)
 		}
 	}
 
-	err = erofs_load_compress_hints(&g_sbi);
+	err = erofs_load_compress_hints(&importer, &g_sbi);
 	if (err) {
 		erofs_err("failed to load compress hints %s",
 			  cfg.c_compress_hints_file);
-- 
2.43.5



More information about the Linux-erofs mailing list