Merge tag 'erofs-for-5.15-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/xiang/erofs (412106c2) · Commits · EulixOS / Software / Kernel

Documentation/filesystems/erofs.rst

+17 −2

Original line number	Diff line number	Diff line
		@@ -84,6 +84,9 @@ cache_strategy=%s Select a strategy for cached decompression from now on:
		It still does in-place I/O decompression
		for the rest compressed physical clusters.
		========== =============================================
		dax={always,never} Use direct access (no page cache). See
		Documentation/filesystems/dax.rst.
		dax A legacy option which is an alias for ``dax=always``.
		=================== =========================================================

		On-disk details
		@@ -153,13 +156,14 @@ may not. All metadatas can be now observed in two different spaces (views):

		Xattrs, extents, data inline are followed by the corresponding inode with
		proper alignment, and they could be optional for different data mappings.
		_currently_ total 4 valid data mappings are supported:
		_currently_ total 5 data layouts are supported:

		== ====================================================================
		0 flat file data without data inline (no extent);
		1 fixed-sized output data compression (with non-compacted indexes);
		2 flat file data with tail packing data inline (no extent);
		3 fixed-sized output data compression (with compacted indexes, v5.3+).
		3 fixed-sized output data compression (with compacted indexes, v5.3+);
		4 chunk-based file (v5.15+).
		== ====================================================================

		The size of the optional xattrs is indicated by i_xattr_count in inode
		@@ -210,6 +214,17 @@ Note that apart from the offset of the first filename, nameoff0 also indicates
		the total number of directory entries in this block since it is no need to
		introduce another on-disk field at all.

		Chunk-based file
		----------------
		In order to support chunk-based data deduplication, a new inode data layout has
		been supported since Linux v5.15: Files are split in equal-sized data chunks
		with ``extents`` area of the inode metadata indicating how to get the chunk
		data: these can be simply as a 4-byte block address array or in the 8-byte
		chunk index form (see struct erofs_inode_chunk_index in erofs_fs.h for more
		details.)

		By the way, chunk-based files are all uncompressed for now.

		Data compression
		----------------
		EROFS implements LZ4 fixed-sized output compression which generates fixed-sized

fs/erofs/Kconfig

+1 −0

Original line number	Diff line number	Diff line
		@@ -3,6 +3,7 @@
		config EROFS_FS
		tristate "EROFS filesystem support"
		depends on BLOCK
		select FS_IOMAP
		select LIBCRC32C
		help
		EROFS (Enhanced Read-Only File System) is a lightweight

fs/erofs/data.c

+221 −194

Original line number	Diff line number	Diff line
		@@ -2,35 +2,13 @@
		/*
		* Copyright (C) 2017-2018 HUAWEI, Inc.
		* https://www.huawei.com/
		* Copyright (C) 2021, Alibaba Cloud
		*/
		#include "internal.h"
		#include <linux/prefetch.h>

		#include <linux/dax.h>
		#include <trace/events/erofs.h>

		static void erofs_readendio(struct bio *bio)
		{
		struct bio_vec *bvec;
		blk_status_t err = bio->bi_status;
		struct bvec_iter_all iter_all;

		bio_for_each_segment_all(bvec, bio, iter_all) {
		struct page *page = bvec->bv_page;

		/* page is already locked */
		DBG_BUGON(PageUptodate(page));

		if (err)
		SetPageError(page);
		else
		SetPageUptodate(page);

		unlock_page(page);
		/* page could be reclaimed now */
		}
		bio_put(bio);
		}

		struct page erofs_get_meta_page(struct super_block sb, erofs_blk_t blkaddr)
		{
		struct address_space *const mapping = sb->s_bdev->bd_inode->i_mapping;
		@@ -59,13 +37,6 @@ static int erofs_map_blocks_flatmode(struct inode *inode,
		nblocks = DIV_ROUND_UP(inode->i_size, PAGE_SIZE);
		lastblk = nblocks - tailendpacking;

		if (offset >= inode->i_size) {
		/* leave out-of-bound access unmapped */
		map->m_flags = 0;
		map->m_plen = 0;
		goto out;
		}

		/* there is no hole in flatmode */
		map->m_flags = EROFS_MAP_MAPPED;

		@@ -100,217 +71,273 @@ static int erofs_map_blocks_flatmode(struct inode *inode,
		goto err_out;
		}

		out:
		map->m_llen = map->m_plen;

		err_out:
		trace_erofs_map_blocks_flatmode_exit(inode, map, flags, 0);
		return err;
		}

		static inline struct bio erofs_read_raw_page(struct bio bio,
		struct address_space *mapping,
		struct page *page,
		erofs_off_t *last_block,
		unsigned int nblocks,
		unsigned int *eblks,
		bool ra)
		static int erofs_map_blocks(struct inode *inode,
		struct erofs_map_blocks *map, int flags)
		{
		struct inode *const inode = mapping->host;
		struct super_block *const sb = inode->i_sb;
		erofs_off_t current_block = (erofs_off_t)page->index;
		int err;

		DBG_BUGON(!nblocks);
		struct super_block *sb = inode->i_sb;
		struct erofs_inode *vi = EROFS_I(inode);
		struct erofs_inode_chunk_index *idx;
		struct page *page;
		u64 chunknr;
		unsigned int unit;
		erofs_off_t pos;
		int err = 0;

		if (PageUptodate(page)) {
		err = 0;
		goto has_updated;
		if (map->m_la >= inode->i_size) {
		/* leave out-of-bound access unmapped */
		map->m_flags = 0;
		map->m_plen = 0;
		goto out;
		}

		/* note that for readpage case, bio also equals to NULL */
		if (bio &&
		(last_block + 1 != current_block \|\| !eblks)) {
		submit_bio_retry:
		submit_bio(bio);
		bio = NULL;
		}
		if (vi->datalayout != EROFS_INODE_CHUNK_BASED)
		return erofs_map_blocks_flatmode(inode, map, flags);

		if (!bio) {
		struct erofs_map_blocks map = {
		.m_la = blknr_to_addr(current_block),
		};
		erofs_blk_t blknr;
		unsigned int blkoff;
		if (vi->chunkformat & EROFS_CHUNK_FORMAT_INDEXES)
		unit = sizeof(idx); / chunk index */
		else
		unit = EROFS_BLOCK_MAP_ENTRY_SIZE; /* block map */

		err = erofs_map_blocks_flatmode(inode, &map, EROFS_GET_BLOCKS_RAW);
		if (err)
		goto err_out;
		chunknr = map->m_la >> vi->chunkbits;
		pos = ALIGN(iloc(EROFS_SB(sb), vi->nid) + vi->inode_isize +
		vi->xattr_isize, unit) + unit * chunknr;

		/* zero out the holed page */
		if (!(map.m_flags & EROFS_MAP_MAPPED)) {
		zero_user_segment(page, 0, PAGE_SIZE);
		SetPageUptodate(page);
		page = erofs_get_meta_page(inode->i_sb, erofs_blknr(pos));
		if (IS_ERR(page))
		return PTR_ERR(page);

		map->m_la = chunknr << vi->chunkbits;
		map->m_plen = min_t(erofs_off_t, 1UL << vi->chunkbits,
		roundup(inode->i_size - map->m_la, EROFS_BLKSIZ));

		/* handle block map */
		if (!(vi->chunkformat & EROFS_CHUNK_FORMAT_INDEXES)) {
		__le32 *blkaddr = page_address(page) + erofs_blkoff(pos);

		/* imply err = 0, see erofs_map_blocks */
		goto has_updated;
		if (le32_to_cpu(*blkaddr) == EROFS_NULL_ADDR) {
		map->m_flags = 0;
		} else {
		map->m_pa = blknr_to_addr(le32_to_cpu(*blkaddr));
		map->m_flags = EROFS_MAP_MAPPED;
		}
		goto out_unlock;
		}
		/* parse chunk indexes */
		idx = page_address(page) + erofs_blkoff(pos);
		switch (le32_to_cpu(idx->blkaddr)) {
		case EROFS_NULL_ADDR:
		map->m_flags = 0;
		break;
		default:
		/* only one device is supported for now */
		if (idx->device_id) {
		erofs_err(sb, "invalid device id %u @ %llu for nid %llu",
		le16_to_cpu(idx->device_id),
		chunknr, vi->nid);
		err = -EFSCORRUPTED;
		goto out_unlock;
		}
		map->m_pa = blknr_to_addr(le32_to_cpu(idx->blkaddr));
		map->m_flags = EROFS_MAP_MAPPED;
		break;
		}
		out_unlock:
		unlock_page(page);
		put_page(page);
		out:
		map->m_llen = map->m_plen;
		return err;
		}

		/* for RAW access mode, m_plen must be equal to m_llen */
		DBG_BUGON(map.m_plen != map.m_llen);
		static int erofs_iomap_begin(struct inode *inode, loff_t offset, loff_t length,
		unsigned int flags, struct iomap iomap, struct iomap srcmap)
		{
		int ret;
		struct erofs_map_blocks map;

		blknr = erofs_blknr(map.m_pa);
		blkoff = erofs_blkoff(map.m_pa);
		map.m_la = offset;
		map.m_llen = length;

		/* deal with inline page */
		if (map.m_flags & EROFS_MAP_META) {
		void vsrc, vto;
		struct page *ipage;
		ret = erofs_map_blocks(inode, &map, EROFS_GET_BLOCKS_RAW);
		if (ret < 0)
		return ret;

		iomap->bdev = inode->i_sb->s_bdev;
		iomap->dax_dev = EROFS_I_SB(inode)->dax_dev;
		iomap->offset = map.m_la;
		iomap->length = map.m_llen;
		iomap->flags = 0;
		iomap->private = NULL;

		DBG_BUGON(map.m_plen > PAGE_SIZE);
		if (!(map.m_flags & EROFS_MAP_MAPPED)) {
		iomap->type = IOMAP_HOLE;
		iomap->addr = IOMAP_NULL_ADDR;
		if (!iomap->length)
		iomap->length = length;
		return 0;
		}

		ipage = erofs_get_meta_page(inode->i_sb, blknr);
		if (map.m_flags & EROFS_MAP_META) {
		struct page *ipage;

		if (IS_ERR(ipage)) {
		err = PTR_ERR(ipage);
		goto err_out;
		iomap->type = IOMAP_INLINE;
		ipage = erofs_get_meta_page(inode->i_sb,
		erofs_blknr(map.m_pa));
		if (IS_ERR(ipage))
		return PTR_ERR(ipage);
		iomap->inline_data = page_address(ipage) +
		erofs_blkoff(map.m_pa);
		iomap->private = ipage;
		} else {
		iomap->type = IOMAP_MAPPED;
		iomap->addr = map.m_pa;
		}
		return 0;
		}

		vsrc = kmap_atomic(ipage);
		vto = kmap_atomic(page);
		memcpy(vto, vsrc + blkoff, map.m_plen);
		memset(vto + map.m_plen, 0, PAGE_SIZE - map.m_plen);
		kunmap_atomic(vto);
		kunmap_atomic(vsrc);
		flush_dcache_page(page);
		static int erofs_iomap_end(struct inode *inode, loff_t pos, loff_t length,
		ssize_t written, unsigned int flags, struct iomap *iomap)
		{
		struct page *ipage = iomap->private;

		SetPageUptodate(page);
		/* TODO: could we unlock the page earlier? */
		if (ipage) {
		DBG_BUGON(iomap->type != IOMAP_INLINE);
		unlock_page(ipage);
		put_page(ipage);

		/* imply err = 0, see erofs_map_blocks */
		goto has_updated;
		} else {
		DBG_BUGON(iomap->type == IOMAP_INLINE);
		}

		/* pa must be block-aligned for raw reading */
		DBG_BUGON(erofs_blkoff(map.m_pa));

		/* max # of continuous pages */
		if (nblocks > DIV_ROUND_UP(map.m_plen, PAGE_SIZE))
		nblocks = DIV_ROUND_UP(map.m_plen, PAGE_SIZE);

		*eblks = bio_max_segs(nblocks);
		bio = bio_alloc(GFP_NOIO, *eblks);

		bio->bi_end_io = erofs_readendio;
		bio_set_dev(bio, sb->s_bdev);
		bio->bi_iter.bi_sector = (sector_t)blknr <<
		LOG_SECTORS_PER_BLOCK;
		bio->bi_opf = REQ_OP_READ \| (ra ? REQ_RAHEAD : 0);
		return written;
		}

		err = bio_add_page(bio, page, PAGE_SIZE, 0);
		/* out of the extent or bio is full */
		if (err < PAGE_SIZE)
		goto submit_bio_retry;
		--*eblks;
		*last_block = current_block;
		return bio;
		static const struct iomap_ops erofs_iomap_ops = {
		.iomap_begin = erofs_iomap_begin,
		.iomap_end = erofs_iomap_end,
		};

		err_out:
		/* for sync reading, set page error immediately */
		if (!ra) {
		SetPageError(page);
		ClearPageUptodate(page);
		int erofs_fiemap(struct inode inode, struct fiemap_extent_info fieinfo,
		u64 start, u64 len)
		{
		if (erofs_inode_is_data_compressed(EROFS_I(inode)->datalayout)) {
		#ifdef CONFIG_EROFS_FS_ZIP
		return iomap_fiemap(inode, fieinfo, start, len,
		&z_erofs_iomap_report_ops);
		#else
		return -EOPNOTSUPP;
		#endif
		}
		has_updated:
		unlock_page(page);

		/* if updated manually, continuous pages has a gap */
		if (bio)
		submit_bio(bio);
		return err ? ERR_PTR(err) : NULL;
		return iomap_fiemap(inode, fieinfo, start, len, &erofs_iomap_ops);
		}

		/*
		* since we dont have write or truncate flows, so no inode
		* locking needs to be held at the moment.
		*/
		static int erofs_raw_access_readpage(struct file file, struct page page)
		static int erofs_readpage(struct file file, struct page page)
		{
		erofs_off_t last_block;
		unsigned int eblks;
		struct bio *bio;
		return iomap_readpage(page, &erofs_iomap_ops);
		}

		trace_erofs_readpage(page, true);
		static void erofs_readahead(struct readahead_control *rac)
		{
		return iomap_readahead(rac, &erofs_iomap_ops);
		}

		bio = erofs_read_raw_page(NULL, page->mapping,
		page, &last_block, 1, &eblks, false);
		static sector_t erofs_bmap(struct address_space *mapping, sector_t block)
		{
		return iomap_bmap(mapping, block, &erofs_iomap_ops);
		}

		if (IS_ERR(bio))
		return PTR_ERR(bio);
		static int erofs_prepare_dio(struct kiocb iocb, struct iov_iter to)
		{
		struct inode *inode = file_inode(iocb->ki_filp);
		loff_t align = iocb->ki_pos \| iov_iter_count(to) \|
		iov_iter_alignment(to);
		struct block_device *bdev = inode->i_sb->s_bdev;
		unsigned int blksize_mask;

		if (bdev)
		blksize_mask = (1 << ilog2(bdev_logical_block_size(bdev))) - 1;
		else
		blksize_mask = (1 << inode->i_blkbits) - 1;

		if (bio)
		submit_bio(bio);
		if (align & blksize_mask)
		return -EINVAL;
		return 0;
		}

		static void erofs_raw_access_readahead(struct readahead_control *rac)
		static ssize_t erofs_file_read_iter(struct kiocb iocb, struct iov_iter to)
		{
		erofs_off_t last_block;
		unsigned int eblks;
		struct bio *bio = NULL;
		struct page *page;

		trace_erofs_readpages(rac->mapping->host, readahead_index(rac),
		readahead_count(rac), true);

		while ((page = readahead_page(rac))) {
		prefetchw(&page->flags);

		bio = erofs_read_raw_page(bio, rac->mapping, page, &last_block,
		readahead_count(rac), &eblks, true);

		/* all the page errors are ignored when readahead */
		if (IS_ERR(bio)) {
		pr_err("%s, readahead error at page %lu of nid %llu\n",
		__func__, page->index,
		EROFS_I(rac->mapping->host)->nid);
		/* no need taking (shared) inode lock since it's a ro filesystem */
		if (!iov_iter_count(to))
		return 0;

		bio = NULL;
		#ifdef CONFIG_FS_DAX
		if (IS_DAX(iocb->ki_filp->f_mapping->host))
		return dax_iomap_rw(iocb, to, &erofs_iomap_ops);
		#endif
		if (iocb->ki_flags & IOCB_DIRECT) {
		int err = erofs_prepare_dio(iocb, to);

		if (!err)
		return iomap_dio_rw(iocb, to, &erofs_iomap_ops,
		NULL, 0);
		if (err < 0)
		return err;
		}

		put_page(page);
		return filemap_read(iocb, to, 0);
		}

		if (bio)
		submit_bio(bio);
		/* for uncompressed (aligned) files and raw access for other files */
		const struct address_space_operations erofs_raw_access_aops = {
		.readpage = erofs_readpage,
		.readahead = erofs_readahead,
		.bmap = erofs_bmap,
		.direct_IO = noop_direct_IO,
		};

		#ifdef CONFIG_FS_DAX
		static vm_fault_t erofs_dax_huge_fault(struct vm_fault *vmf,
		enum page_entry_size pe_size)
		{
		return dax_iomap_fault(vmf, pe_size, NULL, NULL, &erofs_iomap_ops);
		}

		static sector_t erofs_bmap(struct address_space *mapping, sector_t block)
		static vm_fault_t erofs_dax_fault(struct vm_fault *vmf)
		{
		struct inode *inode = mapping->host;
		struct erofs_map_blocks map = {
		.m_la = blknr_to_addr(block),
		};
		return erofs_dax_huge_fault(vmf, PE_SIZE_PTE);
		}

		if (EROFS_I(inode)->datalayout == EROFS_INODE_FLAT_INLINE) {
		erofs_blk_t blks = i_size_read(inode) >> LOG_BLOCK_SIZE;
		static const struct vm_operations_struct erofs_dax_vm_ops = {
		.fault = erofs_dax_fault,
		.huge_fault = erofs_dax_huge_fault,
		};

		if (block >> LOG_SECTORS_PER_BLOCK >= blks)
		return 0;
		}
		static int erofs_file_mmap(struct file file, struct vm_area_struct vma)
		{
		if (!IS_DAX(file_inode(file)))
		return generic_file_readonly_mmap(file, vma);

		if (!erofs_map_blocks_flatmode(inode, &map, EROFS_GET_BLOCKS_RAW))
		return erofs_blknr(map.m_pa);
		if ((vma->vm_flags & VM_SHARED) && (vma->vm_flags & VM_MAYWRITE))
		return -EINVAL;

		vma->vm_ops = &erofs_dax_vm_ops;
		vma->vm_flags \|= VM_HUGEPAGE;
		return 0;
		}

		/* for uncompressed (aligned) files and raw access for other files */
		const struct address_space_operations erofs_raw_access_aops = {
		.readpage = erofs_raw_access_readpage,
		.readahead = erofs_raw_access_readahead,
		.bmap = erofs_bmap,
		#else
		#define erofs_file_mmap generic_file_readonly_mmap
		#endif

		const struct file_operations erofs_file_fops = {
		.llseek = generic_file_llseek,
		.read_iter = erofs_file_read_iter,
		.mmap = erofs_file_mmap,
		.splice_read = generic_file_splice_read,
		};

fs/erofs/erofs_fs.h

+45 −2

Original line number	Diff line number	Diff line
		@@ -4,6 +4,7 @@
		*
		* Copyright (C) 2017-2018 HUAWEI, Inc.
		* https://www.huawei.com/
		* Copyright (C) 2021, Alibaba Cloud
		*/
		#ifndef __EROFS_FS_H
		#define __EROFS_FS_H
		@@ -19,10 +20,12 @@
		#define EROFS_FEATURE_INCOMPAT_LZ4_0PADDING 0x00000001
		#define EROFS_FEATURE_INCOMPAT_COMPR_CFGS 0x00000002
		#define EROFS_FEATURE_INCOMPAT_BIG_PCLUSTER 0x00000002
		#define EROFS_FEATURE_INCOMPAT_CHUNKED_FILE 0x00000004
		#define EROFS_ALL_FEATURE_INCOMPAT \
		(EROFS_FEATURE_INCOMPAT_LZ4_0PADDING \| \
		EROFS_FEATURE_INCOMPAT_COMPR_CFGS \| \
		EROFS_FEATURE_INCOMPAT_BIG_PCLUSTER)
		EROFS_FEATURE_INCOMPAT_BIG_PCLUSTER \| \
		EROFS_FEATURE_INCOMPAT_CHUNKED_FILE)

		#define EROFS_SB_EXTSLOT_SIZE 16

		@@ -64,13 +67,16 @@ struct erofs_super_block {
		* inode, [xattrs], last_inline_data, ... \| ... \| no-holed data
		* 3 - inode compression D:
		* inode, [xattrs], map_header, extents ... \| ...
		* 4~7 - reserved
		* 4 - inode chunk-based E:
		* inode, [xattrs], chunk indexes ... \| ...
		* 5~7 - reserved
		*/
		enum {
		EROFS_INODE_FLAT_PLAIN = 0,
		EROFS_INODE_FLAT_COMPRESSION_LEGACY = 1,
		EROFS_INODE_FLAT_INLINE = 2,
		EROFS_INODE_FLAT_COMPRESSION = 3,
		EROFS_INODE_CHUNK_BASED = 4,
		EROFS_INODE_DATALAYOUT_MAX
		};

		@@ -90,6 +96,19 @@ static inline bool erofs_inode_is_data_compressed(unsigned int datamode)
		#define EROFS_I_ALL \
		((1 << (EROFS_I_DATALAYOUT_BIT + EROFS_I_DATALAYOUT_BITS)) - 1)

		/* indicate chunk blkbits, thus 'chunksize = blocksize << chunk blkbits' */
		#define EROFS_CHUNK_FORMAT_BLKBITS_MASK 0x001F
		/* with chunk indexes or just a 4-byte blkaddr array */
		#define EROFS_CHUNK_FORMAT_INDEXES 0x0020

		#define EROFS_CHUNK_FORMAT_ALL \
		(EROFS_CHUNK_FORMAT_BLKBITS_MASK \| EROFS_CHUNK_FORMAT_INDEXES)

		struct erofs_inode_chunk_info {
		__le16 format; /* chunk blkbits, etc. */
		__le16 reserved;
		};

		/* 32-byte reduced form of an ondisk inode */
		struct erofs_inode_compact {
		__le16 i_format; /* inode format hints */
		@@ -107,6 +126,9 @@ struct erofs_inode_compact {

		/* for device files, used to indicate old/new device # */
		__le32 rdev;

		/* for chunk-based files, it contains the summary info */
		struct erofs_inode_chunk_info c;
		} i_u;
		__le32 i_ino; /* only used for 32-bit stat compatibility */
		__le16 i_uid;
		@@ -135,6 +157,9 @@ struct erofs_inode_extended {

		/* for device files, used to indicate old/new device # */
		__le32 rdev;

		/* for chunk-based files, it contains the summary info */
		struct erofs_inode_chunk_info c;
		} i_u;

		/* only used for 32-bit stat compatibility */
		@@ -204,6 +229,19 @@ static inline unsigned int erofs_xattr_entry_size(struct erofs_xattr_entry *e)
		e->e_name_len + le16_to_cpu(e->e_value_size));
		}

		/* represent a zeroed chunk (hole) */
		#define EROFS_NULL_ADDR -1

		/* 4-byte block address array */
		#define EROFS_BLOCK_MAP_ENTRY_SIZE sizeof(__le32)

		/* 8-byte inode chunk indexes */
		struct erofs_inode_chunk_index {
		__le16 advise; /* always 0, don't care for now */
		__le16 device_id; /* back-end storage id, always 0 for now */
		__le32 blkaddr; /* start block address of this inode chunk */
		};

		/* maximum supported size of a physical compression cluster */
		#define Z_EROFS_PCLUSTER_MAX_SIZE (1024 * 1024)

		@@ -338,9 +376,14 @@ static inline void erofs_check_ondisk_layout_definitions(void)
		BUILD_BUG_ON(sizeof(struct erofs_inode_extended) != 64);
		BUILD_BUG_ON(sizeof(struct erofs_xattr_ibody_header) != 12);
		BUILD_BUG_ON(sizeof(struct erofs_xattr_entry) != 4);
		BUILD_BUG_ON(sizeof(struct erofs_inode_chunk_info) != 4);
		BUILD_BUG_ON(sizeof(struct erofs_inode_chunk_index) != 8);
		BUILD_BUG_ON(sizeof(struct z_erofs_map_header) != 8);
		BUILD_BUG_ON(sizeof(struct z_erofs_vle_decompressed_index) != 8);
		BUILD_BUG_ON(sizeof(struct erofs_dirent) != 12);
		/* keep in sync between 2 index structures for better extendibility */
		BUILD_BUG_ON(sizeof(struct erofs_inode_chunk_index) !=
		sizeof(struct z_erofs_vle_decompressed_index));

		BUILD_BUG_ON(BIT(Z_EROFS_VLE_DI_CLUSTER_TYPE_BITS) <
		Z_EROFS_VLE_CLUSTER_TYPE_MAX - 1);

fs/erofs/inode.c

+27 −2

Original line number	Diff line number	Diff line
		@@ -2,6 +2,7 @@
		/*
		* Copyright (C) 2017-2018 HUAWEI, Inc.
		* https://www.huawei.com/
		* Copyright (C) 2021, Alibaba Cloud
		*/
		#include "xattr.h"

		@@ -122,8 +123,11 @@ static struct page erofs_read_inode(struct inode inode,
		/* total blocks for compressed files */
		if (erofs_inode_is_data_compressed(vi->datalayout))
		nblks = le32_to_cpu(die->i_u.compressed_blocks);

		else if (vi->datalayout == EROFS_INODE_CHUNK_BASED)
		/* fill chunked inode summary info */
		vi->chunkformat = le16_to_cpu(die->i_u.c.format);
		kfree(copied);
		copied = NULL;
		break;
		case EROFS_INODE_LAYOUT_COMPACT:
		vi->inode_isize = sizeof(struct erofs_inode_compact);
		@@ -160,6 +164,8 @@ static struct page erofs_read_inode(struct inode inode,
		inode->i_size = le32_to_cpu(dic->i_size);
		if (erofs_inode_is_data_compressed(vi->datalayout))
		nblks = le32_to_cpu(dic->i_u.compressed_blocks);
		else if (vi->datalayout == EROFS_INODE_CHUNK_BASED)
		vi->chunkformat = le16_to_cpu(dic->i_u.c.format);
		break;
		default:
		erofs_err(inode->i_sb,
		@@ -169,11 +175,26 @@ static struct page erofs_read_inode(struct inode inode,
		goto err_out;
		}

		if (vi->datalayout == EROFS_INODE_CHUNK_BASED) {
		if (!(vi->chunkformat & EROFS_CHUNK_FORMAT_ALL)) {
		erofs_err(inode->i_sb,
		"unsupported chunk format %x of nid %llu",
		vi->chunkformat, vi->nid);
		err = -EOPNOTSUPP;
		goto err_out;
		}
		vi->chunkbits = LOG_BLOCK_SIZE +
		(vi->chunkformat & EROFS_CHUNK_FORMAT_BLKBITS_MASK);
		}
		inode->i_mtime.tv_sec = inode->i_ctime.tv_sec;
		inode->i_atime.tv_sec = inode->i_ctime.tv_sec;
		inode->i_mtime.tv_nsec = inode->i_ctime.tv_nsec;
		inode->i_atime.tv_nsec = inode->i_ctime.tv_nsec;

		inode->i_flags &= ~S_DAX;
		if (test_opt(&sbi->ctx, DAX_ALWAYS) && S_ISREG(inode->i_mode) &&
		vi->datalayout == EROFS_INODE_FLAT_PLAIN)
		inode->i_flags \|= S_DAX;
		if (!nblks)
		/* measure inode.i_blocks as generic filesystems */
		inode->i_blocks = roundup(inode->i_size, EROFS_BLKSIZ) >> 9;
		@@ -247,7 +268,10 @@ static int erofs_fill_inode(struct inode *inode, int isdir)
		switch (inode->i_mode & S_IFMT) {
		case S_IFREG:
		inode->i_op = &erofs_generic_iops;
		if (erofs_inode_is_data_compressed(vi->datalayout))
		inode->i_fop = &generic_ro_fops;
		else
		inode->i_fop = &erofs_file_fops;
		break;
		case S_IFDIR:
		inode->i_op = &erofs_dir_iops;
		@@ -358,6 +382,7 @@ const struct inode_operations erofs_generic_iops = {
		.getattr = erofs_getattr,
		.listxattr = erofs_listxattr,
		.get_acl = erofs_get_acl,
		.fiemap = erofs_fiemap,
		};

		const struct inode_operations erofs_symlink_iops = {