Now that iomap.c is in place, update itree_v1.c, itree_v2.c, and itree_common.c to use iomap. This also updates the exports in minix.h, adds a convenient helper function to get the right version of minix_iomap_ops, and exports the previously static minix_aops struct from inode.c. There are a couple of odd things in here that need to be explicitly called out and explained: First, in itree_common.c there is now a check on inode->i_mapping->a_ops where if it is equal to &minix_aops. If it is, it calls iomap_truncate_page; otherwise, it calls block_truncate_page. This is because unlike everything else directory operations still use buffer_heads and have their own address_space_operations struct. Second, instead of standing alone iomap.c is #included into itree_v1.c and itree_v2.c the same way itree_common.c is. This is an existing pattern that has been present in this module as far back as the git history goes to accomodate the different block pointer sizes and number of indirect block levels the different versions of the minix filesystem has. The way it is now does look very strange, but it avoids massive changes that might not be appreciated. Signed-off-by: Jeremy Bingham --- fs/minix/inode.c | 2 +- fs/minix/itree_common.c | 11 ++++++++++- fs/minix/itree_v1.c | 25 ++++++++++++++++++++++++- fs/minix/itree_v2.c | 17 ++++++++++++++++- fs/minix/minix.h | 22 ++++++++++++++++++++-- 5 files changed, 71 insertions(+), 6 deletions(-) diff --git a/fs/minix/inode.c b/fs/minix/inode.c index c30cc590698d..d5ba72f51049 100644 --- a/fs/minix/inode.c +++ b/fs/minix/inode.c @@ -490,7 +490,7 @@ static sector_t minix_bmap(struct address_space *mapping, sector_t block) return generic_block_bmap(mapping,block,minix_get_block); } -static const struct address_space_operations minix_aops = { +const struct address_space_operations minix_aops = { .dirty_folio = block_dirty_folio, .invalidate_folio = block_invalidate_folio, .read_folio = minix_read_folio, diff --git a/fs/minix/itree_common.c b/fs/minix/itree_common.c index c3cd2c75af9c..5a8b73a7beda 100644 --- a/fs/minix/itree_common.c +++ b/fs/minix/itree_common.c @@ -311,7 +311,16 @@ static inline void truncate (struct inode * inode) long iblock; iblock = (inode->i_size + sb->s_blocksize -1) >> sb->s_blocksize_bits; - block_truncate_page(inode->i_mapping, inode->i_size, get_block); + + /* Depending on what address space operations are being used by the + * inode being truncated, we need to either call iomap_truncate_page or + * block_truncate_page. + */ + if (inode->i_mapping->a_ops == &minix_aops) + iomap_truncate_page(inode, inode->i_size, NULL, + minix_iomap_ops_ver(inode), NULL, NULL); + else + block_truncate_page(inode->i_mapping, inode->i_size, get_block); n = block_to_path(inode, iblock, offsets); if (!n) diff --git a/fs/minix/itree_v1.c b/fs/minix/itree_v1.c index 1fed906042aa..58c29f4443d3 100644 --- a/fs/minix/itree_v1.c +++ b/fs/minix/itree_v1.c @@ -49,6 +49,18 @@ static int block_to_path(struct inode * inode, long block, int offsets[DEPTH]) } #include "itree_common.c" +/* NOTA BENE: + * + * This is icky to me, but at the same time having it be a standalone C file + * that's compiled to object form and linked separately like one would think is + * much nastier in minix because of the different versions of the minix fs that + * have some very, very different aspects, like the size of block_t. I don't + * like it, but since minix already has this pattern where a common itree file + * is included in the itree_v1 and itree_v2(and v3) files, I'm including iomap.c + * in these files as well. It does at least avoid exporting some currently + * static functions that aren't needed anywhere but itree_common.c and iomap.c. + */ +#include "iomap.c" int V1_minix_get_block(struct inode * inode, long block, struct buffer_head *bh_result, int create) @@ -61,7 +73,18 @@ void V1_minix_truncate(struct inode * inode) truncate(inode); } -unsigned V1_minix_blocks(loff_t size, struct super_block *sb) +unsigned int V1_minix_blocks(loff_t size, struct super_block *sb) { return nblocks(size, sb); } + +int V1_minix_iomap_begin(struct inode *inode, loff_t offset, loff_t length, + unsigned int flags, struct iomap *iomap, struct iomap *srcmap) +{ + return minix_iomap_begin(inode, offset, length, flags, iomap, srcmap); +} + +const struct iomap_ops V1_minix_iomap_ops = { + .iomap_begin = V1_minix_iomap_begin, + .iomap_end = minix_iomap_end, +}; diff --git a/fs/minix/itree_v2.c b/fs/minix/itree_v2.c index 9d00f31a2d9d..fc7a5ae8fa1c 100644 --- a/fs/minix/itree_v2.c +++ b/fs/minix/itree_v2.c @@ -57,6 +57,10 @@ static int block_to_path(struct inode * inode, long block, int offsets[DEPTH]) } #include "itree_common.c" +/* See the note in itree_v1 in a comment that starts "NOTA BENE" for an + * explanation for why iomap.c is included here. + */ +#include "iomap.c" int V2_minix_get_block(struct inode * inode, long block, struct buffer_head *bh_result, int create) @@ -69,7 +73,18 @@ void V2_minix_truncate(struct inode * inode) truncate(inode); } -unsigned V2_minix_blocks(loff_t size, struct super_block *sb) +unsigned int V2_minix_blocks(loff_t size, struct super_block *sb) { return nblocks(size, sb); } + +int V2_minix_iomap_begin(struct inode *inode, loff_t offset, loff_t length, + unsigned int flags, struct iomap *iomap, struct iomap *srcmap) +{ + return minix_iomap_begin(inode, offset, length, flags, iomap, srcmap); +} + +const struct iomap_ops V2_minix_iomap_ops = { + .iomap_begin = V2_minix_iomap_begin, + .iomap_end = minix_iomap_end, +}; diff --git a/fs/minix/minix.h b/fs/minix/minix.h index 9e52d4302f0d..cf85edfb5bfa 100644 --- a/fs/minix/minix.h +++ b/fs/minix/minix.h @@ -5,6 +5,7 @@ #include #include #include +#include #define INODE_VERSION(inode) minix_sb(inode->i_sb)->s_version #define MINIX_V1 0x0001 /* original minix fs */ @@ -77,13 +78,24 @@ int minix_make_empty(struct inode*, struct inode*); int minix_empty_dir(struct inode*); int minix_set_link(struct minix_dir_entry *de, struct folio *folio, struct inode *inode); + struct minix_dir_entry *minix_dotdot(struct inode*, struct folio **); ino_t minix_inode_by_name(struct dentry*); +extern int V1_minix_iomap_begin(struct inode *inode, loff_t offset, + loff_t length, unsigned int flags, struct iomap *iomap, + struct iomap *srcmap); +extern int V2_minix_iomap_begin(struct inode *inode, loff_t offset, + loff_t length, unsigned int flags, struct iomap *iomap, + struct iomap *srcmap); + +extern const struct address_space_operations minix_aops; extern const struct inode_operations minix_file_inode_operations; extern const struct inode_operations minix_dir_inode_operations; extern const struct file_operations minix_file_operations; extern const struct file_operations minix_dir_operations; +extern const struct iomap_ops V1_minix_iomap_ops; +extern const struct iomap_ops V2_minix_iomap_ops; static inline struct minix_sb_info *minix_sb(struct super_block *sb) { @@ -95,11 +107,17 @@ static inline struct minix_inode_info *minix_i(struct inode *inode) return container_of(inode, struct minix_inode_info, vfs_inode); } -static inline unsigned minix_blocks_needed(unsigned bits, unsigned blocksize) +static inline unsigned int minix_blocks_needed(unsigned int bits, unsigned int blocksize) { return DIV_ROUND_UP_POW2(bits, blocksize * 8); } +static inline const struct iomap_ops *minix_iomap_ops_ver(struct inode *inode) +{ + return (INODE_VERSION(inode) == MINIX_V1) ? + &V1_minix_iomap_ops : &V2_minix_iomap_ops; +} + #if defined(CONFIG_MINIX_FS_NATIVE_ENDIAN) && \ defined(CONFIG_MINIX_FS_BIG_ENDIAN_16BIT_INDEXED) @@ -129,7 +147,7 @@ static inline unsigned minix_blocks_needed(unsigned bits, unsigned blocksize) * big-endian 16bit indexed bitmaps */ -static inline int minix_find_first_zero_bit(const void *vaddr, unsigned size) +static inline int minix_find_first_zero_bit(const void *vaddr, unsigned int size) { const unsigned short *p = vaddr, *addr = vaddr; unsigned short num; -- 2.47.3