* [PATCH v3 1/2] erofs-utils: mkfs: defer compressed metadata generation @ 2026-09-11 10:28 Gao Xiang 2026-09-11 10:28 ` [PATCH v3 2/2] erofs-utils: mkfs: enable `--blobdev` for compressed inode layouts Gao Xiang 0 siblings, 1 reply; 2+ messages in thread From: Gao Xiang @ 2026-09-11 10:28 UTC (permalink / raw) To: linux-erofs; +Cc: Gao Xiang Generally, unique addresses should be assigned after the size of the primary device is decided. Defer compressed metadata generation until after erofs_update_all_devices(). This is used to support multi-device compressed filesystems (including fsmerge support for compressed images.) Signed-off-by: Gao Xiang <xiang@kernel.org> --- v3: - address Yifan's comments. include/erofs/internal.h | 1 - lib/compress.c | 488 ++++++++++++++++++++++----------------- lib/inode.c | 10 +- lib/liberofs_compress.h | 2 + 4 files changed, 280 insertions(+), 221 deletions(-) diff --git a/include/erofs/internal.h b/include/erofs/internal.h index 84a7590..0de71fb 100644 --- a/include/erofs/internal.h +++ b/include/erofs/internal.h @@ -212,7 +212,6 @@ struct erofs_diskbuf; enum erofs_idata_type { EROFS_IDATA_TYPE_RAW, EROFS_IDATA_TYPE_COMPRESSED_DEFAULT, - EROFS_IDATA_TYPE_COMPRESSED_END_OF_2B, }; #define EROFS_I_BLKADDR_DEV_ID_BIT 48 diff --git a/lib/compress.c b/lib/compress.c index 9bbb127..628d6f8 100644 --- a/lib/compress.c +++ b/lib/compress.c @@ -139,9 +139,13 @@ struct z_erofs_mgr { static bool z_erofs_mt_enabled; -#define Z_EROFS_LEGACY_MAP_HEADER_SIZE Z_EROFS_FULL_INDEX_START(0) +struct z_erofs_index_writer { + struct erofs_inode *inode; + u8 *metacur; + unsigned short clusterofs; +}; -static void z_erofs_fini_full_indexes(struct z_erofs_compress_ictx *ctx) +static void z_erofs_fini_full_indexes(struct z_erofs_index_writer *ctx) { const unsigned int type = Z_EROFS_LCLUSTER_TYPE_PLAIN; struct z_erofs_lcluster_index di; @@ -157,10 +161,9 @@ static void z_erofs_fini_full_indexes(struct z_erofs_compress_ictx *ctx) ctx->metacur += sizeof(di); } -static void z_erofs_write_full_indexes(struct z_erofs_compress_ictx *ctx, +static void z_erofs_write_full_indexes(struct z_erofs_index_writer *ctx, struct z_erofs_inmem_extent *e) { - const struct erofs_importer_params *params = ctx->im->params; struct erofs_inode *inode = ctx->inode; struct erofs_sb_info *sbi = inode->sbi; unsigned int clusterofs = ctx->clusterofs; @@ -181,7 +184,7 @@ static void z_erofs_write_full_indexes(struct z_erofs_compress_ictx *ctx, * A lcluster cannot have three parts with the middle one which * is well-compressed for !ztailpacking cases. */ - DBG_BUGON(!e->raw && !params->ztailpacking && !params->fragments); + DBG_BUGON(!e->raw && !inode->idata_size && !inode->fragment_size); DBG_BUGON(e->partial); type = e->raw ? Z_EROFS_LCLUSTER_TYPE_PLAIN : Z_EROFS_LCLUSTER_TYPE_HEAD1; @@ -895,16 +898,16 @@ static void *write_compacted_indexes(u8 *out, return out + destsize * vcnt; } -int z_erofs_convert_to_compacted_format(struct erofs_inode *inode, - erofs_off_t pstart, - unsigned int legacymetasize, - void *compressmeta) +int z_erofs_convert_to_compact_format(struct erofs_inode *inode, + erofs_off_t pstart, + unsigned int fullmetasz, + void *metabuf) { const unsigned int mpos = roundup(inode->inode_isize + inode->xattr_isize, 8) + sizeof(struct z_erofs_map_header); - const unsigned int totalidx = (legacymetasize - - Z_EROFS_LEGACY_MAP_HEADER_SIZE) / + const unsigned int totalidx = (fullmetasz - + Z_EROFS_FULL_INDEX_START(0)) / sizeof(struct z_erofs_lcluster_index); const unsigned int logical_clusterbits = inode->z_lclusterbits; u8 *out, *in; @@ -953,10 +956,18 @@ int z_erofs_convert_to_compacted_format(struct erofs_inode *inode, compacted_4b_end = totalidx; } - out = in = compressmeta; + if (!metabuf) { + out = (u8 *)sizeof(struct z_erofs_map_header); + out += 4 * compacted_4b_initial; + out += 2 * compacted_2b; + out += 4 * round_up(compacted_4b_end, 2); + return out - (u8 *)metabuf; + } + + out = in = metabuf; out += sizeof(struct z_erofs_map_header); - in += Z_EROFS_LEGACY_MAP_HEADER_SIZE; + in += Z_EROFS_FULL_INDEX_START(0); dummy_head = false; /* prior to bigpcluster, blkaddr was bumped up once coming into HEAD */ @@ -977,9 +988,6 @@ int z_erofs_convert_to_compacted_format(struct erofs_inode *inode, /* generate compacted_2b */ if (compacted_2b) { - if (!compacted_4b_end && inode->idata_size && - inode->idata_type != EROFS_IDATA_TYPE_RAW) - inode->idata_type = EROFS_IDATA_TYPE_COMPRESSED_END_OF_2B; do { in = parse_legacy_indexes(cv, 16, in); out = write_compacted_indexes(out, cv, &blkaddr, @@ -1006,8 +1014,7 @@ int z_erofs_convert_to_compacted_format(struct erofs_inode *inode, 4, logical_clusterbits, true, &dummy_head, big_pcluster); } - inode->extent_isize = out - (u8 *)compressmeta; - return 0; + return out - (u8 *)metabuf; } static void z_erofs_write_mapheader(struct erofs_inode *inode, @@ -1044,78 +1051,156 @@ static void z_erofs_write_mapheader(struct erofs_inode *inode, h.h_fragmentoff = cpu_to_le32(inode->fragmentoff); else h.h_idata_size = cpu_to_le16(inode->idata_size); - - memset(compressmeta, 0, Z_EROFS_LEGACY_MAP_HEADER_SIZE); } + memset(compressmeta, 0, Z_EROFS_FULL_INDEX_START(0)); /* write out map header */ memcpy(compressmeta, &h, sizeof(struct z_erofs_map_header)); } #define EROFS_FULL_INDEXES_SZ(inode) \ (BLK_ROUND_UP(inode->sbi, inode->i_size) * \ - sizeof(struct z_erofs_lcluster_index) + Z_EROFS_LEGACY_MAP_HEADER_SIZE) + sizeof(struct z_erofs_lcluster_index) + Z_EROFS_FULL_INDEX_START(0)) + +struct z_erofs_metadata_ctx { + struct list_head extents; +}; -static void *z_erofs_write_extents(struct z_erofs_compress_ictx *ctx) +static int z_erofs_prepare_layout(struct erofs_inode *inode, + struct list_head *extents, + bool consecutive, bool no_compact) { - struct erofs_inode *inode = ctx->inode; struct erofs_sb_info *sbi = inode->sbi; - struct z_erofs_extent_item *ei, *n; - unsigned int lclusterbits, nexts; - bool pstart_hi = false, unaligned_data = false; - erofs_off_t pstart, pend, lstart; - unsigned int recsz, metasz, moff; - void *metabuf; - - ei = list_first_entry(&ctx->extents, struct z_erofs_extent_item, - list); - lclusterbits = max_t(u8, ilog2(ei->e.length - 1) + 1, sbi->blkszbits); - pend = pstart = ei->e.pstart; - nexts = 0; - list_for_each_entry(ei, &ctx->extents, list) { - pstart_hi |= (ei->e.pstart > UINT32_MAX); - if ((ei->e.pstart | ei->e.plen) & ((1U << sbi->blkszbits) - 1)) - unaligned_data = true; - if (pend != ei->e.pstart) - pend = EROFS_NULL_ADDR; - else - pend += ei->e.plen; - if (ei->e.length != 1 << lclusterbits) { - if (ei->list.next != &ctx->extents || - ei->e.length > 1 << lclusterbits) - lclusterbits = 0; + struct z_erofs_metadata_ctx *ctx; + unsigned int metasz; + int ret; + + ctx = malloc(sizeof(*ctx)); + if (!ctx) + return -ENOMEM; + init_list_head(&ctx->extents); + list_splice_tail(extents, &ctx->extents); + + /* if the entire file is a fragment, a simplified form is used. */ + if (inode->i_size <= inode->fragment_size) { + DBG_BUGON(inode->i_size < inode->fragment_size); + DBG_BUGON(inode->fragmentoff >> 63); + inode->datalayout = EROFS_INODE_COMPRESSED_FULL; + metasz = Z_EROFS_FULL_INDEX_START(0); + goto out; + } + + /* TODO: support writing encoded extents for ztailpacking later. */ + if (erofs_sb_has_48bit(sbi) && !inode->idata_size) { + bool pstart_hi = false, unaligned_data = false; + unsigned int lclusterbits, nexts; + struct z_erofs_extent_item *ei; + erofs_off_t pstart, pend; + unsigned int recsz, moff; + + ei = list_first_entry(&ctx->extents, struct z_erofs_extent_item, + list); + lclusterbits = max_t(u8, ilog2(ei->e.length - 1) + 1, sbi->blkszbits); + pend = pstart = ei->e.pstart; + nexts = 0; + list_for_each_entry(ei, &ctx->extents, list) { + pstart_hi |= (ei->e.pstart > UINT32_MAX); + if ((ei->e.pstart | ei->e.plen) & ((1U << sbi->blkszbits) - 1)) + unaligned_data = true; + if (pend != ei->e.pstart) + pend = EROFS_NULL_ADDR; + else + pend += ei->e.plen; + if (ei->e.length != 1 << lclusterbits) { + if (ei->list.next != &ctx->extents || + ei->e.length > 1 << lclusterbits) + lclusterbits = 0; + } + ++nexts; } - ++nexts; + inode->z_extents = nexts; + recsz = inode->i_size > UINT32_MAX ? 32 : 16; + if (lclusterbits) { + if (pend != EROFS_NULL_ADDR) + recsz = 4; + else if (recsz <= 16 && !pstart_hi) + recsz = 8; + } + + moff = Z_EROFS_MAP_HEADER_END(inode->inode_isize + inode->xattr_isize); + moff = round_up(moff, recsz) - + Z_EROFS_MAP_HEADER_START(inode->inode_isize + inode->xattr_isize); + metasz = moff + recsz * nexts + 8 * (recsz <= 4); + if (unaligned_data || metasz < EROFS_FULL_INDEXES_SZ(inode)) { + inode->z_lclusterbits = lclusterbits; + inode->z_extents = nexts; + inode->datalayout = EROFS_INODE_COMPRESSED_FULL; + inode->z_advise |= Z_EROFS_ADVISE_EXTENTS | + ((ilog2(recsz) - 2) << Z_EROFS_ADVISE_EXTRECSZ_BIT); + goto out; + } + } + + /* + * If the packed inode is larger than 4GiB, the full fragmentoff + * will be recorded by switching to the noncompact layout anyway. + */ + if (inode->fragment_size && inode->fragmentoff >> 32) { + inode->datalayout = EROFS_INODE_COMPRESSED_FULL; + } else if (!no_compact && consecutive && + inode->z_lclusterbits <= 14) { + if (inode->z_lclusterbits <= 12) + inode->z_advise |= Z_EROFS_ADVISE_COMPACTED_2B; + inode->datalayout = EROFS_INODE_COMPRESSED_COMPACT; + } else { + inode->datalayout = EROFS_INODE_COMPRESSED_FULL; + } + + if (erofs_sb_has_big_pcluster(sbi)) { + inode->z_advise |= Z_EROFS_ADVISE_BIG_PCLUSTER_1; + if (inode->datalayout == EROFS_INODE_COMPRESSED_COMPACT) + inode->z_advise |= Z_EROFS_ADVISE_BIG_PCLUSTER_2; } - recsz = inode->i_size > UINT32_MAX ? 32 : 16; - if (lclusterbits) { - if (pend != EROFS_NULL_ADDR) - recsz = 4; - else if (recsz <= 16 && !pstart_hi) - recsz = 8; + metasz = EROFS_FULL_INDEXES_SZ(inode); + + if (inode->datalayout == EROFS_INODE_COMPRESSED_COMPACT) { + ret = z_erofs_convert_to_compact_format(inode, 0, metasz, + NULL); + if (ret < 0) + return ret; + metasz = ret; } +out: + inode->extent_isize = metasz; + inode->compressmeta = ctx; + return 0; +} + +static void z_erofs_write_extents(struct erofs_inode *inode, + struct list_head *extents, u8 *metabuf) +{ + unsigned int recsz = z_erofs_extent_recsize(inode->z_advise); + struct z_erofs_extent_item *ei, *n; + erofs_off_t pstart, lstart; + unsigned int moff; + u8 *metacur; + u64 nexts; + moff = Z_EROFS_MAP_HEADER_END(inode->inode_isize + inode->xattr_isize); moff = round_up(moff, recsz) - Z_EROFS_MAP_HEADER_START(inode->inode_isize + inode->xattr_isize); - metasz = moff + recsz * nexts + 8 * (recsz <= 4); - if (!unaligned_data && metasz > EROFS_FULL_INDEXES_SZ(inode)) - return ERR_PTR(-EAGAIN); - - metabuf = malloc(metasz); - if (!metabuf) - return ERR_PTR(-ENOMEM); - inode->z_lclusterbits = lclusterbits; - inode->z_extents = nexts; - ctx->metacur = metabuf + moff; + metacur = metabuf + moff; if (recsz <= 4) { - *(__le64 *)ctx->metacur = cpu_to_le64(pstart); - ctx->metacur += sizeof(__le64); + ei = list_first_entry(extents, struct z_erofs_extent_item, list); + pstart = ei->e.pstart; + *(__le64 *)metacur = cpu_to_le64(pstart); + metacur += sizeof(__le64); } nexts = 0; lstart = 0; - list_for_each_entry_safe(ei, n, &ctx->extents, list) { + list_for_each_entry_safe(ei, n, extents, list) { struct z_erofs_extent de; u32 fmt, plen; @@ -1136,128 +1221,30 @@ static void *z_erofs_write_extents(struct z_erofs_compress_ictx *ctx) .pstart_hi = cpu_to_le32(ei->e.pstart >> 32), .lstart_hi = cpu_to_le32(lstart >> 32), }; - memcpy(ctx->metacur, &de, recsz); - ctx->metacur += recsz; + memcpy(metacur, &de, recsz); + metacur += recsz; lstart += ei->e.length; list_del(&ei->list); free(ei); + ++nexts; } - inode->datalayout = EROFS_INODE_COMPRESSED_FULL; - inode->z_advise |= Z_EROFS_ADVISE_EXTENTS | - ((ilog2(recsz) - 2) << Z_EROFS_ADVISE_EXTRECSZ_BIT); - return metabuf; -} - -static void *z_erofs_write_indexes(struct z_erofs_compress_ictx *ctx) -{ - const struct erofs_importer_params *params = ctx->im->params; - struct erofs_inode *inode = ctx->inode; - struct erofs_sb_info *sbi = inode->sbi; - struct z_erofs_extent_item *ei, *n; - void *metabuf; - - /* TODO: support writing encoded extents for ztailpacking later. */ - if (erofs_sb_has_48bit(sbi) && !inode->idata_size) { - metabuf = z_erofs_write_extents(ctx); - if (metabuf != ERR_PTR(-EAGAIN)) { - if (IS_ERR(metabuf)) - return metabuf; - goto out; - } - } - - /* - * If the packed inode is larger than 4GiB, the full fragmentoff - * will be recorded by switching to the noncompact layout anyway. - */ - if (inode->fragment_size && inode->fragmentoff >> 32) { - inode->datalayout = EROFS_INODE_COMPRESSED_FULL; - } else if (!params->no_zcompact && !ctx->dedupe && - inode->z_lclusterbits <= 14) { - if (inode->z_lclusterbits <= 12) - inode->z_advise |= Z_EROFS_ADVISE_COMPACTED_2B; - inode->datalayout = EROFS_INODE_COMPRESSED_COMPACT; - } else { - inode->datalayout = EROFS_INODE_COMPRESSED_FULL; - } - - if (erofs_sb_has_big_pcluster(sbi)) { - inode->z_advise |= Z_EROFS_ADVISE_BIG_PCLUSTER_1; - if (inode->datalayout == EROFS_INODE_COMPRESSED_COMPACT) - inode->z_advise |= Z_EROFS_ADVISE_BIG_PCLUSTER_2; - } - - metabuf = malloc(BLK_ROUND_UP(inode->sbi, inode->i_size) * - sizeof(struct z_erofs_lcluster_index) + - Z_EROFS_LEGACY_MAP_HEADER_SIZE); - if (!metabuf) - return ERR_PTR(-ENOMEM); - - ctx->metacur = metabuf + Z_EROFS_LEGACY_MAP_HEADER_SIZE; - ctx->clusterofs = 0; - list_for_each_entry_safe(ei, n, &ctx->extents, list) { - DBG_BUGON(ei->list.next != &ctx->extents && - ctx->clusterofs + ei->e.length < erofs_blksiz(sbi)); - z_erofs_write_full_indexes(ctx, &ei->e); - - list_del(&ei->list); - free(ei); - } - z_erofs_fini_full_indexes(ctx); -out: - z_erofs_write_mapheader(inode, metabuf); - return metabuf; + DBG_BUGON(inode->z_extents && nexts != inode->z_extents); + DBG_BUGON(metacur - metabuf != inode->extent_isize); } void z_erofs_drop_inline_pcluster(struct erofs_inode *inode) { - struct erofs_sb_info *sbi = inode->sbi; - const unsigned int type = Z_EROFS_LCLUSTER_TYPE_PLAIN; - struct z_erofs_map_header *h = inode->compressmeta; + struct z_erofs_metadata_ctx *ctx = inode->compressmeta; + struct z_erofs_extent_item *ei; - h->h_advise = cpu_to_le16(le16_to_cpu(h->h_advise) & - ~Z_EROFS_ADVISE_INLINE_PCLUSTER); - DBG_BUGON(inode->idata_size != le16_to_cpu(h->h_idata_size)); - h->h_idata_size = 0; + inode->z_advise &= ~Z_EROFS_ADVISE_INLINE_PCLUSTER; if (!inode->eof_tailraw) return; DBG_BUGON(inode->idata_type == EROFS_IDATA_TYPE_RAW); - /* patch the EOF lcluster to uncompressed type first */ - if (inode->datalayout == EROFS_INODE_COMPRESSED_FULL) { - struct z_erofs_lcluster_index *di = - (inode->compressmeta + inode->extent_isize) - - sizeof(struct z_erofs_lcluster_index); - - di->di_advise = cpu_to_le16(type); - } else if (inode->datalayout == EROFS_INODE_COMPRESSED_COMPACT) { - /* handle the last compacted 4B/2B pack */ - unsigned int lclusterbits = inode->z_lclusterbits; - unsigned int lobits, eofs, base, pos, v; - u8 *out; - - lobits = max(lclusterbits, ilog2(Z_EROFS_LI_D0_CBLKCNT) + 1U); - - if (inode->idata_type == EROFS_IDATA_TYPE_COMPRESSED_DEFAULT) { - eofs = inode->extent_isize - - (4 << (BLK_ROUND_UP(sbi, inode->i_size) & 1)); - base = round_down(eofs, 8); - pos = 16 /* encodebits */ * ((eofs - base) / 4); - out = inode->compressmeta + base + pos / 8; - } else { - out = inode->compressmeta + inode->extent_isize - - sizeof(__le32) - sizeof(__le16); - lobits = 16 - 14 /* encodebits */ + lobits; - } - - v = (get_unaligned_le16(out) & (BIT(lobits) - 1)) | - (type << lobits); - *out = v & 0xff; - *(out + 1) = v >> 8; - } else { - DBG_BUGON(1); - return; - } + ei = list_last_entry(&ctx->extents, struct z_erofs_extent_item, list); + DBG_BUGON(ei->e.raw); + ei->e.raw = true; free(inode->idata); /* replace idata with prepared uncompressed data */ inode->idata = inode->eof_tailraw; @@ -1341,6 +1328,22 @@ int z_erofs_compress_segment(struct z_erofs_compress_sctx *ctx, return 0; } +void z_erofs_free_metadata(struct erofs_inode *inode) +{ + struct z_erofs_metadata_ctx *mctx = inode->compressmeta; + struct z_erofs_extent_item *ei, *n; + + if (!mctx) + return; + + list_for_each_entry_safe(ei, n, &mctx->extents, list) { + list_del(&ei->list); + free(ei); + } + free(mctx); + inode->compressmeta = NULL; +} + int erofs_commit_compressed_file(struct z_erofs_compress_ictx *ictx, struct erofs_buffer_head *bh, erofs_off_t pstart, erofs_off_t ptotal) @@ -1348,8 +1351,7 @@ int erofs_commit_compressed_file(struct z_erofs_compress_ictx *ictx, struct erofs_inode *inode = ictx->inode; const struct erofs_importer_params *params = ictx->im->params; struct erofs_sb_info *sbi = inode->sbi; - unsigned int legacymetasize, bbits = sbi->blkszbits; - u8 *compressmeta; + unsigned int bbits = sbi->blkszbits; int ret; if (inode->fragment_size) { @@ -1364,19 +1366,17 @@ int erofs_commit_compressed_file(struct z_erofs_compress_ictx *ictx, } /* fall back to no compression mode */ - DBG_BUGON(pstart < (!!inode->idata_size) << bbits); + DBG_BUGON(ptotal < ((!!inode->idata_size) << bbits)); ptotal -= (u64)(!!inode->idata_size) << bbits; - compressmeta = z_erofs_write_indexes(ictx); - if (!compressmeta) { - ret = -ENOMEM; + ret = z_erofs_prepare_layout(inode, &ictx->extents, !ictx->dedupe, + params->no_zcompact); + if (ret) goto err_free_idata; - } - legacymetasize = ictx->metacur - compressmeta; /* estimate if data compression saves space or not */ if (!inode->fragment_size && ptotal + inode->idata_size + - legacymetasize >= inode->i_size) { + inode->extent_isize >= inode->i_size) { z_erofs_dedupe_ext_commit(true); z_erofs_dedupe_commit(true); ret = EROFS_RETVAL_FALLBACK; @@ -1388,16 +1388,6 @@ int erofs_commit_compressed_file(struct z_erofs_compress_ictx *ictx, if (!ictx->fragemitted) sbi->saved_by_deduplication += inode->fragment_size; - /* if the entire file is a fragment, a simplified form is used. */ - if (inode->i_size <= inode->fragment_size) { - DBG_BUGON(inode->i_size < inode->fragment_size); - DBG_BUGON(inode->fragmentoff >> 63); - *(__le64 *)compressmeta = - cpu_to_le64(inode->fragmentoff | 1ULL << 63); - inode->datalayout = EROFS_INODE_COMPRESSED_FULL; - legacymetasize = Z_EROFS_LEGACY_MAP_HEADER_SIZE; - } - if (ptotal) (void)erofs_bh_balloon(bh, ptotal); else if (!params->fragments && params->dedupe != EROFS_DEDUPE_FORCE_ON) @@ -1414,21 +1404,11 @@ int erofs_commit_compressed_file(struct z_erofs_compress_ictx *ictx, } inode->u.i_blocks = BLK_ROUND_UP(sbi, ptotal); - - if (inode->datalayout == EROFS_INODE_COMPRESSED_FULL) { - inode->extent_isize = legacymetasize; - } else { - ret = z_erofs_convert_to_compacted_format(inode, pstart, - legacymetasize, - compressmeta); - DBG_BUGON(ret); - } - inode->compressmeta = compressmeta; return 0; err_free_meta: - free(compressmeta); - inode->compressmeta = NULL; + z_erofs_free_metadata(inode); + inode->extent_isize = 0; err_free_idata: erofs_bdrop(bh, true); /* revoke buffer */ if (inode->idata) { @@ -1438,6 +1418,84 @@ err_free_idata: return ret; } +char *z_erofs_write_metadata(struct erofs_inode *inode) +{ + struct erofs_sb_info *sbi = inode->sbi; + struct z_erofs_metadata_ctx *mctx = inode->compressmeta; + struct z_erofs_extent_item *ei, *n; + struct z_erofs_index_writer ctx; + unsigned int metasz = + inode->datalayout == EROFS_INODE_COMPRESSED_COMPACT ? + EROFS_FULL_INDEXES_SZ(inode) : inode->extent_isize; + erofs_off_t pstart; + u8 *metabuf; + int err = 0; + + metabuf = malloc(metasz); + if (!metabuf) { + err = -ENOMEM; + goto out; + } + + /* if the entire file is a fragment, a simplified form is used. */ + if (inode->datalayout == EROFS_INODE_COMPRESSED_FULL && + inode->i_size <= inode->fragment_size) { + DBG_BUGON(inode->i_size < inode->fragment_size); + DBG_BUGON(inode->fragmentoff >> 63); + DBG_BUGON(metasz != Z_EROFS_FULL_INDEX_START(0)); + memset(metabuf, 0, metasz); + *(__le64 *)metabuf = cpu_to_le64(inode->fragmentoff | 1ULL << 63); + goto out; + } + + if (__erofs_unlikely(!mctx)) { + DBG_BUGON(1); + return ERR_PTR(-EINVAL); + } + + z_erofs_write_mapheader(inode, metabuf); + + if (inode->datalayout == EROFS_INODE_COMPRESSED_FULL && + (inode->z_advise & Z_EROFS_ADVISE_EXTENTS)) { + z_erofs_write_extents(inode, &mctx->extents, metabuf); + goto out; + } + + ctx = (struct z_erofs_index_writer) { + .inode = inode, + .metacur = metabuf + Z_EROFS_FULL_INDEX_START(0), + }; + + DBG_BUGON(list_empty(&mctx->extents)); + ei = list_first_entry(&mctx->extents, struct z_erofs_extent_item, list); + pstart = ei->e.pstart; + + list_for_each_entry_safe(ei, n, &mctx->extents, list) { + DBG_BUGON(ei->list.next != &mctx->extents && + ctx.clusterofs + ei->e.length < erofs_blksiz(sbi)); + z_erofs_write_full_indexes(&ctx, &ei->e); + + list_del(&ei->list); + free(ei); + } + z_erofs_fini_full_indexes(&ctx); + DBG_BUGON(metasz != ctx.metacur - metabuf); + + if (inode->datalayout == EROFS_INODE_COMPRESSED_COMPACT) { + err = z_erofs_convert_to_compact_format(inode, pstart, + metasz, metabuf); + if (err < 0) { + DBG_BUGON(1); + goto out; + } + metasz = err; + } + DBG_BUGON(metasz != inode->extent_isize); +out: + z_erofs_free_metadata(inode); + return err < 0 ? ERR_PTR(err) : metabuf; +} + static struct z_erofs_compress_ictx g_ictx; #ifdef EROFS_MT_ENABLED @@ -2053,24 +2111,23 @@ int erofs_begin_compress_dir(struct erofs_importer *im, { if (!im->params->compress_dir || - inode->i_size < Z_EROFS_LEGACY_MAP_HEADER_SIZE) + inode->i_size < Z_EROFS_FULL_INDEX_START(0)) return EROFS_RETVAL_FALLBACK; inode->z_advise |= Z_EROFS_ADVISE_FRAGMENT_PCLUSTER; erofs_sb_set_fragments(inode->sbi); inode->datalayout = EROFS_INODE_COMPRESSED_FULL; - inode->extent_isize = Z_EROFS_LEGACY_MAP_HEADER_SIZE; + inode->extent_isize = Z_EROFS_FULL_INDEX_START(0); inode->compressmeta = NULL; return 0; } int erofs_write_compress_dir(struct erofs_inode *inode, struct erofs_vfile *vf) { - void *compressmeta; int err; if (inode->datalayout != EROFS_INODE_COMPRESSED_FULL || - inode->extent_isize < Z_EROFS_LEGACY_MAP_HEADER_SIZE) { + inode->extent_isize < Z_EROFS_FULL_INDEX_START(0)) { DBG_BUGON(1); return -EINVAL; } @@ -2081,13 +2138,8 @@ int erofs_write_compress_dir(struct erofs_inode *inode, struct erofs_vfile *vf) err = erofs_fragment_commit(inode, ~0); if (err) return err; - - compressmeta = calloc(1, Z_EROFS_LEGACY_MAP_HEADER_SIZE); - if (!compressmeta) - return -ENOMEM; - *(__le64 *)compressmeta = - cpu_to_le64(inode->fragmentoff | 1ULL << 63); - inode->compressmeta = compressmeta; + DBG_BUGON(inode->fragment_size != inode->i_size); + DBG_BUGON(inode->compressmeta); return 0; } diff --git a/lib/inode.c b/lib/inode.c index 2cd7bed..6f3748a 100644 --- a/lib/inode.c +++ b/lib/inode.c @@ -149,7 +149,7 @@ unsigned int erofs_iput(struct erofs_inode *inode) list_for_each_entry_safe(d, t, &inode->i_subdirs, d_child) free(d); - free(inode->compressmeta); + z_erofs_free_metadata(inode); free(inode->eof_tailraw); erofs_remove_ihash(inode); if (!erofs_is_special_identifier(inode->i_srcpath)) @@ -925,9 +925,15 @@ int erofs_iflush(struct erofs_inode *inode) if (inode->datalayout == EROFS_INODE_CHUNK_BASED) { ret = erofs_write_chunk_indexes(inode, ibmgr->vf, off); } else { /* write compression metadata */ + char *metabuf; + off = roundup(off, 8); - ret = erofs_io_pwrite(ibmgr->vf, inode->compressmeta, + metabuf = z_erofs_write_metadata(inode); + if (IS_ERR(metabuf)) + return PTR_ERR(metabuf); + ret = erofs_io_pwrite(ibmgr->vf, metabuf, off, inode->extent_isize); + free(metabuf); } if (ret != inode->extent_isize) return ret < 0 ? ret : -EIO; diff --git a/lib/liberofs_compress.h b/lib/liberofs_compress.h index da6eb1a..50b3804 100644 --- a/lib/liberofs_compress.h +++ b/lib/liberofs_compress.h @@ -19,6 +19,8 @@ void *erofs_prepare_compressed_file(struct erofs_importer *im, struct erofs_inode *inode); void erofs_bind_compressed_file_with_fd(struct z_erofs_compress_ictx *ictx, int fd, u64 fpos); +void z_erofs_free_metadata(struct erofs_inode *inode); +char *z_erofs_write_metadata(struct erofs_inode *inode); int erofs_begin_compressed_file(struct z_erofs_compress_ictx *ictx); int erofs_write_compressed_file(struct z_erofs_compress_ictx *ictx); -- 2.47.3 ^ permalink raw reply related [flat|nested] 2+ messages in thread
* [PATCH v3 2/2] erofs-utils: mkfs: enable `--blobdev` for compressed inode layouts 2026-09-11 10:28 [PATCH v3 1/2] erofs-utils: mkfs: defer compressed metadata generation Gao Xiang @ 2026-09-11 10:28 ` Gao Xiang 0 siblings, 0 replies; 2+ messages in thread From: Gao Xiang @ 2026-09-11 10:28 UTC (permalink / raw) To: linux-erofs; +Cc: Gao Xiang Add metadata-only image support for compressed inode layouts, e.g.: $ mkfs.erofs -zlz4 --blobdev blob.erofs fsmeta.erofs foo/ Note that `-Efragments` and `-Ededupe` haven't supported yet. Follow-up: support rebuild mode for compressed inode layouts. Signed-off-by: Gao Xiang <xiang@kernel.org> --- include/erofs/dedupe.h | 1 + include/erofs/internal.h | 12 ++--- lib/compress.c | 94 ++++++++++++++++++++++++++++------------ lib/data.c | 16 +++++++ lib/inode.c | 5 ++- lib/super.c | 6 +-- lib/tar.c | 2 +- lib/xattr.c | 2 +- 8 files changed, 95 insertions(+), 43 deletions(-) diff --git a/include/erofs/dedupe.h b/include/erofs/dedupe.h index 267d9b9..14dd7dc 100644 --- a/include/erofs/dedupe.h +++ b/include/erofs/dedupe.h @@ -16,6 +16,7 @@ struct z_erofs_inmem_extent { erofs_off_t pstart; unsigned int plen; unsigned int length; + unsigned short device_id; bool raw, partial, inlined; }; diff --git a/include/erofs/internal.h b/include/erofs/internal.h index 0de71fb..3ca5553 100644 --- a/include/erofs/internal.h +++ b/include/erofs/internal.h @@ -513,6 +513,8 @@ static inline int erofs_get_occupied_size(const struct erofs_inode *inode, } /* data.c */ +int erofs_dev_write(struct erofs_sb_info *sbi, int device_id, + const void *buf, u64 offset, size_t len); int erofs_getxattr(struct erofs_inode *vi, const char *name, char *buffer, size_t buffer_size); int erofs_listxattr(struct erofs_inode *vi, char *buffer, size_t buffer_size); @@ -533,18 +535,10 @@ int erofs_blob_open_ro(struct erofs_sb_info *sbi, const char *dev); ssize_t erofs_dev_read(struct erofs_sb_info *sbi, int device_id, void *buf, u64 offset, size_t len); -static inline int erofs_dev_write(struct erofs_sb_info *sbi, const void *buf, - u64 offset, size_t len) -{ - if (erofs_io_pwrite(&sbi->bdev, buf, offset, len) != (ssize_t)len) - return -EIO; - return 0; -} - static inline int erofs_blk_write(struct erofs_sb_info *sbi, const void *buf, erofs_blk_t blkaddr, u32 nblocks) { - return erofs_dev_write(sbi, buf, erofs_pos(sbi, blkaddr), + return erofs_dev_write(sbi, 0, buf, erofs_pos(sbi, blkaddr), erofs_pos(sbi, nblocks)); } diff --git a/lib/compress.c b/lib/compress.c index 628d6f8..996b0c8 100644 --- a/lib/compress.c +++ b/lib/compress.c @@ -51,6 +51,7 @@ struct z_erofs_compress_ictx { /* inode context */ /* fields for write indexes */ u8 *metacur; struct list_head extents; + u16 device_id; u16 clusterofs; int seg_num; u32 max_compressed_extent_size; @@ -172,6 +173,7 @@ static void z_erofs_write_full_indexes(struct z_erofs_index_writer *ctx, unsigned int d0 = 0, d1 = (clusterofs + count) >> bbits; struct z_erofs_lcluster_index di; unsigned int type, advise; + erofs_blk_t blkaddr; DBG_BUGON(!count); DBG_BUGON(e->pstart & (BIT(bbits) - 1)); @@ -190,10 +192,14 @@ static void z_erofs_write_full_indexes(struct z_erofs_index_writer *ctx, Z_EROFS_LCLUSTER_TYPE_HEAD1; di.di_advise = cpu_to_le16(type); - if (inode->datalayout == EROFS_INODE_COMPRESSED_FULL && !e->plen) + if (inode->datalayout == EROFS_INODE_COMPRESSED_FULL && !e->plen) { di.di_u.blkaddr = cpu_to_le32(inode->fragmentoff >> 32); - else - di.di_u.blkaddr = cpu_to_le32(e->pstart >> bbits); + } else { + blkaddr = e->pstart >> bbits; + if (e->device_id) + blkaddr += sbi->devs[e->device_id - 1].uniaddr; + di.di_u.blkaddr = cpu_to_le32(blkaddr); + } memcpy(ctx->metacur, &di, sizeof(di)); ctx->metacur += sizeof(di); @@ -235,10 +241,14 @@ static void z_erofs_write_full_indexes(struct z_erofs_index_writer *ctx, Z_EROFS_LCLUSTER_TYPE_HEAD1; if (inode->datalayout == EROFS_INODE_COMPRESSED_FULL && - !e->plen) + !e->plen) { di.di_u.blkaddr = cpu_to_le32(inode->fragmentoff >> 32); - else - di.di_u.blkaddr = cpu_to_le32(e->pstart >> bbits); + } else { + blkaddr = e->pstart >> bbits; + if (e->device_id) + blkaddr += sbi->devs[e->device_id - 1].uniaddr; + di.di_u.blkaddr = cpu_to_le32(blkaddr); + } if (e->partial) { DBG_BUGON(e->raw); @@ -255,7 +265,7 @@ static void z_erofs_write_full_indexes(struct z_erofs_index_writer *ctx, ++d0; --d1; - } while (clusterofs + count >= 1 << bbits); + } while (clusterofs + count >= (1 << bbits)); ctx->clusterofs = clusterofs + count; } @@ -392,8 +402,10 @@ static int write_uncompressed_block(struct z_erofs_compress_sctx *ctx, { struct erofs_inode *inode = ctx->ictx->inode; struct erofs_sb_info *sbi = inode->sbi; - unsigned int count = min(erofs_blksiz(sbi), len); + unsigned int bs = erofs_blksiz(sbi); + unsigned int count = min(bs, len); unsigned int interlaced_offset, rightpart; + unsigned int device_id = ctx->ictx->device_id; int ret; /* write interlaced uncompressed data if needed */ @@ -401,9 +413,9 @@ static int write_uncompressed_block(struct z_erofs_compress_sctx *ctx, interlaced_offset = ctx->clusterofs; else interlaced_offset = 0; - rightpart = min(erofs_blksiz(sbi) - interlaced_offset, count); + rightpart = min(bs - interlaced_offset, count); - memset(dst, 0, erofs_blksiz(sbi)); + memset(dst, 0, bs); memcpy(dst + interlaced_offset, ctx->queue + ctx->head, rightpart); memcpy(dst, ctx->queue + ctx->head + rightpart, count - rightpart); @@ -411,15 +423,15 @@ static int write_uncompressed_block(struct z_erofs_compress_sctx *ctx, if (ctx->membuf) { erofs_dbg("Recording %u uncompressed data of %s", count, inode->i_srcpath); - memcpy(ctx->membuf + ctx->poff, dst, erofs_blksiz(sbi)); + memcpy(ctx->membuf + ctx->poff, dst, bs); } else { erofs_dbg("Writing %u uncompressed data to %llu", count, ctx->pstart | 0ULL); - ret = erofs_dev_write(sbi, dst, ctx->pstart, erofs_blksiz(sbi)); + ret = erofs_dev_write(sbi, device_id, dst, ctx->pstart, bs); if (ret) return ret; } - ctx->poff += erofs_blksiz(sbi); + ctx->poff += bs; return count; } @@ -452,6 +464,7 @@ static int write_uncompressed_extents(struct z_erofs_compress_sctx *ctx, .plen = round_up(count, erofs_blksiz(inode->sbi)), .raw = true, .pstart = ctx->pstart, + .device_id = ctx->ictx->device_id, }; if (ctx->pstart != EROFS_NULL_ADDR) ctx->pstart += ei->e.plen; @@ -584,6 +597,7 @@ static int __z_erofs_compress_one(struct z_erofs_compress_sctx *ctx, bool may_inline = (params->ztailpacking && !data_unaligned && tsg && final && !may_packing); unsigned int compressedsize; + int device_id = ictx->device_id; int ret; DBG_BUGON(ctx->pivot); @@ -734,8 +748,8 @@ frag_packing: erofs_dbg("Writing %u compressed data to %llu of %u bytes", e->length, ctx->pstart, e->plen); - ret = erofs_dev_write(sbi, dst - padding, ctx->pstart, - e->plen); + ret = erofs_dev_write(sbi, device_id, dst - padding, + ctx->pstart, e->plen); if (ret) return ret; } @@ -748,6 +762,8 @@ frag_packing: e->pstart = ctx->pstart; if (ctx->pstart != EROFS_NULL_ADDR) ctx->pstart += e->plen; + if (!e->inlined && e->plen) // TODO: !e->fragments + e->device_id = device_id; if (!may_inline && !may_packing && !is_packed_inode) (void)z_erofs_dedupe_insert(e, ctx->queue + ctx->head); ctx->head += e->length; @@ -1096,17 +1112,19 @@ static int z_erofs_prepare_layout(struct erofs_inode *inode, struct z_erofs_extent_item *ei; erofs_off_t pstart, pend; unsigned int recsz, moff; + int devid; ei = list_first_entry(&ctx->extents, struct z_erofs_extent_item, list); lclusterbits = max_t(u8, ilog2(ei->e.length - 1) + 1, sbi->blkszbits); pend = pstart = ei->e.pstart; + devid = ei->e.device_id; nexts = 0; list_for_each_entry(ei, &ctx->extents, list) { pstart_hi |= (ei->e.pstart > UINT32_MAX); if ((ei->e.pstart | ei->e.plen) & ((1U << sbi->blkszbits) - 1)) unaligned_data = true; - if (pend != ei->e.pstart) + if (pend != ei->e.pstart || devid != ei->e.device_id) pend = EROFS_NULL_ADDR; else pend += ei->e.plen; @@ -1181,11 +1199,13 @@ static void z_erofs_write_extents(struct erofs_inode *inode, struct list_head *extents, u8 *metabuf) { unsigned int recsz = z_erofs_extent_recsize(inode->z_advise); + struct erofs_sb_info *sbi = inode->sbi; struct z_erofs_extent_item *ei, *n; erofs_off_t pstart, lstart; unsigned int moff; u8 *metacur; u64 nexts; + int devid; moff = Z_EROFS_MAP_HEADER_END(inode->inode_isize + inode->xattr_isize); moff = round_up(moff, recsz) - @@ -1194,6 +1214,10 @@ static void z_erofs_write_extents(struct erofs_inode *inode, if (recsz <= 4) { ei = list_first_entry(extents, struct z_erofs_extent_item, list); pstart = ei->e.pstart; + devid = ei->e.device_id; + if (devid) + pstart += (erofs_off_t)sbi->devs[devid - 1].uniaddr + << sbi->blkszbits; *(__le64 *)metacur = cpu_to_le64(pstart); metacur += sizeof(__le64); } @@ -1207,18 +1231,23 @@ static void z_erofs_write_extents(struct erofs_inode *inode, plen = ei->e.plen; if (!plen) { plen = inode->fragmentoff; - ei->e.pstart = inode->fragmentoff >> 32; + pstart = inode->fragmentoff >> 32; } else { fmt = ei->e.raw ? 0 : inode->z_algorithmtype[0] + 1; plen |= fmt << Z_EROFS_EXTENT_PLEN_FMT_BIT; if (ei->e.partial) plen |= Z_EROFS_EXTENT_PLEN_PARTIAL; + pstart = ei->e.pstart; + devid = ei->e.device_id; + if (devid) + pstart += (erofs_off_t)sbi->devs[devid - 1].uniaddr + << sbi->blkszbits; } de = (struct z_erofs_extent) { .plen = cpu_to_le32(plen), - .pstart_lo = cpu_to_le32(ei->e.pstart), + .pstart_lo = cpu_to_le32(pstart), .lstart_lo = cpu_to_le32(lstart), - .pstart_hi = cpu_to_le32(ei->e.pstart >> 32), + .pstart_hi = cpu_to_le32(pstart >> 32), .lstart_hi = cpu_to_le32(lstart >> 32), }; memcpy(metacur, &de, recsz); @@ -1469,6 +1498,8 @@ char *z_erofs_write_metadata(struct erofs_inode *inode) DBG_BUGON(list_empty(&mctx->extents)); ei = list_first_entry(&mctx->extents, struct z_erofs_extent_item, list); pstart = ei->e.pstart; + if (ei->e.device_id) + pstart += sbi->devs[ei->e.device_id - 1].uniaddr << sbi->blkszbits; list_for_each_entry_safe(ei, n, &mctx->extents, list) { DBG_BUGON(ei->list.next != &mctx->extents && @@ -1665,8 +1696,8 @@ int z_erofs_merge_segment(struct z_erofs_compress_ictx *ictx, } erofs_dbg("Writing %u %scompressed data of %s to %llu", ei->e.length, ei->e.raw ? "un" : "", ictx->inode->i_srcpath, ei->e.pstart); - ret2 = erofs_dev_write(sbi, sctx->membuf + off, ei->e.pstart, - ei->e.plen); + ret2 = erofs_dev_write(sbi, ei->e.device_id, sctx->membuf + off, + ei->e.pstart, ei->e.plen); off += ei->e.plen; if (ret2) ret = ret2; @@ -1759,9 +1790,11 @@ int erofs_mt_write_compressed_file(struct z_erofs_compress_ictx *ictx) struct erofs_buffer_head *bh = NULL; struct erofs_compress_work *head = ictx->mtworks, *cur; erofs_off_t pstart, ptotal = 0; + struct erofs_bufmgr *bmgr = ictx->device_id ? + sbi->devs[ictx->device_id - 1].bmgr : sbi->bmgr; int ret; - bh = erofs_balloc(sbi->bmgr, DATA, 0, 0); + bh = erofs_balloc(bmgr, DATA, 0, 0); if (IS_ERR(bh)) { ret = PTR_ERR(bh); goto out; @@ -1918,6 +1951,11 @@ void *erofs_prepare_compressed_file(struct erofs_importer *im, } ictx->im = im; ictx->inode = inode; + ictx->device_id = !params->fragments && !params->dedupe && + !erofs_is_packed_inode(inode) && + !erofs_is_metabox_inode(inode) && + params->ddev_id_def && S_ISREG(inode->i_mode) ? + params->ddev_id_def : 0; if (erofs_is_metabox_inode(inode)) ictx->ccfg = &sbi->zmgr->ccfg[cfg.c_mkfs_metabox_algid]; else @@ -2049,6 +2087,8 @@ int erofs_write_compressed_file(struct z_erofs_compress_ictx *ictx) struct erofs_compress_cfg *ccfg = ictx->ccfg; struct erofs_inode *inode = ictx->inode; struct erofs_sb_info *sbi = inode->sbi; + struct erofs_bufmgr *bmgr = ictx->device_id ? + sbi->devs[ictx->device_id - 1].bmgr : sbi->bmgr; erofs_off_t pstart; int ret; @@ -2058,7 +2098,7 @@ int erofs_write_compressed_file(struct z_erofs_compress_ictx *ictx) #endif /* allocate main data buffer */ - bh = erofs_balloc(inode->sbi->bmgr, DATA, 0, 0); + bh = erofs_balloc(bmgr, DATA, 0, 0); if (IS_ERR(bh)) { ret = PTR_ERR(bh); goto err_free_idata; @@ -2169,7 +2209,7 @@ static int z_erofs_build_compr_cfgs(struct erofs_importer *im, return PTR_ERR(bh); } erofs_mapbh(NULL, bh->block); - ret = erofs_dev_write(sbi, &lz4alg, erofs_btell(bh, false), + ret = erofs_dev_write(sbi, 0, &lz4alg, erofs_btell(bh, false), sizeof(lz4alg)); bh->op = &erofs_drop_directly_bhops; } @@ -2193,7 +2233,7 @@ static int z_erofs_build_compr_cfgs(struct erofs_importer *im, return PTR_ERR(bh); } erofs_mapbh(NULL, bh->block); - ret = erofs_dev_write(sbi, &lzmaalg, erofs_btell(bh, false), + ret = erofs_dev_write(sbi, 0, &lzmaalg, erofs_btell(bh, false), sizeof(lzmaalg)); bh->op = &erofs_drop_directly_bhops; } @@ -2217,7 +2257,7 @@ static int z_erofs_build_compr_cfgs(struct erofs_importer *im, return PTR_ERR(bh); } erofs_mapbh(NULL, bh->block); - ret = erofs_dev_write(sbi, &zalg, erofs_btell(bh, false), + ret = erofs_dev_write(sbi, 0, &zalg, erofs_btell(bh, false), sizeof(zalg)); bh->op = &erofs_drop_directly_bhops; } @@ -2240,7 +2280,7 @@ static int z_erofs_build_compr_cfgs(struct erofs_importer *im, return PTR_ERR(bh); } erofs_mapbh(NULL, bh->block); - ret = erofs_dev_write(sbi, &zalg, erofs_btell(bh, false), + ret = erofs_dev_write(sbi, 0, &zalg, erofs_btell(bh, false), sizeof(zalg)); bh->op = &erofs_drop_directly_bhops; } diff --git a/lib/data.c b/lib/data.c index fa2907b..c73cbe3 100644 --- a/lib/data.c +++ b/lib/data.c @@ -8,8 +8,24 @@ #include "erofs/internal.h" #include "erofs/trace.h" #include "erofs/decompress.h" +#include "liberofs_cache.h" #include "liberofs_fragments.h" +int erofs_dev_write(struct erofs_sb_info *sbi, int device_id, + const void *buf, u64 offset, size_t len) +{ + ssize_t ret; + + ret = erofs_io_pwrite(device_id ? + sbi->devs[device_id - 1].bmgr->vf : &sbi->bdev, + buf, offset, len); + if (ret < 0) + return ret; + if (ret != (ssize_t)len) + return -EIO; + return 0; +} + void *erofs_bread(struct erofs_buf *buf, erofs_off_t offset, bool need_kmap) { struct erofs_sb_info *sbi = buf->sbi; diff --git a/lib/inode.c b/lib/inode.c index 6f3748a..62958d1 100644 --- a/lib/inode.c +++ b/lib/inode.c @@ -511,7 +511,7 @@ static int erofs_rebuild_inode_fix_pnid(struct erofs_inode *parent, if (!fixed) continue; - err = erofs_dev_write(dir.sbi, buf, + err = erofs_dev_write(dir.sbi, 0, buf, (off + bsz > dir.i_size && dir.datalayout == EROFS_INODE_FLAT_INLINE ? erofs_iloc(&dir) + isz : boff + off), count); @@ -2488,7 +2488,8 @@ int erofs_fixup_root_inode(struct erofs_inode *root) return -ENOMEM; err = erofs_dev_read(sbi, 0, ibuf, erofs_iloc(root), ondisk_size); if (err >= 0) - err = erofs_dev_write(sbi, ibuf, erofs_iloc(&oi), ondisk_size); + err = erofs_dev_write(sbi, 0, ibuf, erofs_iloc(&oi), + ondisk_size); free(ibuf); return err; } diff --git a/lib/super.c b/lib/super.c index 1358101..71b9f4f 100644 --- a/lib/super.c +++ b/lib/super.c @@ -270,7 +270,7 @@ int erofs_writesb(struct erofs_sb_info *sbi) } memcpy(buf + EROFS_SUPER_OFFSET, &sb, sbi->sb_size); - ret = erofs_dev_write(sbi, buf, sb_bh ? erofs_btell(sb_bh, false) : 0, + ret = erofs_dev_write(sbi, 0, buf, sb_bh ? erofs_btell(sb_bh, false) : 0, EROFS_SUPER_OFFSET + sbi->sb_size); free(buf); if (sb_bh) @@ -352,7 +352,7 @@ int erofs_enable_sb_chksum(struct erofs_sb_info *sbi, u32 *crc) /* set up checksum field to erofs_super_block */ sb->checksum = cpu_to_le32(*crc); - ret = erofs_dev_write(sbi, buf, EROFS_SUPER_OFFSET, len); + ret = erofs_dev_write(sbi, 0, buf, EROFS_SUPER_OFFSET, len); if (ret) { erofs_err("failed to write checksummed superblock: %s", erofs_strerror(ret)); @@ -460,7 +460,7 @@ int erofs_write_device_table(struct erofs_sb_info *sbi) }; memcpy(dis.tag, di->tag, sizeof(dis.tag)); - ret = erofs_dev_write(sbi, &dis, pos, sizeof(dis)); + ret = erofs_dev_write(sbi, 0, &dis, pos, sizeof(dis)); if (ret) return ret; pos += sizeof(dis); diff --git a/lib/tar.c b/lib/tar.c index f027532..f24ad95 100644 --- a/lib/tar.c +++ b/lib/tar.c @@ -705,7 +705,7 @@ static int tarerofs_write_uncompressed_file(struct erofs_inode *inode, ret = -EIO; break; } - if (erofs_dev_write(sbi, buf, + if (erofs_dev_write(sbi, 0, buf, erofs_pos(sbi, inode->u.i_blkaddr) + pos, ret)) { ret = -EIO; diff --git a/lib/xattr.c b/lib/xattr.c index af45075..3cf8c79 100644 --- a/lib/xattr.c +++ b/lib/xattr.c @@ -1055,7 +1055,7 @@ int erofs_load_shared_xattrs_from_path(struct erofs_sb_info *sbi, const char *pa xamgr->shared_xattrs = sorted_n[0]; free(sorted_n); bh->op = &erofs_drop_directly_bhops; - ret = erofs_dev_write(sbi, buf, erofs_btell(bh, false), shared_xattrs_size); + ret = erofs_dev_write(sbi, 0, buf, erofs_btell(bh, false), shared_xattrs_size); free(buf); erofs_bdrop(bh, false); return ret; -- 2.47.3 ^ permalink raw reply related [flat|nested] 2+ messages in thread
end of thread, other threads:[~2026-09-11 10:30 UTC | newest] Thread overview: 2+ messages (download: mbox.gz follow: Atom feed -- links below jump to the message on this page -- 2026-09-11 10:28 [PATCH v3 1/2] erofs-utils: mkfs: defer compressed metadata generation Gao Xiang 2026-09-11 10:28 ` [PATCH v3 2/2] erofs-utils: mkfs: enable `--blobdev` for compressed inode layouts Gao Xiang
This is a public inbox, see mirroring instructions for how to clone and mirror all data and code used for this inbox