mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-09-12 05:48:40 +00:00
![Gao Xiang](/assets/img/avatar_default.png)
Since tail-packing inline has been supported by iomap now, let's convert all EROFS uncompressed data I/O to iomap, which is pretty straight-forward. Link: https://lore.kernel.org/r/20210805003601.183063-4-hsiangkao@linux.alibaba.com Cc: linux-fsdevel@vger.kernel.org Reviewed-by: Chao Yu <chao@kernel.org> Signed-off-by: Gao Xiang <hsiangkao@linux.alibaba.com>
260 lines
6.4 KiB
C
260 lines
6.4 KiB
C
// SPDX-License-Identifier: GPL-2.0-only
|
|
/*
|
|
* Copyright (C) 2017-2018 HUAWEI, Inc.
|
|
* https://www.huawei.com/
|
|
*/
|
|
#include "internal.h"
|
|
#include <linux/prefetch.h>
|
|
#include <linux/iomap.h>
|
|
#include <linux/dax.h>
|
|
#include <trace/events/erofs.h>
|
|
|
|
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;
|
|
struct page *page;
|
|
|
|
page = read_cache_page_gfp(mapping, blkaddr,
|
|
mapping_gfp_constraint(mapping, ~__GFP_FS));
|
|
/* should already be PageUptodate */
|
|
if (!IS_ERR(page))
|
|
lock_page(page);
|
|
return page;
|
|
}
|
|
|
|
static int erofs_map_blocks_flatmode(struct inode *inode,
|
|
struct erofs_map_blocks *map,
|
|
int flags)
|
|
{
|
|
int err = 0;
|
|
erofs_blk_t nblocks, lastblk;
|
|
u64 offset = map->m_la;
|
|
struct erofs_inode *vi = EROFS_I(inode);
|
|
bool tailendpacking = (vi->datalayout == EROFS_INODE_FLAT_INLINE);
|
|
|
|
trace_erofs_map_blocks_flatmode_enter(inode, map, flags);
|
|
|
|
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;
|
|
|
|
if (offset < blknr_to_addr(lastblk)) {
|
|
map->m_pa = blknr_to_addr(vi->raw_blkaddr) + map->m_la;
|
|
map->m_plen = blknr_to_addr(lastblk) - offset;
|
|
} else if (tailendpacking) {
|
|
/* 2 - inode inline B: inode, [xattrs], inline last blk... */
|
|
struct erofs_sb_info *sbi = EROFS_SB(inode->i_sb);
|
|
|
|
map->m_pa = iloc(sbi, vi->nid) + vi->inode_isize +
|
|
vi->xattr_isize + erofs_blkoff(map->m_la);
|
|
map->m_plen = inode->i_size - offset;
|
|
|
|
/* inline data should be located in one meta block */
|
|
if (erofs_blkoff(map->m_pa) + map->m_plen > PAGE_SIZE) {
|
|
erofs_err(inode->i_sb,
|
|
"inline data cross block boundary @ nid %llu",
|
|
vi->nid);
|
|
DBG_BUGON(1);
|
|
err = -EFSCORRUPTED;
|
|
goto err_out;
|
|
}
|
|
|
|
map->m_flags |= EROFS_MAP_META;
|
|
} else {
|
|
erofs_err(inode->i_sb,
|
|
"internal error @ nid: %llu (size %llu), m_la 0x%llx",
|
|
vi->nid, inode->i_size, map->m_la);
|
|
DBG_BUGON(1);
|
|
err = -EIO;
|
|
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 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;
|
|
|
|
map.m_la = offset;
|
|
map.m_llen = length;
|
|
|
|
ret = erofs_map_blocks_flatmode(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;
|
|
|
|
if (!(map.m_flags & EROFS_MAP_MAPPED)) {
|
|
iomap->type = IOMAP_HOLE;
|
|
iomap->addr = IOMAP_NULL_ADDR;
|
|
if (!iomap->length)
|
|
iomap->length = length;
|
|
return 0;
|
|
}
|
|
|
|
if (map.m_flags & EROFS_MAP_META) {
|
|
struct page *ipage;
|
|
|
|
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;
|
|
}
|
|
|
|
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;
|
|
|
|
if (ipage) {
|
|
DBG_BUGON(iomap->type != IOMAP_INLINE);
|
|
unlock_page(ipage);
|
|
put_page(ipage);
|
|
} else {
|
|
DBG_BUGON(iomap->type == IOMAP_INLINE);
|
|
}
|
|
return written;
|
|
}
|
|
|
|
static const struct iomap_ops erofs_iomap_ops = {
|
|
.iomap_begin = erofs_iomap_begin,
|
|
.iomap_end = erofs_iomap_end,
|
|
};
|
|
|
|
/*
|
|
* since we dont have write or truncate flows, so no inode
|
|
* locking needs to be held at the moment.
|
|
*/
|
|
static int erofs_readpage(struct file *file, struct page *page)
|
|
{
|
|
return iomap_readpage(page, &erofs_iomap_ops);
|
|
}
|
|
|
|
static void erofs_readahead(struct readahead_control *rac)
|
|
{
|
|
return iomap_readahead(rac, &erofs_iomap_ops);
|
|
}
|
|
|
|
static sector_t erofs_bmap(struct address_space *mapping, sector_t block)
|
|
{
|
|
return iomap_bmap(mapping, block, &erofs_iomap_ops);
|
|
}
|
|
|
|
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 (align & blksize_mask)
|
|
return -EINVAL;
|
|
return 0;
|
|
}
|
|
|
|
static ssize_t erofs_file_read_iter(struct kiocb *iocb, struct iov_iter *to)
|
|
{
|
|
/* no need taking (shared) inode lock since it's a ro filesystem */
|
|
if (!iov_iter_count(to))
|
|
return 0;
|
|
|
|
#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;
|
|
}
|
|
return filemap_read(iocb, to, 0);
|
|
}
|
|
|
|
/* 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 vm_fault_t erofs_dax_fault(struct vm_fault *vmf)
|
|
{
|
|
return erofs_dax_huge_fault(vmf, PE_SIZE_PTE);
|
|
}
|
|
|
|
static const struct vm_operations_struct erofs_dax_vm_ops = {
|
|
.fault = erofs_dax_fault,
|
|
.huge_fault = erofs_dax_huge_fault,
|
|
};
|
|
|
|
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 ((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;
|
|
}
|
|
#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,
|
|
};
|