ext2: Move direct-io to use iomap
This patch converts ext2 direct-io path to iomap interface. - This also takes care of DIO_SKIP_HOLES part in which we return -ENOTBLK from ext2_iomap_begin(), in case if the write is done on a hole. - This fallbacks to buffered-io in case of DIO_SKIP_HOLES or in case of a partial write or if any error is detected in ext2_iomap_end(). We try to return -ENOTBLK in such cases. - For any unaligned or extending DIO writes, we pass IOMAP_DIO_FORCE_WAIT flag to ensure synchronous writes. - For extending writes we set IOMAP_F_DIRTY in ext2_iomap_begin because otherwise with dsync writes on devices that support FUA, generic_write_sync won't be called and we might miss inode metadata updates. - Since ext2 already now uses _nolock vartiant of sync write. Hence there is no inode lock problem with iomap in this patch. - ext2_iomap_ops are now being shared by DIO, DAX & fiemap path Tested-by: Disha Goel <disgoel@linux.ibm.com> Reviewed-by: Christoph Hellwig <hch@lst.de> Signed-off-by: Ritesh Harjani (IBM) <ritesh.list@gmail.com> Signed-off-by: Jan Kara <jack@suse.cz> Message-Id: <610b672a52f2a7ff6dc550fd14d0f995806232a5.1682069716.git.ritesh.list@gmail.com>
This commit is contained in:
Ritesh Harjani (IBM)
Jan Kara
parent
d053070425
commit
fb5de4358e
|
|
@ -754,6 +754,7 @@ extern unsigned long ext2_count_free (struct buffer_head *, unsigned);
|
|||
extern struct inode *ext2_iget (struct super_block *, unsigned long);
|
||||
extern int ext2_write_inode (struct inode *, struct writeback_control *);
|
||||
extern void ext2_evict_inode(struct inode *);
|
||||
void ext2_write_failed(struct address_space *mapping, loff_t to);
|
||||
extern int ext2_get_block(struct inode *, sector_t, struct buffer_head *, int);
|
||||
extern int ext2_setattr (struct mnt_idmap *, struct dentry *, struct iattr *);
|
||||
extern int ext2_getattr (struct mnt_idmap *, const struct path *,
|
||||
|
|
|
|||
115
fs/ext2/file.c
115
fs/ext2/file.c
|
|
@ -162,12 +162,124 @@ int ext2_fsync(struct file *file, loff_t start, loff_t end, int datasync)
|
|||
return ret;
|
||||
}
|
||||
|
||||
static ssize_t ext2_dio_read_iter(struct kiocb *iocb, struct iov_iter *to)
|
||||
{
|
||||
struct file *file = iocb->ki_filp;
|
||||
struct inode *inode = file->f_mapping->host;
|
||||
ssize_t ret;
|
||||
|
||||
inode_lock_shared(inode);
|
||||
ret = iomap_dio_rw(iocb, to, &ext2_iomap_ops, NULL, 0, NULL, 0);
|
||||
inode_unlock_shared(inode);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int ext2_dio_write_end_io(struct kiocb *iocb, ssize_t size,
|
||||
int error, unsigned int flags)
|
||||
{
|
||||
loff_t pos = iocb->ki_pos;
|
||||
struct inode *inode = file_inode(iocb->ki_filp);
|
||||
|
||||
if (error)
|
||||
goto out;
|
||||
|
||||
/*
|
||||
* If we are extending the file, we have to update i_size here before
|
||||
* page cache gets invalidated in iomap_dio_rw(). This prevents racing
|
||||
* buffered reads from zeroing out too much from page cache pages.
|
||||
* Note that all extending writes always happens synchronously with
|
||||
* inode lock held by ext2_dio_write_iter(). So it is safe to update
|
||||
* inode size here for extending file writes.
|
||||
*/
|
||||
pos += size;
|
||||
if (pos > i_size_read(inode)) {
|
||||
i_size_write(inode, pos);
|
||||
mark_inode_dirty(inode);
|
||||
}
|
||||
out:
|
||||
return error;
|
||||
}
|
||||
|
||||
static const struct iomap_dio_ops ext2_dio_write_ops = {
|
||||
.end_io = ext2_dio_write_end_io,
|
||||
};
|
||||
|
||||
static ssize_t ext2_dio_write_iter(struct kiocb *iocb, struct iov_iter *from)
|
||||
{
|
||||
struct file *file = iocb->ki_filp;
|
||||
struct inode *inode = file->f_mapping->host;
|
||||
ssize_t ret;
|
||||
unsigned int flags = 0;
|
||||
unsigned long blocksize = inode->i_sb->s_blocksize;
|
||||
loff_t offset = iocb->ki_pos;
|
||||
loff_t count = iov_iter_count(from);
|
||||
|
||||
inode_lock(inode);
|
||||
ret = generic_write_checks(iocb, from);
|
||||
if (ret <= 0)
|
||||
goto out_unlock;
|
||||
|
||||
ret = kiocb_modified(iocb);
|
||||
if (ret)
|
||||
goto out_unlock;
|
||||
|
||||
/* use IOMAP_DIO_FORCE_WAIT for unaligned or extending writes */
|
||||
if (iocb->ki_pos + iov_iter_count(from) > i_size_read(inode) ||
|
||||
(!IS_ALIGNED(iocb->ki_pos | iov_iter_alignment(from), blocksize)))
|
||||
flags |= IOMAP_DIO_FORCE_WAIT;
|
||||
|
||||
ret = iomap_dio_rw(iocb, from, &ext2_iomap_ops, &ext2_dio_write_ops,
|
||||
flags, NULL, 0);
|
||||
|
||||
/* ENOTBLK is magic return value for fallback to buffered-io */
|
||||
if (ret == -ENOTBLK)
|
||||
ret = 0;
|
||||
|
||||
if (ret < 0 && ret != -EIOCBQUEUED)
|
||||
ext2_write_failed(inode->i_mapping, offset + count);
|
||||
|
||||
/* handle case for partial write and for fallback to buffered write */
|
||||
if (ret >= 0 && iov_iter_count(from)) {
|
||||
loff_t pos, endbyte;
|
||||
ssize_t status;
|
||||
int ret2;
|
||||
|
||||
iocb->ki_flags &= ~IOCB_DIRECT;
|
||||
pos = iocb->ki_pos;
|
||||
status = generic_perform_write(iocb, from);
|
||||
if (unlikely(status < 0)) {
|
||||
ret = status;
|
||||
goto out_unlock;
|
||||
}
|
||||
|
||||
iocb->ki_pos += status;
|
||||
ret += status;
|
||||
endbyte = pos + status - 1;
|
||||
ret2 = filemap_write_and_wait_range(inode->i_mapping, pos,
|
||||
endbyte);
|
||||
if (!ret2)
|
||||
invalidate_mapping_pages(inode->i_mapping,
|
||||
pos >> PAGE_SHIFT,
|
||||
endbyte >> PAGE_SHIFT);
|
||||
if (ret > 0)
|
||||
generic_write_sync(iocb, ret);
|
||||
}
|
||||
|
||||
out_unlock:
|
||||
inode_unlock(inode);
|
||||
return ret;
|
||||
}
|
||||
|
||||
static ssize_t ext2_file_read_iter(struct kiocb *iocb, struct iov_iter *to)
|
||||
{
|
||||
#ifdef CONFIG_FS_DAX
|
||||
if (IS_DAX(iocb->ki_filp->f_mapping->host))
|
||||
return ext2_dax_read_iter(iocb, to);
|
||||
#endif
|
||||
if (iocb->ki_flags & IOCB_DIRECT)
|
||||
return ext2_dio_read_iter(iocb, to);
|
||||
|
||||
return generic_file_read_iter(iocb, to);
|
||||
}
|
||||
|
||||
|
|
@ -177,6 +289,9 @@ static ssize_t ext2_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
|
|||
if (IS_DAX(iocb->ki_filp->f_mapping->host))
|
||||
return ext2_dax_write_iter(iocb, from);
|
||||
#endif
|
||||
if (iocb->ki_flags & IOCB_DIRECT)
|
||||
return ext2_dio_write_iter(iocb, from);
|
||||
|
||||
return generic_file_write_iter(iocb, from);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -56,7 +56,7 @@ static inline int ext2_inode_is_fast_symlink(struct inode *inode)
|
|||
|
||||
static void ext2_truncate_blocks(struct inode *inode, loff_t offset);
|
||||
|
||||
static void ext2_write_failed(struct address_space *mapping, loff_t to)
|
||||
void ext2_write_failed(struct address_space *mapping, loff_t to)
|
||||
{
|
||||
struct inode *inode = mapping->host;
|
||||
|
||||
|
|
@ -809,9 +809,27 @@ static int ext2_iomap_begin(struct inode *inode, loff_t offset, loff_t length,
|
|||
bool new = false, boundary = false;
|
||||
u32 bno;
|
||||
int ret;
|
||||
bool create = flags & IOMAP_WRITE;
|
||||
|
||||
/*
|
||||
* For writes that could fill holes inside i_size on a
|
||||
* DIO_SKIP_HOLES filesystem we forbid block creations: only
|
||||
* overwrites are permitted.
|
||||
*/
|
||||
if ((flags & IOMAP_DIRECT) &&
|
||||
(first_block << blkbits) < i_size_read(inode))
|
||||
create = 0;
|
||||
|
||||
/*
|
||||
* Writes that span EOF might trigger an IO size update on completion,
|
||||
* so consider them to be dirty for the purposes of O_DSYNC even if
|
||||
* there is no other metadata changes pending or have been made here.
|
||||
*/
|
||||
if ((flags & IOMAP_WRITE) && offset + length > i_size_read(inode))
|
||||
iomap->flags |= IOMAP_F_DIRTY;
|
||||
|
||||
ret = ext2_get_blocks(inode, first_block, max_blocks,
|
||||
&bno, &new, &boundary, flags & IOMAP_WRITE);
|
||||
&bno, &new, &boundary, create);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
|
|
@ -823,6 +841,12 @@ static int ext2_iomap_begin(struct inode *inode, loff_t offset, loff_t length,
|
|||
iomap->bdev = inode->i_sb->s_bdev;
|
||||
|
||||
if (ret == 0) {
|
||||
/*
|
||||
* Switch to buffered-io for writing to holes in a non-extent
|
||||
* based filesystem to avoid stale data exposure problem.
|
||||
*/
|
||||
if (!create && (flags & IOMAP_WRITE) && (flags & IOMAP_DIRECT))
|
||||
return -ENOTBLK;
|
||||
iomap->type = IOMAP_HOLE;
|
||||
iomap->addr = IOMAP_NULL_ADDR;
|
||||
iomap->length = 1 << blkbits;
|
||||
|
|
@ -844,6 +868,13 @@ static int
|
|||
ext2_iomap_end(struct inode *inode, loff_t offset, loff_t length,
|
||||
ssize_t written, unsigned flags, struct iomap *iomap)
|
||||
{
|
||||
/*
|
||||
* Switch to buffered-io in case of any error.
|
||||
* Blocks allocated can be used by the buffered-io path.
|
||||
*/
|
||||
if ((flags & IOMAP_DIRECT) && (flags & IOMAP_WRITE) && written == 0)
|
||||
return -ENOTBLK;
|
||||
|
||||
if (iomap->type == IOMAP_MAPPED &&
|
||||
written < length &&
|
||||
(flags & IOMAP_WRITE))
|
||||
|
|
@ -908,22 +939,6 @@ static sector_t ext2_bmap(struct address_space *mapping, sector_t block)
|
|||
return generic_block_bmap(mapping,block,ext2_get_block);
|
||||
}
|
||||
|
||||
static ssize_t
|
||||
ext2_direct_IO(struct kiocb *iocb, struct iov_iter *iter)
|
||||
{
|
||||
struct file *file = iocb->ki_filp;
|
||||
struct address_space *mapping = file->f_mapping;
|
||||
struct inode *inode = mapping->host;
|
||||
size_t count = iov_iter_count(iter);
|
||||
loff_t offset = iocb->ki_pos;
|
||||
ssize_t ret;
|
||||
|
||||
ret = blockdev_direct_IO(iocb, inode, iter, ext2_get_block);
|
||||
if (ret < 0 && iov_iter_rw(iter) == WRITE)
|
||||
ext2_write_failed(mapping, offset + count);
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int
|
||||
ext2_writepages(struct address_space *mapping, struct writeback_control *wbc)
|
||||
{
|
||||
|
|
@ -946,7 +961,7 @@ const struct address_space_operations ext2_aops = {
|
|||
.write_begin = ext2_write_begin,
|
||||
.write_end = ext2_write_end,
|
||||
.bmap = ext2_bmap,
|
||||
.direct_IO = ext2_direct_IO,
|
||||
.direct_IO = noop_direct_IO,
|
||||
.writepages = ext2_writepages,
|
||||
.migrate_folio = buffer_migrate_folio,
|
||||
.is_partially_uptodate = block_is_partially_uptodate,
|
||||
|
|
|
|||
Loading…
Reference in New Issue