f2fs: use iomap for direct I/O
Subsystems (3)
cover f2fs: use iomap for direct I/O
This series makes f2fs implement direct I/O using iomap_dio_rw() instead of __blockdev_direct_IO(). In order to do this, it adds f2fs_iomap_ops, since this is the first use of iomap in f2fs.
The iomap direct I/O implementation is more efficient than the fs/direct-io.c implementation. Switching to iomap also avoids the need to add new features and optimizations to the old implementation. E.g., see https://lore.kernel.org/r/[email protected] and
https://lore.kernel.org/r/[email protected].
In general, this series preserves existing f2fs behavior (such as the conditions for falling back to buffered I/O) and is only an implementation change.
Patches 1-5 contain cleanups and fixes for f2fs_file_write_iter(). Patch 6 adds f2fs_iomap_ops, patch 7 and 8 switch direct I/O reads and writes to iomap, and patch 9 removes obsoleted code.
Careful review is appreciated, as I'm not an expert in all areas here.
This series has been tested with xfstests by running 'gce-xfstests -c f2fs -g auto -X generic/017' with and without this series; no regressions were seen. (Some tests fail both before and after. generic/017 hangs both before and after, so it had to be excluded.)
This series applies to v5.14-rc1.
Eric Biggers (9):
f2fs: make f2fs_write_failed() take struct inode
f2fs: remove allow_outplace_dio()
f2fs: rework write preallocations
f2fs: reduce indentation in f2fs_file_write_iter()
f2fs: fix the f2fs_file_write_iter tracepoint
f2fs: implement iomap operations
f2fs: use iomap for direct I/O reads
f2fs: use iomap for direct I/O writes
f2fs: remove f2fs_direct_IO()
fs/f2fs/Kconfig | 1 + fs/f2fs/data.c | 286 +++++++------------------ fs/f2fs/f2fs.h | 29 +-- fs/f2fs/file.c | 416 +++++++++++++++++++++++++++++------- include/trace/events/f2fs.h | 12 +- 5 files changed, 421 insertions(+), 323 deletions(-)
base-commit: e73f0f0ee7541171d89f2e2491130c7771ba58d3
Signature · 1 line
2.32.0
PATCH 1/9 f2fs: make f2fs_write_failed() take struct inode
From: Eric Biggers <[email protected]>
Make f2fs_write_failed() take a 'struct inode' directly rather than a 'struct address_space', as this simplifies it slightly.
--- fs/f2fs/data.c | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-)
fs/f2fs/data.c +3 -4
@@ -3176,9 +3176,8 @@ static int f2fs_write_data_pages(struct address_space *mapping, FS_CP_DATA_IO : FS_DATA_IO); } -static void f2fs_write_failed (struct address_space *mapping,loff_t to) +static void f2fs_write_failed (struct inode *inode,loff_t to) { -struct inode *inode = mapping->host;loff_t i_size =i_size_read (inode);if (IS_NOQUOTA (inode))
@@ -3410,7 +3409,7 @@ static int f2fs_write_begin(struct file *file, struct address_space *mapping, fail:f2fs_put_page (page,1 ); -f2fs_write_failed (mapping, pos + len); +f2fs_write_failed (inode, pos + len);if (drop_atomic)f2fs_drop_inmem_pages_all (sbi, false);return err;
@@ -3600,7 +3599,7 @@ static ssize_t f2fs_direct_IO(struct kiocb *iocb, struct iov_iter *iter)f2fs_update_iostat (F2FS_I_SB (inode),APP_DIRECT_IO , count -iov_iter_count (iter)); }else if (err <0 ) { -f2fs_write_failed (mapping, offset + count); +f2fs_write_failed (inode, offset + count); } }else {if (err >0 )
Signature · 1 line
2.32.0
PATCH 2/9 f2fs: remove allow_outplace_dio()
In reply to Eric BiggersFrom: Eric Biggers <[email protected]>
We can just check f2fs_lfs_mode() directly. The block_unaligned_IO() check is redundant because in LFS mode, f2fs doesn't do direct I/O writes that aren't block-aligned (due to f2fs_force_buffered_io() returning true in this case, triggering the fallback to buffered I/O).
--- fs/f2fs/data.c | 2 +- fs/f2fs/f2fs.h | 10 ---------- fs/f2fs/file.c | 2 +- 3 files changed, 2 insertions(+), 12 deletions(-)
fs/f2fs/data.c +1 -1
@@ -3551,7 +3551,7 @@ static ssize_t f2fs_direct_IO(struct kiocb *iocb, struct iov_iter *iter)if (f2fs_force_buffered_io (inode, iocb, iter))return 0 ; - do_opu =allow_outplace_dio (inode, iocb, iter); + do_opu = (rw ==WRITE &&f2fs_lfs_mode (sbi));trace_f2fs_direct_IO_enter (inode, offset, count, rw);
fs/f2fs/f2fs.h +0 -10
@@ -4305,16 +4305,6 @@ static inline int block_unaligned_IO(struct inode *inode,return align & blocksize_mask; } -static inline int allow_outplace_dio (struct inode *inode, -struct kiocb *iocb,struct iov_iter *iter) -{ -struct f2fs_sb_info *sbi =F2FS_I_SB (inode); -int rw =iov_iter_rw (iter); - -return (f2fs_lfs_mode (sbi) && (rw ==WRITE ) && - !block_unaligned_IO (inode, iocb, iter)); -} -static inline bool f2fs_force_buffered_io (struct inode *inode,struct kiocb *iocb,struct iov_iter *iter) {
fs/f2fs/file.c +1 -1
@@ -4292,7 +4292,7 @@ static ssize_t f2fs_file_write_iter(struct kiocb *iocb, struct iov_iter *from)* back to buffered IO. */ if (!f2fs_force_buffered_io (inode, iocb, from) && -allow_outplace_dio (inode, iocb, from)) +f2fs_lfs_mode (F2FS_I_SB (inode))) goto write; } preallocated = true;
Signature · 1 line
2.32.0
PATCH 3/9 f2fs: rework write preallocations
In reply to Eric BiggersFrom: Eric Biggers <[email protected]>
f2fs_write_begin() assumes that all blocks were preallocated by default unless FI_NO_PREALLOC is explicitly set. This invites data corruption, as there are cases in which not all blocks are preallocated. Commit 47501f87c61a ("f2fs: preallocate DIO blocks when forcing buffered_io") fixed one case, but there are others remaining.
Fix up this logic by replacing this flag with FI_PREALLOCATED_ALL, which only gets set if all blocks for the current write were preallocated.
Also clean up f2fs_preallocate_blocks(), move it to file.c, and make it handle some of the logic that was previously in write_iter() directly.
--- fs/f2fs/data.c | 55 ++-------------------- fs/f2fs/f2fs.h | 3 +- fs/f2fs/file.c | 123 ++++++++++++++++++++++++++++++++----------------- 3 files changed, 84 insertions(+), 97 deletions(-)
fs/f2fs/data.c +3 -52
@@ -1370,53 +1370,6 @@ static int __allocate_data_block(struct dnode_of_data *dn, int seg_type)return 0 ; } -int f2fs_preallocate_blocks (struct kiocb *iocb,struct iov_iter *from) -{ -struct inode *inode =file_inode (iocb->ki_filp); -struct f2fs_map_blocks map; -int flag; -int err =0 ; -bool direct_io = iocb->ki_flags &IOCB_DIRECT ; - - map.m_lblk =F2FS_BLK_ALIGN (iocb->ki_pos); - map.m_len =F2FS_BYTES_TO_BLK (iocb->ki_pos +iov_iter_count (from)); -if (map.m_len > map.m_lblk) - map.m_len -= map.m_lblk; -else - map.m_len =0 ; - - map.m_next_pgofs =NULL ; - map.m_next_extent =NULL ; - map.m_seg_type =NO_CHECK_TYPE ; - map.m_may_create = true; - -if (direct_io) { - map.m_seg_type =f2fs_rw_hint_to_seg_type (iocb->ki_hint); - flag =f2fs_force_buffered_io (inode, iocb, from) ? -F2FS_GET_BLOCK_PRE_AIO : -F2FS_GET_BLOCK_PRE_DIO ; - goto map_blocks; - } -if (iocb->ki_pos +iov_iter_count (from) >MAX_INLINE_DATA (inode)) { - err =f2fs_convert_inline_inode (inode); -if (err) -return err; - } -if (f2fs_has_inline_data (inode)) -return err; - - flag =F2FS_GET_BLOCK_PRE_AIO ; - -map_blocks: - err =f2fs_map_blocks (inode, &map,1 , flag); -if (map.m_len >0 && err == -ENOSPC ) { -if (!direct_io) -set_inode_flag (inode,FI_NO_PREALLOC ); - err =0 ; - } -return err; -} -void f2fs_do_map_lock (struct f2fs_sb_info *sbi,int flag,bool lock) {if (flag ==F2FS_GET_BLOCK_PRE_AIO ) {
@@ -3210,12 +3163,10 @@ static int prepare_write_begin(struct f2fs_sb_info *sbi,int flag;/* -* we already allocated all the blocks, so we don't need to get -* the block addresses when there is no need to fill the page. +* If a whole page is being written and we already preallocated all the +* blocks, then there is no need to get a block address now. */ -if (!f2fs_has_inline_data (inode) && len ==PAGE_SIZE && - !is_inode_flag_set (inode,FI_NO_PREALLOC ) && - !f2fs_verity_in_progress (inode)) +if (len ==PAGE_SIZE &&is_inode_flag_set (inode,FI_PREALLOCATED_ALL ))return 0 ;/* f2fs_lock_op avoids race between write CP and convert_inline_page */
fs/f2fs/f2fs.h +1 -2
@@ -699,7 +699,7 @@ enum {FI_INLINE_DOTS ,/* indicate inline dot dentries */ FI_DO_DEFRAG ,/* indicate defragment is running */ FI_DIRTY_FILE ,/* indicate regular/symlink has dirty pages */ -FI_NO_PREALLOC ,/* indicate skipped preallocated blocks */ +FI_PREALLOCATED_ALL ,/* all blocks for write were preallocated */ FI_HOT_DATA ,/* indicate file is hot */ FI_EXTRA_ATTR ,/* indicate file has extra attribute */ FI_PROJ_INHERIT, /* indicate file inherits projectid */
@@ -3604,7 +3604,6 @@ void f2fs_update_data_blkaddr(struct dnode_of_data *dn, block_t blkaddr);int f2fs_reserve_new_blocks (struct dnode_of_data *dn,blkcnt_t count);int f2fs_reserve_new_block (struct dnode_of_data *dn);int f2fs_get_block (struct dnode_of_data *dn,pgoff_t index); -int f2fs_preallocate_blocks (struct kiocb *iocb,struct iov_iter *from);int f2fs_reserve_block (struct dnode_of_data *dn,pgoff_t index);struct page *f2fs_get_read_data_page (struct inode *inode,pgoff_t index,int op_flags,bool for_write);
fs/f2fs/file.c +80 -43
174 lines not on this page · raw message
Signature · 1 line
2.32.0
PATCH 4/9 f2fs: reduce indentation in f2fs_file_write_iter()
In reply to Eric BiggersFrom: Eric Biggers <[email protected]>
Replace 'if (ret > 0)' with 'if (ret <= 0) goto out_unlock;'. No change in behavior.
--- fs/f2fs/file.c | 73 +++++++++++++++++++++++++------------------------- 1 file changed, 37 insertions(+), 36 deletions(-)
fs/f2fs/file.c +37 -36
@@ -4316,49 +4316,50 @@ static ssize_t f2fs_file_write_iter(struct kiocb *iocb, struct iov_iter *from) } ret =generic_write_checks (iocb, from); -if (ret >0 ) { -if (iocb->ki_flags &IOCB_NOWAIT ) { -if (!f2fs_overwrite_io (inode, iocb->ki_pos, -iov_iter_count (from)) || -f2fs_has_inline_data (inode) || -f2fs_force_buffered_io (inode, iocb, from)) { - ret = -EAGAIN ; - goto out_unlock; - } - } -if (iocb->ki_flags &IOCB_DIRECT ) { -/* -* Convert inline data for Direct I/O before entering -* f2fs_direct_IO(). -*/ - ret =f2fs_convert_inline_inode (inode); -if (ret) - goto out_unlock; - } +if (ret <=0 ) + goto out_unlock; -/* Possibly preallocate the blocks for the write. */ - target_size = iocb->ki_pos +iov_iter_count (from); - preallocated =f2fs_preallocate_blocks (iocb, from); -if (preallocated <0 ) { - ret = preallocated; +if (iocb->ki_flags &IOCB_NOWAIT ) { +if (!f2fs_overwrite_io (inode, iocb->ki_pos, +iov_iter_count (from)) || +f2fs_has_inline_data (inode) || +f2fs_force_buffered_io (inode, iocb, from)) { + ret = -EAGAIN ; goto out_unlock; } + } +if (iocb->ki_flags &IOCB_DIRECT ) { +/* +* Convert inline data for Direct I/O before entering +* f2fs_direct_IO(). +*/ + ret =f2fs_convert_inline_inode (inode); +if (ret) + goto out_unlock; + } - ret =__generic_file_write_iter (iocb, from); +/* Possibly preallocate the blocks for the write. */ + target_size = iocb->ki_pos +iov_iter_count (from); + preallocated =f2fs_preallocate_blocks (iocb, from); +if (preallocated <0 ) { + ret = preallocated; + goto out_unlock; + } -/* Don't leave any preallocated blocks around past i_size. */ -if (preallocated >0 && inode->i_size < target_size) { -down_write (&F2FS_I (inode)->i_gc_rwsem[WRITE ]); -down_write (&F2FS_I (inode)->i_mmap_sem); -f2fs_truncate (inode); -up_write (&F2FS_I (inode)->i_mmap_sem); -up_write (&F2FS_I (inode)->i_gc_rwsem[WRITE ]); - } -clear_inode_flag (inode,FI_PREALLOCATED_ALL ); + ret =__generic_file_write_iter (iocb, from); -if (ret >0 ) -f2fs_update_iostat (F2FS_I_SB (inode),APP_WRITE_IO , ret); +/* Don't leave any preallocated blocks around past i_size. */ +if (preallocated >0 && inode->i_size < target_size) { +down_write (&F2FS_I (inode)->i_gc_rwsem[WRITE ]); +down_write (&F2FS_I (inode)->i_mmap_sem); +f2fs_truncate (inode); +up_write (&F2FS_I (inode)->i_mmap_sem); +up_write (&F2FS_I (inode)->i_gc_rwsem[WRITE ]); } +clear_inode_flag (inode,FI_PREALLOCATED_ALL ); + +if (ret >0 ) +f2fs_update_iostat (F2FS_I_SB (inode),APP_WRITE_IO , ret); out_unlock:inode_unlock (inode); out:
Signature · 1 line
2.32.0
PATCH 5/9 f2fs: fix the f2fs_file_write_iter tracepoint
In reply to Eric BiggersFrom: Eric Biggers <[email protected]>
Pass in the original position and count rather than the position and count that were updated by the write. Also use the correct types for all arguments, in particular the file offset which was being truncated to 32 bits on 32-bit platforms.
--- fs/f2fs/file.c | 5 +++-- include/trace/events/f2fs.h | 12 ++++++------ 2 files changed, 9 insertions(+), 8 deletions(-)
fs/f2fs/file.c +3 -2
@@ -4282,6 +4282,8 @@ static ssize_t f2fs_file_write_iter(struct kiocb *iocb, struct iov_iter *from) {struct file *file = iocb->ki_filp;struct inode *inode =file_inode (file); +const loff_t orig_pos = iocb->ki_pos; +const size_t orig_count =iov_iter_count (from);loff_t target_size;int preallocated;ssize_t ret;
@@ -4363,8 +4365,7 @@ static ssize_t f2fs_file_write_iter(struct kiocb *iocb, struct iov_iter *from) out_unlock:inode_unlock (inode); out: -trace_f2fs_file_write_iter (inode, iocb->ki_pos, -iov_iter_count (from), ret); +trace_f2fs_file_write_iter (inode, orig_pos, orig_count, ret);if (ret >0 ) ret =generic_write_sync (iocb, ret);return ret;
include/trace/events/f2fs.h +6 -6
@@ -540,17 +540,17 @@ TRACE_EVENT(f2fs_truncate_partial_nodes, TRACE_EVENT(f2fs_file_write_iter, - TP_PROTO(struct inode *inode, unsigned long offset, - unsigned long length, int ret), + TP_PROTO(struct inode *inode, loff_t offset, size_t length, + ssize_t ret), TP_ARGS(inode, offset, length, ret), TP_STRUCT__entry( __field(dev_t, dev) __field(ino_t, ino) - __field(unsigned long, offset) - __field(unsigned long, length) - __field(int, ret) + __field(loff_t, offset) + __field(size_t, length) + __field(ssize_t, ret) ), TP_fast_assign(
@@ -562,7 +562,7 @@ TRACE_EVENT(f2fs_file_write_iter, ), TP_printk("dev = (%d,%d), ino = %lu, " - "offset = %lu, length = %lu, written(err) = %d", + "offset = %lld, length = %zu, written(err) = %zd", show_dev_ino(__entry), __entry->offset, __entry->length,
Signature · 1 line
2.32.0
PATCH 6/9 f2fs: implement iomap operations
In reply to Eric BiggersFrom: Eric Biggers <[email protected]>
Implement 'struct iomap_ops' and 'struct iomap_dio_ops' for f2fs, in preparation for making f2fs use iomap for direct I/O.
Note that f2fs_iomap_ops may be used for other things besides direct I/O in the future; however, for now I've only tested it for direct I/O.
--- fs/f2fs/Kconfig | 1 + fs/f2fs/data.c | 95 +++++++++++++++++++++++++++++++++++++++++++++++-- fs/f2fs/f2fs.h | 2 ++ 3 files changed, 96 insertions(+), 2 deletions(-)
fs/f2fs/Kconfig +1 -0
@@ -7,6 +7,7 @@ config F2FS_FS select CRYPTO_CRC32 select F2FS_FS_XATTR if FS_ENCRYPTION select FS_ENCRYPTION_ALGS if FS_ENCRYPTION + select FS_IOMAP select LZ4_COMPRESS if F2FS_FS_LZ4 select LZ4_DECOMPRESS if F2FS_FS_LZ4 select LZ4HC_COMPRESS if F2FS_FS_LZ4HC
fs/f2fs/data.c +93 -2
122 lines not on this page · raw message
fs/f2fs/f2fs.h +2 -0
@@ -3639,6 +3639,8 @@ int f2fs_init_post_read_processing(void);void f2fs_destroy_post_read_processing (void );int f2fs_init_post_read_wq (struct f2fs_sb_info *sbi);void f2fs_destroy_post_read_wq (struct f2fs_sb_info *sbi); +extern const struct iomap_ops f2fs_iomap_ops; +extern const struct iomap_dio_ops f2fs_iomap_dio_ops;/* * gc.c
Signature · 1 line
2.32.0
PATCH 7/9 f2fs: use iomap for direct I/O reads
In reply to Eric BiggersFrom: Eric Biggers <[email protected]>
Convert f2fs_file_read_iter() to use iomap_dio_rw() for direct I/O rather than using f2fs_direct_IO() via generic_file_read_iter().
Besides the new direct I/O implementation being more efficient (especially with regards to the block mapping), this change retains the existing f2fs behavior such as the conditions for falling back to buffered I/O, the locking of i_gc_rwsem[READ], the iostat gathering, and the f2fs_direct_IO_{enter,exit} tracepoints. An exception is that we no longer fall back to a buffered I/O read if a direct I/O read returns a short read (previously this was done by generic_file_read_iter()), as this doesn't appear to be a useful thing to do on f2fs.
--- fs/f2fs/f2fs.h | 7 ++--- fs/f2fs/file.c | 84 +++++++++++++++++++++++++++++++++++++++++++++++--- 2 files changed, 82 insertions(+), 9 deletions(-)
fs/f2fs/f2fs.h +3 -4
@@ -3243,10 +3243,9 @@ static inline void f2fs_update_iostat(struct f2fs_sb_info *sbi, sbi->rw_iostat[APP_WRITE_IO ] - sbi->rw_iostat[APP_DIRECT_IO ]; -if (type ==APP_READ_IO || type ==APP_DIRECT_READ_IO ) - sbi->rw_iostat[APP_BUFFERED_READ_IO ] = - sbi->rw_iostat[APP_READ_IO ] - - sbi->rw_iostat[APP_DIRECT_READ_IO ]; +if (type ==APP_BUFFERED_READ_IO || type ==APP_DIRECT_READ_IO ) + sbi->rw_iostat[APP_READ_IO ] += io_bytes; +spin_unlock (&sbi->iostat_lock);f2fs_record_iostat (sbi);
fs/f2fs/file.c +79 -5
105 lines not on this page · raw message
Signature · 1 line
2.32.0
PATCH 8/9 f2fs: use iomap for direct I/O writes
In reply to Eric BiggersFrom: Eric Biggers <[email protected]>
Convert f2fs_file_write_iter() to use iomap_dio_rw() for direct I/O rather than using f2fs_direct_IO() via __generic_file_write_iter().
This is more complicated than the read-side conversion, but it follows a similar pattern. Some logic in __generic_file_write_iter() needed to be re-implemented, while other things are now handled by iomap_dio_rw(). Existing f2fs behavior such as the conditions for falling back to buffered I/O is retained, except for some things which shouldn't matter such as the exact time that the timestamps are updated.
--- fs/f2fs/data.c | 7 +- fs/f2fs/f2fs.h | 7 +- fs/f2fs/file.c | 215 ++++++++++++++++++++++++++++++++++++++++--------- 3 files changed, 180 insertions(+), 49 deletions(-)
fs/f2fs/data.c +1 -6
@@ -1363,11 +1363,6 @@ static int __allocate_data_block(struct dnode_of_data *dn, int seg_type)f2fs_invalidate_compress_page (sbi, old_blkaddr); }f2fs_update_data_blkaddr (dn, dn->data_blkaddr); - -/* -* i_size will be updated by direct_IO. Otherwise, we'll get stale -* data from unwritten block via dio_read. -*/ return 0 ; }
@@ -3130,7 +3125,7 @@ static int f2fs_write_data_pages(struct address_space *mapping, FS_CP_DATA_IO : FS_DATA_IO); } -static void f2fs_write_failed (struct inode *inode,loff_t to) +void f2fs_write_failed (struct inode *inode,loff_t to) {loff_t i_size =i_size_read (inode);
fs/f2fs/f2fs.h +3 -4
@@ -3238,10 +3238,8 @@ static inline void f2fs_update_iostat(struct f2fs_sb_info *sbi,spin_lock (&sbi->iostat_lock); sbi->rw_iostat[type] += io_bytes; -if (type ==APP_WRITE_IO || type ==APP_DIRECT_IO ) - sbi->rw_iostat[APP_BUFFERED_IO ] = - sbi->rw_iostat[APP_WRITE_IO ] - - sbi->rw_iostat[APP_DIRECT_IO ]; +if (type ==APP_BUFFERED_IO || type ==APP_DIRECT_IO ) + sbi->rw_iostat[APP_WRITE_IO ] += io_bytes;if (type ==APP_BUFFERED_READ_IO || type ==APP_DIRECT_READ_IO ) sbi->rw_iostat[APP_READ_IO ] += io_bytes;
@@ -3625,6 +3623,7 @@ int f2fs_write_single_data_page(struct page *page, int *submitted,struct writeback_control *wbc, enum iostat_type io_type, int compr_blocks, bool allow_balance); +void f2fs_write_failed (struct inode *inode,loff_t to);void f2fs_invalidate_page (struct page *page,unsigned int offset,unsigned int length);int f2fs_release_page (struct page *page,gfp_t wait);
fs/f2fs/file.c +176 -39
272 lines not on this page · raw message
Signature · 1 line
2.32.0
PATCH 9/9 f2fs: remove f2fs_direct_IO()
In reply to Eric BiggersFrom: Eric Biggers <[email protected]>
Remove f2fs_direct_IO(), since it is no longer used because f2fs now uses iomap_dio_rw() instead.
Set ->direct_IO to noop_direct_IO rather than NULL. This is needed to continue to mark the inodes as supporting direct I/O, as mentioned in the comment for noop_direct_IO().
--- fs/f2fs/data.c | 180 +------------------------------------------------ 1 file changed, 1 insertion(+), 179 deletions(-)
fs/f2fs/data.c +1 -179
@@ -1650,47 +1650,6 @@ static inline u64 blks_to_bytes(struct inode *inode, u64 blks)return (blks << inode->i_blkbits); } -static int __get_data_block (struct inode *inode,sector_t iblock, -struct buffer_head *bh,int create,int flag, -pgoff_t *next_pgofs,int seg_type,bool may_write) -{ -struct f2fs_map_blocks map; -int err; - - map.m_lblk = iblock; - map.m_len =bytes_to_blks (inode, bh->b_size); - map.m_next_pgofs = next_pgofs; - map.m_next_extent =NULL ; - map.m_seg_type = seg_type; - map.m_may_create = may_write; - - err =f2fs_map_blocks (inode, &map, create, flag); -if (!err) { -map_bh (bh, inode->i_sb, map.m_pblk); - bh->b_state = (bh->b_state & ~F2FS_MAP_FLAGS ) | map.m_flags; - bh->b_size =blks_to_bytes (inode, map.m_len); - } -return err; -} - -static int get_data_block_dio_write (struct inode *inode,sector_t iblock, -struct buffer_head *bh_result,int create) -{ -return __get_data_block (inode, iblock, bh_result, create, -F2FS_GET_BLOCK_DIO ,NULL , -f2fs_rw_hint_to_seg_type (inode->i_write_hint), - true); -} - -static int get_data_block_dio (struct inode *inode,sector_t iblock, -struct buffer_head *bh_result,int create) -{ -return __get_data_block (inode, iblock, bh_result, create, -F2FS_GET_BLOCK_DIO ,NULL , -f2fs_rw_hint_to_seg_type (inode->i_write_hint), - false); -} -static int f2fs_xattr_fiemap (struct inode *inode,struct fiemap_extent_info *fieinfo) {
@@ -3410,29 +3369,6 @@ static int f2fs_write_end(struct file *file,return copied; } -static int check_direct_IO (struct inode *inode,struct iov_iter *iter, -loff_t offset) -{ -unsigned i_blkbits =READ_ONCE (inode->i_blkbits); -unsigned blkbits = i_blkbits; -unsigned blocksize_mask = (1 << blkbits) -1 ; -unsigned long align = offset |iov_iter_alignment (iter); -struct block_device *bdev = inode->i_sb->s_bdev; - -if (iov_iter_rw (iter) ==READ && offset >=i_size_read (inode)) -return 1 ; - -if (align & blocksize_mask) { -if (bdev) - blkbits =blksize_bits (bdev_logical_block_size (bdev)); - blocksize_mask = (1 << blkbits) -1 ; -if (align & blocksize_mask) -return -EINVAL ; -return 1 ; - } -return 0 ; -} -static void f2fs_dio_end_io (struct bio *bio) {struct f2fs_private_dio *dio = bio->bi_private;
@@ -3448,35 +3384,6 @@ static void f2fs_dio_end_io(struct bio *bio)bio_endio (bio); } -static void f2fs_dio_submit_bio_old (struct bio *bio,struct inode *inode, -loff_t file_offset) -{ -struct f2fs_private_dio *dio; -bool write = (bio_op (bio) ==REQ_OP_WRITE ); - - dio =f2fs_kzalloc (F2FS_I_SB (inode), -sizeof (struct f2fs_private_dio ),GFP_NOFS ); -if (!dio) - goto out; - - dio->inode = inode; - dio->orig_end_io = bio->bi_end_io; - dio->orig_private = bio->bi_private; - dio->write = write; - - bio->bi_end_io = f2fs_dio_end_io; - bio->bi_private = dio; - -inc_page_count (F2FS_I_SB (inode), - write ?F2FS_DIO_WRITE :F2FS_DIO_READ ); - -submit_bio (bio); -return ; -out: - bio->bi_status =BLK_STS_IOERR ; -bio_endio (bio); -} -static blk_qc_t f2fs_dio_submit_bio (struct inode *inode,struct iomap *iomap,struct bio *bio,loff_t file_offset) {
@@ -3506,91 +3413,6 @@ static blk_qc_t f2fs_dio_submit_bio(struct inode *inode, struct iomap *iomap,return BLK_QC_T_NONE ; } -static ssize_t f2fs_direct_IO (struct kiocb *iocb,struct iov_iter *iter) -{ -struct address_space *mapping = iocb->ki_filp->f_mapping; -struct inode *inode = mapping->host; -struct f2fs_sb_info *sbi =F2FS_I_SB (inode); -struct f2fs_inode_info *fi =F2FS_I (inode); -size_t count =iov_iter_count (iter); -loff_t offset = iocb->ki_pos; -int rw =iov_iter_rw (iter); -int err; -enum rw_hint hint = iocb->ki_hint; -int whint_mode =F2FS_OPTION (sbi).whint_mode; -bool do_opu; - - err =check_direct_IO (inode, iter, offset); -if (err) -return err <0 ? err :0 ; - -if (f2fs_force_buffered_io (inode, iocb, iter)) -return 0 ; - - do_opu = (rw ==WRITE &&f2fs_lfs_mode (sbi)); - -trace_f2fs_direct_IO_enter (inode, offset, count, rw); - -if (rw ==WRITE && whint_mode ==WHINT_MODE_OFF ) - iocb->ki_hint =WRITE_LIFE_NOT_SET ; - -if (iocb->ki_flags &IOCB_NOWAIT ) { -if (!down_read_trylock (&fi->i_gc_rwsem[rw])) { - iocb->ki_hint = hint; - err = -EAGAIN ; - goto out; - } -if (do_opu && !down_read_trylock (&fi->i_gc_rwsem[READ ])) { -up_read (&fi->i_gc_rwsem[rw]); - iocb->ki_hint = hint; - err = -EAGAIN ; - goto out; - } - }else { -down_read (&fi->i_gc_rwsem[rw]); -if (do_opu) -down_read (&fi->i_gc_rwsem[READ ]); - } - - err =__blockdev_direct_IO (iocb, inode, inode->i_sb->s_bdev, - iter, rw ==WRITE ? get_data_block_dio_write : - get_data_block_dio,NULL , f2fs_dio_submit_bio_old, - rw ==WRITE ?DIO_LOCKING |DIO_SKIP_HOLES : -DIO_SKIP_HOLES ); - -if (do_opu) -up_read (&fi->i_gc_rwsem[READ ]); - -up_read (&fi->i_gc_rwsem[rw]); - -if (rw ==WRITE ) { -if (whint_mode ==WHINT_MODE_OFF ) - iocb->ki_hint = hint; -if (err >0 ) { -f2fs_update_iostat (F2FS_I_SB (inode),APP_DIRECT_IO , - err); -if (!do_opu) -set_inode_flag (inode,FI_UPDATE_WRITE ); - }else if (err == -EIOCBQUEUED ) { -f2fs_update_iostat (F2FS_I_SB (inode),APP_DIRECT_IO , - count -iov_iter_count (iter)); - }else if (err <0 ) { -f2fs_write_failed (inode, offset + count); - } - }else { -if (err >0 ) -f2fs_update_iostat (sbi,APP_DIRECT_READ_IO , err); -else if (err == -EIOCBQUEUED ) -f2fs_update_iostat (F2FS_I_SB (inode),APP_DIRECT_READ_IO , - count -iov_iter_count (iter)); - } - -out: -trace_f2fs_direct_IO_exit (inode, offset, count, rw, err); - -return err; -} -void f2fs_invalidate_page (struct page *page,unsigned int offset,unsigned int length) {
@@ -4046,7 +3868,7 @@ const struct address_space_operations f2fs_dblock_aops = { .set_page_dirty = f2fs_set_data_page_dirty, .invalidatepage = f2fs_invalidate_page, .releasepage = f2fs_release_page, - .direct_IO = f2fs_direct_IO, + .direct_IO = noop_direct_IO, .bmap = f2fs_bmap, .swap_activate = f2fs_swap_activate, .swap_deactivate = f2fs_swap_deactivate,
Signature · 1 line
2.32.0
Re: [PATCH 2/9] f2fs: remove allow_outplace_dio()
In reply to Eric Biggersfs/f2fs/data.c static ssize_t f2fs_direct_IO(struct kiocb *iocb, struct iov_iter *iter) · line 3554
Quoted 1 line · Eric Biggers
fs/f2fs/data.c +1
-0+ do_opu = (rw ==WRITE &&f2fs_lfs_mode (sbi));
Nit: no need for the braces.
_______________________________________________
Linux-f2fs-devel mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
Re: [PATCH 6/9] f2fs: implement iomap operations
In reply to Eric BiggersQuoted 13 lines · Eric Biggers
(quoted diff) +13
-0+static blk_qc_t f2fs_dio_submit_bio(struct inode *inode, struct iomap *iomap, + struct bio *bio, loff_t file_offset) +{ + struct f2fs_private_dio *dio; + bool write = (bio_op(bio) == REQ_OP_WRITE); + + dio = f2fs_kzalloc(F2FS_I_SB(inode), + sizeof(struct f2fs_private_dio), GFP_NOFS); + if (!dio) + goto out; + + dio->inode = inode; + dio->orig_end_io = bio->bi_end_io;
Review
Quoted 10 lines
(quoted diff) +10
-0+ dio->orig_private = bio->bi_private; + dio->write = write; + + bio->bi_end_io = f2fs_dio_end_io; + bio->bi_private = dio; + + inc_page_count(F2FS_I_SB(inode), + write ? F2FS_DIO_WRITE : F2FS_DIO_READ); + + return submit_bio(bio);
I don't think there is any need for this mess. The F2FS_DIO_WRITE / F2FS_DIO_READ counts are only used to check if there is any inflight I/O at all. So instead we can increment them once before calling iomap_dio_rw, and decrement them in ->end_io or for a failure/noop exit from iomap_dio_rw. Untested patch below. Note that all this would be much simpler to review if the last three patches were folded into a single one.
fs/f2fs/data.c +13 -45
@@ -3369,50 +3369,6 @@ static int f2fs_write_end(struct file *file,return copied; } -static void f2fs_dio_end_io (struct bio *bio) -{ -struct f2fs_private_dio *dio = bio->bi_private; - -dec_page_count (F2FS_I_SB (dio->inode), - dio->write ?F2FS_DIO_WRITE :F2FS_DIO_READ ); - - bio->bi_private = dio->orig_private; - bio->bi_end_io = dio->orig_end_io; - -kfree (dio); - -bio_endio (bio); -} - -static blk_qc_t f2fs_dio_submit_bio (struct inode *inode,struct iomap *iomap, -struct bio *bio,loff_t file_offset) -{ -struct f2fs_private_dio *dio; -bool write = (bio_op (bio) ==REQ_OP_WRITE ); - - dio =f2fs_kzalloc (F2FS_I_SB (inode), -sizeof (struct f2fs_private_dio ),GFP_NOFS ); -if (!dio) - goto out; - - dio->inode = inode; - dio->orig_end_io = bio->bi_end_io; - dio->orig_private = bio->bi_private; - dio->write = write; - - bio->bi_end_io = f2fs_dio_end_io; - bio->bi_private = dio; - -inc_page_count (F2FS_I_SB (inode), - write ?F2FS_DIO_WRITE :F2FS_DIO_READ ); - -return submit_bio (bio); -out: - bio->bi_status =BLK_STS_IOERR ; -bio_endio (bio); -return BLK_QC_T_NONE ; -} -void f2fs_invalidate_page (struct page *page,unsigned int offset,unsigned int length) {
@@ -4006,6 +3962,18 @@ const struct iomap_ops f2fs_iomap_ops = { .iomap_begin = f2fs_iomap_begin, }; +static int f2fs_dio_end_io (struct kiocb *iocb,ssize_t size,int error, +unsigned flags) +{ +struct f2fs_sb_info *sbi =F2FS_I_SB (file_inode (iocb->ki_filp)); + +if (iocb->ki_flags &IOCB_WRITE ) +dec_page_count (sbi,F2FS_DIO_WRITE ); +else +dec_page_count (sbi,F2FS_DIO_READ ); +return 0 ; +} +const struct iomap_dio_ops f2fs_iomap_dio_ops = { - .submit_io = f2fs_dio_submit_bio, + .end_io = f2fs_dio_end_io, };
fs/f2fs/f2fs.h +0 -7
@@ -1750,13 +1750,6 @@ struct f2fs_sb_info {#endif }; -struct f2fs_private_dio { -struct inode *inode; -void *orig_private; -bio_end_io_t *orig_end_io; -bool write; -}; -#ifdef CONFIG_F2FS_FAULT_INJECTION #define f2fs_show_injection_info (sbi, type) \ printk_ratelimited("%sF2FS-fs (%s) : inject %s in %s of %pS\n", \
fs/f2fs/file.c +7 -0
@@ -4259,6 +4259,7 @@ static ssize_t f2fs_dio_read_iter(struct kiocb *iocb, struct iov_iter *to)down_read (&fi->i_gc_rwsem[READ ]); } +inc_page_count (F2FS_I_SB (inode),F2FS_DIO_READ ); ret =iomap_dio_rw (iocb, to, &f2fs_iomap_ops, &f2fs_iomap_dio_ops,0 );up_read (&fi->i_gc_rwsem[READ ]);
@@ -4270,6 +4271,8 @@ static ssize_t f2fs_dio_read_iter(struct kiocb *iocb, struct iov_iter *to)else if (ret == -EIOCBQUEUED )f2fs_update_iostat (F2FS_I_SB (inode),APP_DIRECT_READ_IO , count -iov_iter_count (to)); +else +dec_page_count (F2FS_I_SB (inode),F2FS_DIO_READ ); out:trace_f2fs_direct_IO_exit (inode, pos, count,READ , ret);return ret;
@@ -4446,6 +4449,7 @@ static ssize_t f2fs_dio_write_iter(struct kiocb *iocb, struct iov_iter *from,if (pos + count > inode->i_size) dio_flags |=IOMAP_DIO_FORCE_WAIT ; +inc_page_count (F2FS_I_SB (inode),F2FS_DIO_WRITE ); ret =iomap_dio_rw (iocb, from, &f2fs_iomap_ops, &f2fs_iomap_dio_ops, dio_flags);if (ret == -ENOTBLK )
@@ -4459,6 +4463,9 @@ static ssize_t f2fs_dio_write_iter(struct kiocb *iocb, struct iov_iter *from,up_read (&fi->i_gc_rwsem[WRITE ]); +if (ret <=0 && ret != -EIOCBQUEUED ) +dec_page_count (F2FS_I_SB (inode),F2FS_DIO_WRITE ); +if (ret <0 ) {if (ret == -EIOCBQUEUED ) f2fs_update_iostat(sbi, APP_DIRECT_IO,
_______________________________________________
Linux-f2fs-devel mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
Jaegeuk Kim
maintainerRe: [PATCH 6/9] f2fs: implement iomap operations
Quoted 25 lines · Christoph Hellwig
Quoted 13 lines · Eric Biggers
(quoted diff) +13
-0+static blk_qc_t f2fs_dio_submit_bio(struct inode *inode, struct iomap *iomap, + struct bio *bio, loff_t file_offset) +{ + struct f2fs_private_dio *dio; + bool write = (bio_op(bio) == REQ_OP_WRITE); + + dio = f2fs_kzalloc(F2FS_I_SB(inode), + sizeof(struct f2fs_private_dio), GFP_NOFS); + if (!dio) + goto out; + + dio->inode = inode; + dio->orig_end_io = bio->bi_end_io;Review
Quoted 10 lines
(quoted diff) +10
-0+ dio->orig_private = bio->bi_private; + dio->write = write; + + bio->bi_end_io = f2fs_dio_end_io; + bio->bi_private = dio; + + inc_page_count(F2FS_I_SB(inode), + write ? F2FS_DIO_WRITE : F2FS_DIO_READ); + + return submit_bio(bio);
Quoted 7 lines
I don't think there is any need for this mess. The
F2FS_DIO_WRITE/F2FS_DIO_READcounts are only used to check if there is any inflight I/O at all. So instead we can increment them once before callingiomap_dio_rw, and decrement them in ->end_io or for a failure/noop exit fromiomap_dio_rw. Untested patch below. Note that all this would be much simpler to review if the last three patches were folded into a single one.
Eric, wdyt?
I've merged v1 to v5, including Christoph's comment in v2.
Quoted 133 lines
fs/f2fs/data.c +13
-45@@ -3369,50 +3369,6 @@ static int f2fs_write_end(struct file *file,return copied; } -static void f2fs_dio_end_io (struct bio *bio) -{ -struct f2fs_private_dio *dio = bio->bi_private; - -dec_page_count (F2FS_I_SB (dio->inode), - dio->write ?F2FS_DIO_WRITE :F2FS_DIO_READ ); - - bio->bi_private = dio->orig_private; - bio->bi_end_io = dio->orig_end_io; - -kfree (dio); - -bio_endio (bio); -} - -static blk_qc_t f2fs_dio_submit_bio (struct inode *inode,struct iomap *iomap, -struct bio *bio,loff_t file_offset) -{ -struct f2fs_private_dio *dio; -bool write = (bio_op (bio) ==REQ_OP_WRITE ); - - dio =f2fs_kzalloc (F2FS_I_SB (inode), -sizeof (struct f2fs_private_dio ),GFP_NOFS ); -if (!dio) - goto out; - - dio->inode = inode; - dio->orig_end_io = bio->bi_end_io; - dio->orig_private = bio->bi_private; - dio->write = write; - - bio->bi_end_io = f2fs_dio_end_io; - bio->bi_private = dio; - -inc_page_count (F2FS_I_SB (inode), - write ?F2FS_DIO_WRITE :F2FS_DIO_READ ); - -return submit_bio (bio); -out: - bio->bi_status =BLK_STS_IOERR ; -bio_endio (bio); -return BLK_QC_T_NONE ; -} -void f2fs_invalidate_page (struct page *page,unsigned int offset,unsigned int length) {@@ -4006,6 +3962,18 @@ const struct iomap_ops f2fs_iomap_ops = { .iomap_begin = f2fs_iomap_begin, }; +static int f2fs_dio_end_io (struct kiocb *iocb,ssize_t size,int error, +unsigned flags) +{ +struct f2fs_sb_info *sbi =F2FS_I_SB (file_inode (iocb->ki_filp)); + +if (iocb->ki_flags &IOCB_WRITE ) +dec_page_count (sbi,F2FS_DIO_WRITE ); +else +dec_page_count (sbi,F2FS_DIO_READ ); +return 0 ; +} +const struct iomap_dio_ops f2fs_iomap_dio_ops = { - .submit_io = f2fs_dio_submit_bio, + .end_io = f2fs_dio_end_io, };fs/f2fs/f2fs.h +0
-7@@ -1750,13 +1750,6 @@ struct f2fs_sb_info {#endif }; -struct f2fs_private_dio { -struct inode *inode; -void *orig_private; -bio_end_io_t *orig_end_io; -bool write; -}; -#ifdef CONFIG_F2FS_FAULT_INJECTION #define f2fs_show_injection_info (sbi, type) \ printk_ratelimited("%sF2FS-fs (%s) : inject %s in %s of %pS\n", \fs/f2fs/file.c +7
-0@@ -4259,6 +4259,7 @@ static ssize_t f2fs_dio_read_iter(struct kiocb *iocb, struct iov_iter *to)down_read (&fi->i_gc_rwsem[READ ]); } +inc_page_count (F2FS_I_SB (inode),F2FS_DIO_READ ); ret =iomap_dio_rw (iocb, to, &f2fs_iomap_ops, &f2fs_iomap_dio_ops,0 );up_read (&fi->i_gc_rwsem[READ ]);@@ -4270,6 +4271,8 @@ static ssize_t f2fs_dio_read_iter(struct kiocb *iocb, struct iov_iter *to)else if (ret == -EIOCBQUEUED )f2fs_update_iostat (F2FS_I_SB (inode),APP_DIRECT_READ_IO , count -iov_iter_count (to)); +else +dec_page_count (F2FS_I_SB (inode),F2FS_DIO_READ ); out:trace_f2fs_direct_IO_exit (inode, pos, count,READ , ret);return ret;@@ -4446,6 +4449,7 @@ static ssize_t f2fs_dio_write_iter(struct kiocb *iocb, struct iov_iter *from,if (pos + count > inode->i_size) dio_flags |=IOMAP_DIO_FORCE_WAIT ; +inc_page_count (F2FS_I_SB (inode),F2FS_DIO_WRITE ); ret =iomap_dio_rw (iocb, from, &f2fs_iomap_ops, &f2fs_iomap_dio_ops, dio_flags);if (ret == -ENOTBLK )@@ -4459,6 +4463,9 @@ static ssize_t f2fs_dio_write_iter(struct kiocb *iocb, struct iov_iter *from,up_read (&fi->i_gc_rwsem[WRITE ]); +if (ret <=0 && ret != -EIOCBQUEUED ) +dec_page_count (F2FS_I_SB (inode),F2FS_DIO_WRITE ); +if (ret <0 ) {if (ret == -EIOCBQUEUED ) f2fs_update_iostat(sbi, APP_DIRECT_IO,
Jaegeuk Kim
maintainerRe: [PATCH 6/9] f2fs: implement iomap operations
Quoted 34 lines · Jaegeuk Kim
Quoted 25 lines · Christoph Hellwig
Quoted 13 lines · Eric Biggers
(quoted diff) +13
-0+static blk_qc_t f2fs_dio_submit_bio(struct inode *inode, struct iomap *iomap, + struct bio *bio, loff_t file_offset) +{ + struct f2fs_private_dio *dio; + bool write = (bio_op(bio) == REQ_OP_WRITE); + + dio = f2fs_kzalloc(F2FS_I_SB(inode), + sizeof(struct f2fs_private_dio), GFP_NOFS); + if (!dio) + goto out; + + dio->inode = inode; + dio->orig_end_io = bio->bi_end_io;Review
Quoted 10 lines
(quoted diff) +10
-0+ dio->orig_private = bio->bi_private; + dio->write = write; + + bio->bi_end_io = f2fs_dio_end_io; + bio->bi_private = dio; + + inc_page_count(F2FS_I_SB(inode), + write ? F2FS_DIO_WRITE : F2FS_DIO_READ); + + return submit_bio(bio);Quoted 7 lines
I don't think there is any need for this mess. The
F2FS_DIO_WRITE/F2FS_DIO_READcounts are only used to check if there is any inflight I/O at all. So instead we can increment them once before callingiomap_dio_rw, and decrement them in ->end_io or for a failure/noop exit fromiomap_dio_rw. Untested patch below. Note that all this would be much simpler to review if the last three patches were folded into a single one.
Quoted 3 lines
Eric, wdyt?
I've merged v1 to v5, including Christoph's comment in v2.
Sorry, I mean patch #1 to #5. You can find them in:
https://git.kernel.org/pub/scm/linux/kernel/git/jaegeuk/f2fs.git/log/?h=dev
Quoted 134 lines
Quoted 134 lines
fs/f2fs/data.c +13
-45@@ -3369,50 +3369,6 @@ static int f2fs_write_end(struct file *file,return copied; } -static void f2fs_dio_end_io (struct bio *bio) -{ -struct f2fs_private_dio *dio = bio->bi_private; - -dec_page_count (F2FS_I_SB (dio->inode), - dio->write ?F2FS_DIO_WRITE :F2FS_DIO_READ ); - - bio->bi_private = dio->orig_private; - bio->bi_end_io = dio->orig_end_io; - -kfree (dio); - -bio_endio (bio); -} - -static blk_qc_t f2fs_dio_submit_bio (struct inode *inode,struct iomap *iomap, -struct bio *bio,loff_t file_offset) -{ -struct f2fs_private_dio *dio; -bool write = (bio_op (bio) ==REQ_OP_WRITE ); - - dio =f2fs_kzalloc (F2FS_I_SB (inode), -sizeof (struct f2fs_private_dio ),GFP_NOFS ); -if (!dio) - goto out; - - dio->inode = inode; - dio->orig_end_io = bio->bi_end_io; - dio->orig_private = bio->bi_private; - dio->write = write; - - bio->bi_end_io = f2fs_dio_end_io; - bio->bi_private = dio; - -inc_page_count (F2FS_I_SB (inode), - write ?F2FS_DIO_WRITE :F2FS_DIO_READ ); - -return submit_bio (bio); -out: - bio->bi_status =BLK_STS_IOERR ; -bio_endio (bio); -return BLK_QC_T_NONE ; -} -void f2fs_invalidate_page (struct page *page,unsigned int offset,unsigned int length) {@@ -4006,6 +3962,18 @@ const struct iomap_ops f2fs_iomap_ops = { .iomap_begin = f2fs_iomap_begin, }; +static int f2fs_dio_end_io (struct kiocb *iocb,ssize_t size,int error, +unsigned flags) +{ +struct f2fs_sb_info *sbi =F2FS_I_SB (file_inode (iocb->ki_filp)); + +if (iocb->ki_flags &IOCB_WRITE ) +dec_page_count (sbi,F2FS_DIO_WRITE ); +else +dec_page_count (sbi,F2FS_DIO_READ ); +return 0 ; +} +const struct iomap_dio_ops f2fs_iomap_dio_ops = { - .submit_io = f2fs_dio_submit_bio, + .end_io = f2fs_dio_end_io, };fs/f2fs/f2fs.h +0
-7@@ -1750,13 +1750,6 @@ struct f2fs_sb_info {#endif }; -struct f2fs_private_dio { -struct inode *inode; -void *orig_private; -bio_end_io_t *orig_end_io; -bool write; -}; -#ifdef CONFIG_F2FS_FAULT_INJECTION #define f2fs_show_injection_info (sbi, type) \ printk_ratelimited("%sF2FS-fs (%s) : inject %s in %s of %pS\n", \fs/f2fs/file.c +7
-0@@ -4259,6 +4259,7 @@ static ssize_t f2fs_dio_read_iter(struct kiocb *iocb, struct iov_iter *to)down_read (&fi->i_gc_rwsem[READ ]); } +inc_page_count (F2FS_I_SB (inode),F2FS_DIO_READ ); ret =iomap_dio_rw (iocb, to, &f2fs_iomap_ops, &f2fs_iomap_dio_ops,0 );up_read (&fi->i_gc_rwsem[READ ]);@@ -4270,6 +4271,8 @@ static ssize_t f2fs_dio_read_iter(struct kiocb *iocb, struct iov_iter *to)else if (ret == -EIOCBQUEUED )f2fs_update_iostat (F2FS_I_SB (inode),APP_DIRECT_READ_IO , count -iov_iter_count (to)); +else +dec_page_count (F2FS_I_SB (inode),F2FS_DIO_READ ); out:trace_f2fs_direct_IO_exit (inode, pos, count,READ , ret);return ret;@@ -4446,6 +4449,7 @@ static ssize_t f2fs_dio_write_iter(struct kiocb *iocb, struct iov_iter *from,if (pos + count > inode->i_size) dio_flags |=IOMAP_DIO_FORCE_WAIT ; +inc_page_count (F2FS_I_SB (inode),F2FS_DIO_WRITE ); ret =iomap_dio_rw (iocb, from, &f2fs_iomap_ops, &f2fs_iomap_dio_ops, dio_flags);if (ret == -ENOTBLK )@@ -4459,6 +4463,9 @@ static ssize_t f2fs_dio_write_iter(struct kiocb *iocb, struct iov_iter *from,up_read (&fi->i_gc_rwsem[WRITE ]); +if (ret <=0 && ret != -EIOCBQUEUED ) +dec_page_count (F2FS_I_SB (inode),F2FS_DIO_WRITE ); +if (ret <0 ) {if (ret == -EIOCBQUEUED ) f2fs_update_iostat(sbi, APP_DIRECT_IO,
Re: [PATCH 6/9] f2fs: implement iomap operations
In reply to Jaegeuk KimQuoted 34 lines · Jaegeuk Kim
Quoted 25 lines · Christoph Hellwig
Quoted 13 lines · Eric Biggers
(quoted diff) +13
-0+static blk_qc_t f2fs_dio_submit_bio(struct inode *inode, struct iomap *iomap, + struct bio *bio, loff_t file_offset) +{ + struct f2fs_private_dio *dio; + bool write = (bio_op(bio) == REQ_OP_WRITE); + + dio = f2fs_kzalloc(F2FS_I_SB(inode), + sizeof(struct f2fs_private_dio), GFP_NOFS); + if (!dio) + goto out; + + dio->inode = inode; + dio->orig_end_io = bio->bi_end_io;Review
Quoted 10 lines
(quoted diff) +10
-0+ dio->orig_private = bio->bi_private; + dio->write = write; + + bio->bi_end_io = f2fs_dio_end_io; + bio->bi_private = dio; + + inc_page_count(F2FS_I_SB(inode), + write ? F2FS_DIO_WRITE : F2FS_DIO_READ); + + return submit_bio(bio);Quoted 7 lines
I don't think there is any need for this mess. The
F2FS_DIO_WRITE/F2FS_DIO_READcounts are only used to check if there is any inflight I/O at all. So instead we can increment them once before callingiomap_dio_rw, and decrement them in ->end_io or for a failure/noop exit fromiomap_dio_rw. Untested patch below. Note that all this would be much simpler to review if the last three patches were folded into a single one.
Quoted 4 lines
Eric, wdyt?
I've merged v1 to v5, including Christoph's comment in v2.
I am planning to do this, but I got caught up by the patch
"f2fs: fix wrong inflight page stats for directIO" that was recently added to f2fs.git#dev, which makes this suggestion no longer viable. Hence my review comment on that patch
(https://lkml.kernel.org/r/[email protected])
and Chao's new version of that patch
(https://lkml.kernel.org/r/[email protected]),
although the new version has some issues too as I commented.
If you could just revert "f2fs: fix wrong inflight page stats for directIO" for now, that would be helpful, as I don't think we want it.
- Eric
_______________________________________________
Linux-f2fs-devel mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
Jaegeuk Kim
maintainerRe: [PATCH 6/9] f2fs: implement iomap operations
Quoted 49 lines · Eric Biggers
Quoted 34 lines · Jaegeuk Kim
Quoted 25 lines · Christoph Hellwig
Quoted 13 lines · Eric Biggers
(quoted diff) +13
-0+static blk_qc_t f2fs_dio_submit_bio(struct inode *inode, struct iomap *iomap, + struct bio *bio, loff_t file_offset) +{ + struct f2fs_private_dio *dio; + bool write = (bio_op(bio) == REQ_OP_WRITE); + + dio = f2fs_kzalloc(F2FS_I_SB(inode), + sizeof(struct f2fs_private_dio), GFP_NOFS); + if (!dio) + goto out; + + dio->inode = inode; + dio->orig_end_io = bio->bi_end_io;Review
Quoted 10 lines
(quoted diff) +10
-0+ dio->orig_private = bio->bi_private; + dio->write = write; + + bio->bi_end_io = f2fs_dio_end_io; + bio->bi_private = dio; + + inc_page_count(F2FS_I_SB(inode), + write ? F2FS_DIO_WRITE : F2FS_DIO_READ); + + return submit_bio(bio);Quoted 7 lines
I don't think there is any need for this mess. The
F2FS_DIO_WRITE/F2FS_DIO_READcounts are only used to check if there is any inflight I/O at all. So instead we can increment them once before callingiomap_dio_rw, and decrement them in ->end_io or for a failure/noop exit fromiomap_dio_rw. Untested patch below. Note that all this would be much simpler to review if the last three patches were folded into a single one.Quoted 4 lines
Eric, wdyt?
I've merged v1 to v5, including Christoph's comment in v2.
I am planning to do this, but I got caught up by the patch
"f2fs: fix wrong inflight page stats for directIO" that was recently added to f2fs.git#dev, which makes this suggestion no longer viable. Hence my review comment on that patch
(https://lkml.kernel.org/r/[email protected])
and Chao's new version of that patch
(https://lkml.kernel.org/r/[email protected]),
although the new version has some issues too as I commented.
Quoted 2 lines
If you could just revert "f2fs: fix wrong inflight page stats for directIO" for now, that would be helpful, as I don't think we want it.
Yup, I dropped it in dev branch, and wait for Chao's next patch on top of iomap.
Quoted 2 lines
- Eric
Re: [PATCH 6/9] f2fs: implement iomap operations
In reply to Christoph HellwigHi Christoph,
Quoted 25 lines · Christoph Hellwig
Quoted 13 lines · Eric Biggers
(quoted diff) +13
-0+static blk_qc_t f2fs_dio_submit_bio(struct inode *inode, struct iomap *iomap, + struct bio *bio, loff_t file_offset) +{ + struct f2fs_private_dio *dio; + bool write = (bio_op(bio) == REQ_OP_WRITE); + + dio = f2fs_kzalloc(F2FS_I_SB(inode), + sizeof(struct f2fs_private_dio), GFP_NOFS); + if (!dio) + goto out; + + dio->inode = inode; + dio->orig_end_io = bio->bi_end_io;Review
Quoted 10 lines
(quoted diff) +10
-0+ dio->orig_private = bio->bi_private; + dio->write = write; + + bio->bi_end_io = f2fs_dio_end_io; + bio->bi_private = dio; + + inc_page_count(F2FS_I_SB(inode), + write ? F2FS_DIO_WRITE : F2FS_DIO_READ); + + return submit_bio(bio);
Quoted 8 lines
I don't think there is any need for this mess. The
F2FS_DIO_WRITE/F2FS_DIO_READcounts are only used to check if there is any inflight I/O at all. So instead we can increment them once before callingiomap_dio_rw, and decrement them in ->end_io or for a failure/noop exit fromiomap_dio_rw. Untested patch below. Note that all this would be much simpler to review if the last three patches were folded into a single one.
I am trying to do this, but unfortunately I don't see a way to make it work correctly in all cases.
The main problem is that when iomap_dio_rw() returns an error (other than -EIOCBQUEUED), there is no way to know whether ->end_io() has been called or not. This is because iomap_dio_rw() can fail either early, before "starting" the I/O (in which case ->end_io() won't have been called), or later, after "starting" the I/O (in which case ->end_io() will have been called). Note that this can't be worked around by checking whether the iov_iter has been advanced or not, since a failure could occur between "starting" the I/O and the iov_iter being advanced for the first time.
Would you be receptive to adding a ->begin_io() callback to struct iomap_dio_ops in order to allow filesystems to maintain counters like this?
Either way, given the problem here, I think I should leave this out of the initial conversion and just do a dumb translation of the existing f2fs logic to start with, like I have in this patch.
- Eric
Re: [PATCH 6/9] f2fs: implement iomap operations
Quoted 12 lines · Eric Biggers
I am trying to do this, but unfortunately I don't see a way to make it work correctly in all cases.
The main problem is that when
iomap_dio_rw()returns an error (other than-EIOCBQUEUED), there is no way to know whether ->end_io() has been called or not. This is becauseiomap_dio_rw()can fail either early, before "starting" the I/O (in which case ->end_io() won't have been called), or later, after "starting" the I/O (in which case ->end_io() will have been called). Note that this can't be worked around by checking whether theiov_iterhas been advanced or not, since a failure could occur between "starting" the I/O and theiov_iterbeing advanced for the first time.
Quoted 2 lines
Would you be receptive to adding a ->begin_io() callback to struct
iomap_dio_opsin order to allow filesystems to maintain counters like this?
I think we can triviall fix this by using the slightly lower level __iomap_dio_rw API. Incremental patch to my previous one below:
fs/f2fs/file.c +8 -4
@@ -4243,6 +4243,7 @@ static ssize_t f2fs_dio_read_iter(struct kiocb *iocb, struct iov_iter *to)struct f2fs_inode_info *fi =F2FS_I (inode);const loff_t pos = iocb->ki_pos;const size_t count =iov_iter_count (to); +struct iomap_dio *dio;ssize_t ret;if (count ==0 )
@@ -4260,8 +4261,13 @@ static ssize_t f2fs_dio_read_iter(struct kiocb *iocb, struct iov_iter *to) }inc_page_count (F2FS_I_SB (inode),F2FS_DIO_READ ); - ret =iomap_dio_rw (iocb, to, &f2fs_iomap_ops, &f2fs_iomap_dio_ops,0 ); - + dio =__iomap_dio_rw (iocb, to, &f2fs_iomap_ops, &f2fs_iomap_dio_ops,0 ); +if (IS_ERR_OR_NULL (dio)) { +dec_page_count (F2FS_I_SB (inode),F2FS_DIO_READ ); + ret =PTR_ERR_OR_ZERO (dio); + }else { + ret =iomap_dio_complete (dio); + }up_read (&fi->i_gc_rwsem[READ ]);file_accessed (file);
@@ -4271,8 +4277,6 @@ static ssize_t f2fs_dio_read_iter(struct kiocb *iocb, struct iov_iter *to)else if (ret == -EIOCBQUEUED )f2fs_update_iostat (F2FS_I_SB (inode),APP_DIRECT_READ_IO , count -iov_iter_count (to)); -else -dec_page_count (F2FS_I_SB (inode),F2FS_DIO_READ ); out:trace_f2fs_direct_IO_exit (inode, pos, count,READ , ret);return ret;
Re: [PATCH 6/9] f2fs: implement iomap operations
Quoted 48 lines · Christoph Hellwig
Quoted 12 lines · Eric Biggers
I am trying to do this, but unfortunately I don't see a way to make it work correctly in all cases.
The main problem is that when
iomap_dio_rw()returns an error (other than-EIOCBQUEUED), there is no way to know whether ->end_io() has been called or not. This is becauseiomap_dio_rw()can fail either early, before "starting" the I/O (in which case ->end_io() won't have been called), or later, after "starting" the I/O (in which case ->end_io() will have been called). Note that this can't be worked around by checking whether theiov_iterhas been advanced or not, since a failure could occur between "starting" the I/O and theiov_iterbeing advanced for the first time.Quoted 2 lines
Would you be receptive to adding a ->begin_io() callback to struct
iomap_dio_opsin order to allow filesystems to maintain counters like this?I think we can triviall fix this by using the slightly lower level
__iomap_dio_rwAPI. Incremental patch to my previous one below:fs/f2fs/file.c +8
-2@@ -4243,6 +4243,7 @@ static ssize_t f2fs_dio_read_iter(struct kiocb *iocb, struct iov_iter *to)struct f2fs_inode_info *fi =F2FS_I (inode);const loff_t pos = iocb->ki_pos;const size_t count =iov_iter_count (to); +struct iomap_dio *dio;ssize_t ret;if (count ==0 )@@ -4260,8 +4261,13 @@ static ssize_t f2fs_dio_read_iter(struct kiocb *iocb, struct iov_iter *to) }inc_page_count (F2FS_I_SB (inode),F2FS_DIO_READ ); - ret =iomap_dio_rw (iocb, to, &f2fs_iomap_ops, &f2fs_iomap_dio_ops,0 ); - + dio =__iomap_dio_rw (iocb, to, &f2fs_iomap_ops, &f2fs_iomap_dio_ops,0 ); +if (IS_ERR_OR_NULL (dio)) { +dec_page_count (F2FS_I_SB (inode),F2FS_DIO_READ ); + ret =PTR_ERR_OR_ZERO (dio); + }else { + ret =iomap_dio_complete (dio); + }up_read (&fi->i_gc_rwsem[READ ]);file_accessed (file);
fs/f2fs/file.c static ssize_t f2fs_dio_read_iter(struct kiocb *iocb, struct iov_iter *to) · line 4282
Quoted 8 lines
fs/f2fs/file.c +0
-2@@ -4271,8 +4277,6 @@ static ssize_t f2fs_dio_read_iter(struct kiocb *iocb, struct iov_iter *to)else if (ret == -EIOCBQUEUED )f2fs_update_iostat (F2FS_I_SB (inode),APP_DIRECT_READ_IO , count -iov_iter_count (to)); -else -dec_page_count (F2FS_I_SB (inode),F2FS_DIO_READ ); out:trace_f2fs_direct_IO_exit (inode, pos, count,READ , ret);return ret;
I wouldn't call it trivial, but yes that seems to work (after fixing it to handle EIOCBQUEUED correctly). Take a look at the v2 I've sent out. Thanks!
- Eric
Re: [PATCH 1/9] f2fs: make f2fs_write_failed() take struct inode
In reply to Eric BiggersQuoted 6 lines · Eric Biggers
From: Eric Biggers <[email protected]>
Make
f2fs_write_failed()take a 'struct inode' directly rather than a 'structaddress_space', as this simplifies it slightly.Signed-off-by Eric Biggers <[email protected]>
Thanks,
Chao Yu
maintainerRe: [PATCH 3/9] f2fs: rework write preallocations
In reply to Eric BiggersQuoted 7 lines · Eric Biggers
From: Eric Biggers <[email protected]>
f2fs_write_begin()assumes that all blocks were preallocated by default unlessFI_NO_PREALLOCis explicitly set. This invites data corruption, as there are cases in which not all blocks are preallocated. Commit47501f87c61a("f2fs: preallocate DIO blocks when forcingbuffered_io") fixed one case, but there are others remaining.
Could you please explain which cases we missed to handle previously? then I can check those related logic before and after the rework.
fs/f2fs/file.c static ssize_t f2fs_file_write_iter(struct kiocb *iocb, struct iov_iter *from) · line 4295
Quoted 7 lines
fs/f2fs/file.c +0
-7-/* -* If force_buffere_io() is true, we have to allocate -* blocks all the time, since f2fs_direct_IO will fall -* back to buffered IO. -*/ -if (!f2fs_force_buffered_io (inode, iocb, from) && -f2fs_lfs_mode (F2FS_I_SB (inode)))
We should keep this OPU DIO logic, otherwise, in lfs mode, write dio will always allocate two block addresses for each 4k append IO.
I jsut test based on codes of last f2fs dev-test branch.
rm /mnt/f2fs/dio
dd if=/dev/zero of=/mnt/f2fs/dio bs=4k count=4 oflag=direct
<...>-763176 [001] ...1 177258.793370: f2fs_map_blocks: dev = (259,1), ino = 6, file offset = 0, start blkaddr = 0xe1a2e, len = 0x1, flags = 48,seg_type = 1, may_create = 1, err = 0
<...>-763176 [001] ...1 177258.793462: f2fs_map_blocks: dev = (259,1), ino = 6, file offset = 0, start blkaddr = 0xe1a2f, len = 0x1, flags = 16,seg_type = 1, may_create = 1, err = 0
dd-763176 [001] ...1 177258.793575: f2fs_map_blocks: dev = (259,1), ino = 6, file offset = 1, start blkaddr = 0xe1a30, len = 0x1, flags = 48,seg_type = 1, may_create = 1, err = 0
dd-763176 [001] ...1 177258.793599: f2fs_map_blocks: dev = (259,1), ino = 6, file offset = 1, start blkaddr = 0xe1a31, len = 0x1, flags = 16,seg_type = 1, may_create = 1, err = 0
dd-763176 [001] ...1 177258.793735: f2fs_map_blocks: dev = (259,1), ino = 6, file offset = 2, start blkaddr = 0xe1a32, len = 0x1, flags = 48,seg_type = 1, may_create = 1, err = 0
dd-763176 [001] ...1 177258.793769: f2fs_map_blocks: dev = (259,1), ino = 6, file offset = 2, start blkaddr = 0xe1a33, len = 0x1, flags = 16,seg_type = 1, may_create = 1, err = 0
dd-763176 [001] ...1 177258.793859: f2fs_map_blocks: dev = (259,1), ino = 6, file offset = 3, start blkaddr = 0xe1a34, len = 0x1, flags = 48,seg_type = 1, may_create = 1, err = 0
dd-763176 [001] ...1 177258.793885: f2fs_map_blocks: dev = (259,1), ino = 6, file offset = 3, start blkaddr = 0xe1a35, len = 0x1, flags = 16,seg_type = 1, may_create = 1, err = 0Thanks,
Jaegeuk Kim
maintainerRe: [PATCH 3/9] f2fs: rework write preallocations
In reply to Eric BiggersNote that, this patch is failing generic/250.
Quoted 298 lines · Eric Biggers
From: Eric Biggers <[email protected]>
f2fs_write_begin()assumes that all blocks were preallocated by default unlessFI_NO_PREALLOCis explicitly set. This invites data corruption, as there are cases in which not all blocks are preallocated. Commit47501f87c61a("f2fs: preallocate DIO blocks when forcingbuffered_io") fixed one case, but there are others remaining.Fix up this logic by replacing this flag with
FI_PREALLOCATED_ALL, which only gets set if all blocks for the current write were preallocated.Also clean up
f2fs_preallocate_blocks(), move it tofile.c, and make it handle some of the logic that was previously inwrite_iter()directly.Signed-off-by Eric Biggers <[email protected]>--- fs/f2fs/data.c | 55 ++-------------------- fs/f2fs/f2fs.h | 3 +- fs/f2fs/file.c | 123 ++++++++++++++++++++++++++++++++----------------- 3 files changed, 84 insertions(+), 97 deletions(-)fs/f2fs/data.c +3
-52@@ -1370,53 +1370,6 @@ static int __allocate_data_block(struct dnode_of_data *dn, int seg_type)return 0 ; } -int f2fs_preallocate_blocks (struct kiocb *iocb,struct iov_iter *from) -{ -struct inode *inode =file_inode (iocb->ki_filp); -struct f2fs_map_blocks map; -int flag; -int err =0 ; -bool direct_io = iocb->ki_flags &IOCB_DIRECT ; - - map.m_lblk =F2FS_BLK_ALIGN (iocb->ki_pos); - map.m_len =F2FS_BYTES_TO_BLK (iocb->ki_pos +iov_iter_count (from)); -if (map.m_len > map.m_lblk) - map.m_len -= map.m_lblk; -else - map.m_len =0 ; - - map.m_next_pgofs =NULL ; - map.m_next_extent =NULL ; - map.m_seg_type =NO_CHECK_TYPE ; - map.m_may_create = true; - -if (direct_io) { - map.m_seg_type =f2fs_rw_hint_to_seg_type (iocb->ki_hint); - flag =f2fs_force_buffered_io (inode, iocb, from) ? -F2FS_GET_BLOCK_PRE_AIO : -F2FS_GET_BLOCK_PRE_DIO ; - goto map_blocks; - } -if (iocb->ki_pos +iov_iter_count (from) >MAX_INLINE_DATA (inode)) { - err =f2fs_convert_inline_inode (inode); -if (err) -return err; - } -if (f2fs_has_inline_data (inode)) -return err; - - flag =F2FS_GET_BLOCK_PRE_AIO ; - -map_blocks: - err =f2fs_map_blocks (inode, &map,1 , flag); -if (map.m_len >0 && err == -ENOSPC ) { -if (!direct_io) -set_inode_flag (inode,FI_NO_PREALLOC ); - err =0 ; - } -return err; -} -void f2fs_do_map_lock (struct f2fs_sb_info *sbi,int flag,bool lock) {if (flag ==F2FS_GET_BLOCK_PRE_AIO ) {@@ -3210,12 +3163,10 @@ static int prepare_write_begin(struct f2fs_sb_info *sbi,int flag;/* -* we already allocated all the blocks, so we don't need to get -* the block addresses when there is no need to fill the page. +* If a whole page is being written and we already preallocated all the +* blocks, then there is no need to get a block address now. */ -if (!f2fs_has_inline_data (inode) && len ==PAGE_SIZE && - !is_inode_flag_set (inode,FI_NO_PREALLOC ) && - !f2fs_verity_in_progress (inode)) +if (len ==PAGE_SIZE &&is_inode_flag_set (inode,FI_PREALLOCATED_ALL ))return 0 ;/* f2fs_lock_op avoids race between write CP and convert_inline_page */ fs/f2fs/f2fs.h +1
-2@@ -699,7 +699,7 @@ enum {FI_INLINE_DOTS ,/* indicate inline dot dentries */ FI_DO_DEFRAG ,/* indicate defragment is running */ FI_DIRTY_FILE ,/* indicate regular/symlink has dirty pages */ -FI_NO_PREALLOC ,/* indicate skipped preallocated blocks */ +FI_PREALLOCATED_ALL ,/* all blocks for write were preallocated */ FI_HOT_DATA ,/* indicate file is hot */ FI_EXTRA_ATTR ,/* indicate file has extra attribute */ FI_PROJ_INHERIT, /* indicate file inherits projectid */@@ -3604,7 +3604,6 @@ void f2fs_update_data_blkaddr(struct dnode_of_data *dn, block_t blkaddr);int f2fs_reserve_new_blocks (struct dnode_of_data *dn,blkcnt_t count);int f2fs_reserve_new_block (struct dnode_of_data *dn);int f2fs_get_block (struct dnode_of_data *dn,pgoff_t index); -int f2fs_preallocate_blocks (struct kiocb *iocb,struct iov_iter *from);int f2fs_reserve_block (struct dnode_of_data *dn,pgoff_t index);struct page *f2fs_get_read_data_page (struct inode *inode,pgoff_t index,int op_flags,bool for_write);fs/f2fs/file.c +80
-43@@ -4218,10 +4218,72 @@ static ssize_t f2fs_file_read_iter(struct kiocb *iocb, struct iov_iter *iter)return ret; } +/* +* Preallocate blocks for a write request, if it is possible and helpful to do +* so. Returns a positive number if blocks may have been preallocated, 0 if no +* blocks were preallocated, or a negative errno value if something went +* seriously wrong. Also sets FI_PREALLOCATED_ALL on the inode if *all* the +* requested blocks (not just some of them) have been allocated. +*/ +static int f2fs_preallocate_blocks (struct kiocb *iocb,struct iov_iter *iter) +{ +struct inode *inode =file_inode (iocb->ki_filp); +struct f2fs_sb_info *sbi =F2FS_I_SB (inode); +const loff_t pos = iocb->ki_pos; +const size_t count =iov_iter_count (iter); +struct f2fs_map_blocks map = {}; +bool dio = (iocb->ki_flags &IOCB_DIRECT ) && + !f2fs_force_buffered_io (inode, iocb, iter); +int flag; +int ret; + +/* If it will be an in-place direct write, don't bother. */ +if (dio && !f2fs_lfs_mode (sbi)) +return 0 ; + +/* No-wait I/O can't allocate blocks. */ +if (iocb->ki_flags &IOCB_NOWAIT ) +return 0 ; + +/* If it will be a short write, don't bother. */ +if (iov_iter_fault_in_readable (iter, count) !=0 ) +return 0 ; + +if (f2fs_has_inline_data (inode)) { +/* If the data will fit inline, don't bother. */ +if (pos + count <=MAX_INLINE_DATA (inode)) +return 0 ; + ret =f2fs_convert_inline_inode (inode); +if (ret) +return ret; + } + + map.m_lblk = (pos >> inode->i_blkbits); + map.m_len = ((pos + count -1 ) >> inode->i_blkbits) - map.m_lblk +1 ; + map.m_may_create = true; +if (dio) { + map.m_seg_type =f2fs_rw_hint_to_seg_type (inode->i_write_hint); + flag =F2FS_GET_BLOCK_PRE_DIO ; + }else { + map.m_seg_type =NO_CHECK_TYPE ; + flag =F2FS_GET_BLOCK_PRE_AIO ; + } + + ret =f2fs_map_blocks (inode, &map,1 , flag); +/* -ENOSPC is only a fatal error if no blocks could be allocated. */ +if (ret <0 && !(ret == -ENOSPC && map.m_len >0 )) +return ret; +if (ret ==0 ) +set_inode_flag (inode,FI_PREALLOCATED_ALL ); +return map.m_len; +} +static ssize_t f2fs_file_write_iter (struct kiocb *iocb,struct iov_iter *from) {struct file *file = iocb->ki_filp;struct inode *inode =file_inode (file); +loff_t target_size; +int preallocated;ssize_t ret;if (unlikely (f2fs_cp_error (F2FS_I_SB (inode)))) {@@ -4245,84 +4307,59 @@ static ssize_t f2fs_file_write_iter(struct kiocb *iocb, struct iov_iter *from)if (unlikely (IS_IMMUTABLE (inode))) { ret = -EPERM ; - goto unlock; + goto out_unlock; }if (is_inode_flag_set (inode,FI_COMPRESS_RELEASED )) { ret = -EPERM ; - goto unlock; + goto out_unlock; } ret =generic_write_checks (iocb, from);if (ret >0 ) { -bool preallocated = false; -size_t target_size =0 ; -int err; - -if (iov_iter_fault_in_readable (from,iov_iter_count (from))) -set_inode_flag (inode,FI_NO_PREALLOC ); - -if ((iocb->ki_flags &IOCB_NOWAIT )) { +if (iocb->ki_flags &IOCB_NOWAIT ) {if (!f2fs_overwrite_io (inode, iocb->ki_pos,iov_iter_count (from)) ||f2fs_has_inline_data (inode) ||f2fs_force_buffered_io (inode, iocb, from)) { -clear_inode_flag (inode,FI_NO_PREALLOC ); -inode_unlock (inode); ret = -EAGAIN ; - goto out; + goto out_unlock; } - goto write; } - -if (is_inode_flag_set (inode,FI_NO_PREALLOC )) - goto write; -if (iocb->ki_flags &IOCB_DIRECT ) {/* * Convert inline data for Direct I/O before entering * f2fs_direct_IO(). */ - err =f2fs_convert_inline_inode (inode); -if (err) - goto out_err; -/* -* If force_buffere_io() is true, we have to allocate -* blocks all the time, since f2fs_direct_IO will fall -* back to buffered IO. -*/ -if (!f2fs_force_buffered_io (inode, iocb, from) && -f2fs_lfs_mode (F2FS_I_SB (inode))) - goto write; + ret =f2fs_convert_inline_inode (inode); +if (ret) + goto out_unlock; } - preallocated = true; - target_size = iocb->ki_pos +iov_iter_count (from); - err =f2fs_preallocate_blocks (iocb, from); -if (err) { -out_err: -clear_inode_flag (inode,FI_NO_PREALLOC ); -inode_unlock (inode); - ret = err; - goto out; +/* Possibly preallocate the blocks for the write. */ + target_size = iocb->ki_pos +iov_iter_count (from); + preallocated =f2fs_preallocate_blocks (iocb, from); +if (preallocated <0 ) { + ret = preallocated; + goto out_unlock; } -write: + ret =__generic_file_write_iter (iocb, from); -clear_inode_flag (inode,FI_NO_PREALLOC ); -/* if we couldn't write data, we should deallocate blocks. */ -if (preallocated &&i_size_read (inode) < target_size) { +/* Don't leave any preallocated blocks around past i_size. */ +if (preallocated >0 && inode->i_size < target_size) {down_write (&F2FS_I (inode)->i_gc_rwsem[WRITE ]);down_write (&F2FS_I (inode)->i_mmap_sem);f2fs_truncate (inode);up_write (&F2FS_I (inode)->i_mmap_sem);up_write (&F2FS_I (inode)->i_gc_rwsem[WRITE ]); } +clear_inode_flag (inode,FI_PREALLOCATED_ALL );if (ret >0 )f2fs_update_iostat (F2FS_I_SB (inode),APP_WRITE_IO , ret); } -unlock: +out_unlock:inode_unlock (inode); out: trace_f2fs_file_write_iter(inode, iocb->ki_pos,Signature · 1 line
2.32.0
Jaegeuk Kim
maintainerRe: [PATCH 3/9] f2fs: rework write preallocations
Quoted 1 line · Jaegeuk Kim
Note that, this patch is failing generic/250.
correction: it's failing in 4.14 and 4.19 after simple cherry-pick, but giving no failure on 5.4, 5.10, and mainline.
Quoted 300 lines · Eric Biggers
Quoted 298 lines
From: Eric Biggers <[email protected]>
f2fs_write_begin()assumes that all blocks were preallocated by default unlessFI_NO_PREALLOCis explicitly set. This invites data corruption, as there are cases in which not all blocks are preallocated. Commit47501f87c61a("f2fs: preallocate DIO blocks when forcingbuffered_io") fixed one case, but there are others remaining.Fix up this logic by replacing this flag with
FI_PREALLOCATED_ALL, which only gets set if all blocks for the current write were preallocated.Also clean up
f2fs_preallocate_blocks(), move it tofile.c, and make it handle some of the logic that was previously inwrite_iter()directly.Signed-off-by Eric Biggers <[email protected]>--- fs/f2fs/data.c | 55 ++-------------------- fs/f2fs/f2fs.h | 3 +- fs/f2fs/file.c | 123 ++++++++++++++++++++++++++++++++----------------- 3 files changed, 84 insertions(+), 97 deletions(-)fs/f2fs/data.c +3
-52@@ -1370,53 +1370,6 @@ static int __allocate_data_block(struct dnode_of_data *dn, int seg_type)return 0 ; } -int f2fs_preallocate_blocks (struct kiocb *iocb,struct iov_iter *from) -{ -struct inode *inode =file_inode (iocb->ki_filp); -struct f2fs_map_blocks map; -int flag; -int err =0 ; -bool direct_io = iocb->ki_flags &IOCB_DIRECT ; - - map.m_lblk =F2FS_BLK_ALIGN (iocb->ki_pos); - map.m_len =F2FS_BYTES_TO_BLK (iocb->ki_pos +iov_iter_count (from)); -if (map.m_len > map.m_lblk) - map.m_len -= map.m_lblk; -else - map.m_len =0 ; - - map.m_next_pgofs =NULL ; - map.m_next_extent =NULL ; - map.m_seg_type =NO_CHECK_TYPE ; - map.m_may_create = true; - -if (direct_io) { - map.m_seg_type =f2fs_rw_hint_to_seg_type (iocb->ki_hint); - flag =f2fs_force_buffered_io (inode, iocb, from) ? -F2FS_GET_BLOCK_PRE_AIO : -F2FS_GET_BLOCK_PRE_DIO ; - goto map_blocks; - } -if (iocb->ki_pos +iov_iter_count (from) >MAX_INLINE_DATA (inode)) { - err =f2fs_convert_inline_inode (inode); -if (err) -return err; - } -if (f2fs_has_inline_data (inode)) -return err; - - flag =F2FS_GET_BLOCK_PRE_AIO ; - -map_blocks: - err =f2fs_map_blocks (inode, &map,1 , flag); -if (map.m_len >0 && err == -ENOSPC ) { -if (!direct_io) -set_inode_flag (inode,FI_NO_PREALLOC ); - err =0 ; - } -return err; -} -void f2fs_do_map_lock (struct f2fs_sb_info *sbi,int flag,bool lock) {if (flag ==F2FS_GET_BLOCK_PRE_AIO ) {@@ -3210,12 +3163,10 @@ static int prepare_write_begin(struct f2fs_sb_info *sbi,int flag;/* -* we already allocated all the blocks, so we don't need to get -* the block addresses when there is no need to fill the page. +* If a whole page is being written and we already preallocated all the +* blocks, then there is no need to get a block address now. */ -if (!f2fs_has_inline_data (inode) && len ==PAGE_SIZE && - !is_inode_flag_set (inode,FI_NO_PREALLOC ) && - !f2fs_verity_in_progress (inode)) +if (len ==PAGE_SIZE &&is_inode_flag_set (inode,FI_PREALLOCATED_ALL ))return 0 ;/* f2fs_lock_op avoids race between write CP and convert_inline_page */ fs/f2fs/f2fs.h +1
-2@@ -699,7 +699,7 @@ enum {FI_INLINE_DOTS ,/* indicate inline dot dentries */ FI_DO_DEFRAG ,/* indicate defragment is running */ FI_DIRTY_FILE ,/* indicate regular/symlink has dirty pages */ -FI_NO_PREALLOC ,/* indicate skipped preallocated blocks */ +FI_PREALLOCATED_ALL ,/* all blocks for write were preallocated */ FI_HOT_DATA ,/* indicate file is hot */ FI_EXTRA_ATTR ,/* indicate file has extra attribute */ FI_PROJ_INHERIT, /* indicate file inherits projectid */@@ -3604,7 +3604,6 @@ void f2fs_update_data_blkaddr(struct dnode_of_data *dn, block_t blkaddr);int f2fs_reserve_new_blocks (struct dnode_of_data *dn,blkcnt_t count);int f2fs_reserve_new_block (struct dnode_of_data *dn);int f2fs_get_block (struct dnode_of_data *dn,pgoff_t index); -int f2fs_preallocate_blocks (struct kiocb *iocb,struct iov_iter *from);int f2fs_reserve_block (struct dnode_of_data *dn,pgoff_t index);struct page *f2fs_get_read_data_page (struct inode *inode,pgoff_t index,int op_flags,bool for_write);fs/f2fs/file.c +80
-43@@ -4218,10 +4218,72 @@ static ssize_t f2fs_file_read_iter(struct kiocb *iocb, struct iov_iter *iter)return ret; } +/* +* Preallocate blocks for a write request, if it is possible and helpful to do +* so. Returns a positive number if blocks may have been preallocated, 0 if no +* blocks were preallocated, or a negative errno value if something went +* seriously wrong. Also sets FI_PREALLOCATED_ALL on the inode if *all* the +* requested blocks (not just some of them) have been allocated. +*/ +static int f2fs_preallocate_blocks (struct kiocb *iocb,struct iov_iter *iter) +{ +struct inode *inode =file_inode (iocb->ki_filp); +struct f2fs_sb_info *sbi =F2FS_I_SB (inode); +const loff_t pos = iocb->ki_pos; +const size_t count =iov_iter_count (iter); +struct f2fs_map_blocks map = {}; +bool dio = (iocb->ki_flags &IOCB_DIRECT ) && + !f2fs_force_buffered_io (inode, iocb, iter); +int flag; +int ret; + +/* If it will be an in-place direct write, don't bother. */ +if (dio && !f2fs_lfs_mode (sbi)) +return 0 ; + +/* No-wait I/O can't allocate blocks. */ +if (iocb->ki_flags &IOCB_NOWAIT ) +return 0 ; + +/* If it will be a short write, don't bother. */ +if (iov_iter_fault_in_readable (iter, count) !=0 ) +return 0 ; + +if (f2fs_has_inline_data (inode)) { +/* If the data will fit inline, don't bother. */ +if (pos + count <=MAX_INLINE_DATA (inode)) +return 0 ; + ret =f2fs_convert_inline_inode (inode); +if (ret) +return ret; + } + + map.m_lblk = (pos >> inode->i_blkbits); + map.m_len = ((pos + count -1 ) >> inode->i_blkbits) - map.m_lblk +1 ; + map.m_may_create = true; +if (dio) { + map.m_seg_type =f2fs_rw_hint_to_seg_type (inode->i_write_hint); + flag =F2FS_GET_BLOCK_PRE_DIO ; + }else { + map.m_seg_type =NO_CHECK_TYPE ; + flag =F2FS_GET_BLOCK_PRE_AIO ; + } + + ret =f2fs_map_blocks (inode, &map,1 , flag); +/* -ENOSPC is only a fatal error if no blocks could be allocated. */ +if (ret <0 && !(ret == -ENOSPC && map.m_len >0 )) +return ret; +if (ret ==0 ) +set_inode_flag (inode,FI_PREALLOCATED_ALL ); +return map.m_len; +} +static ssize_t f2fs_file_write_iter (struct kiocb *iocb,struct iov_iter *from) {struct file *file = iocb->ki_filp;struct inode *inode =file_inode (file); +loff_t target_size; +int preallocated;ssize_t ret;if (unlikely (f2fs_cp_error (F2FS_I_SB (inode)))) {@@ -4245,84 +4307,59 @@ static ssize_t f2fs_file_write_iter(struct kiocb *iocb, struct iov_iter *from)if (unlikely (IS_IMMUTABLE (inode))) { ret = -EPERM ; - goto unlock; + goto out_unlock; }if (is_inode_flag_set (inode,FI_COMPRESS_RELEASED )) { ret = -EPERM ; - goto unlock; + goto out_unlock; } ret =generic_write_checks (iocb, from);if (ret >0 ) { -bool preallocated = false; -size_t target_size =0 ; -int err; - -if (iov_iter_fault_in_readable (from,iov_iter_count (from))) -set_inode_flag (inode,FI_NO_PREALLOC ); - -if ((iocb->ki_flags &IOCB_NOWAIT )) { +if (iocb->ki_flags &IOCB_NOWAIT ) {if (!f2fs_overwrite_io (inode, iocb->ki_pos,iov_iter_count (from)) ||f2fs_has_inline_data (inode) ||f2fs_force_buffered_io (inode, iocb, from)) { -clear_inode_flag (inode,FI_NO_PREALLOC ); -inode_unlock (inode); ret = -EAGAIN ; - goto out; + goto out_unlock; } - goto write; } - -if (is_inode_flag_set (inode,FI_NO_PREALLOC )) - goto write; -if (iocb->ki_flags &IOCB_DIRECT ) {/* * Convert inline data for Direct I/O before entering * f2fs_direct_IO(). */ - err =f2fs_convert_inline_inode (inode); -if (err) - goto out_err; -/* -* If force_buffere_io() is true, we have to allocate -* blocks all the time, since f2fs_direct_IO will fall -* back to buffered IO. -*/ -if (!f2fs_force_buffered_io (inode, iocb, from) && -f2fs_lfs_mode (F2FS_I_SB (inode))) - goto write; + ret =f2fs_convert_inline_inode (inode); +if (ret) + goto out_unlock; } - preallocated = true; - target_size = iocb->ki_pos +iov_iter_count (from); - err =f2fs_preallocate_blocks (iocb, from); -if (err) { -out_err: -clear_inode_flag (inode,FI_NO_PREALLOC ); -inode_unlock (inode); - ret = err; - goto out; +/* Possibly preallocate the blocks for the write. */ + target_size = iocb->ki_pos +iov_iter_count (from); + preallocated =f2fs_preallocate_blocks (iocb, from); +if (preallocated <0 ) { + ret = preallocated; + goto out_unlock; } -write: + ret =__generic_file_write_iter (iocb, from); -clear_inode_flag (inode,FI_NO_PREALLOC ); -/* if we couldn't write data, we should deallocate blocks. */ -if (preallocated &&i_size_read (inode) < target_size) { +/* Don't leave any preallocated blocks around past i_size. */ +if (preallocated >0 && inode->i_size < target_size) {down_write (&F2FS_I (inode)->i_gc_rwsem[WRITE ]);down_write (&F2FS_I (inode)->i_mmap_sem);f2fs_truncate (inode);up_write (&F2FS_I (inode)->i_mmap_sem);up_write (&F2FS_I (inode)->i_gc_rwsem[WRITE ]); } +clear_inode_flag (inode,FI_PREALLOCATED_ALL );if (ret >0 )f2fs_update_iostat (F2FS_I_SB (inode),APP_WRITE_IO , ret); } -unlock: +out_unlock:inode_unlock (inode); out: trace_f2fs_file_write_iter(inode, iocb->ki_pos,Signature · 1 line
2.32.0
Re: [PATCH 3/9] f2fs: rework write preallocations
In reply to Chao YuQuoted 11 lines · Chao Yu
Quoted 7 lines · Eric Biggers
From: Eric Biggers <[email protected]>
f2fs_write_begin()assumes that all blocks were preallocated by default unlessFI_NO_PREALLOCis explicitly set. This invites data corruption, as there are cases in which not all blocks are preallocated. Commit47501f87c61a("f2fs: preallocate DIO blocks when forcingbuffered_io") fixed one case, but there are others remaining.Could you please explain which cases we missed to handle previously? then I can check those related logic before and after the rework.
Any case where a buffered write happens while not all blocks were preallocated but FI_NO_PREALLOC wasn't set. For example when ENOSPC was hit in the middle of the preallocations for a direct write that will fall back to a buffered write, e.g. due to f2fs_force_buffered_io() or page cache invalidation failure.
Quoted 13 lines
fs/f2fs/file.c static ssize_t f2fs_file_write_iter(struct kiocb *iocb, struct iov_iter *from) · line 4296
Quoted 9 lines
fs/f2fs/file.c +0
-8-/* -* If force_buffere_io() is true, we have to allocate -* blocks all the time, since f2fs_direct_IO will fall -* back to buffered IO. -*/ -if (!f2fs_force_buffered_io (inode, iocb, from) && -f2fs_lfs_mode (F2FS_I_SB (inode))) - goto write;We should keep this OPU DIO logic, otherwise, in lfs mode, write dio will always allocate two block addresses for each 4k append IO.
Quoted 1 line
I jsut test based on codes of last f2fs dev-test branch.
Yes, I had misread that due to the weird goto and misleading comment and translated it into:
/* If it will be an in-place direct write, don't bother. */
if (dio && !f2fs_lfs_mode(sbi))
return 0;It should be:
if (dio && f2fs_lfs_mode(sbi))
return 0;Do you have a proper explanation for why preallocations shouldn't be done in this case? Note that preallocations are still done for buffered writes, which may be out-of-place as well; how are those different?
- Eric
Re: [PATCH 3/9] f2fs: rework write preallocations
In reply to Jaegeuk KimQuoted 6 lines · Jaegeuk Kim
Quoted 1 line · Jaegeuk Kim
Note that, this patch is failing generic/250.
correction: it's failing in 4.14 and 4.19 after simple cherry-pick, but giving no failure on 5.4, 5.10, and mainline.
For me, generic/250 fails on both mainline and f2fs/dev without my changes. So it isn't a regression.
- Eric
Jaegeuk Kim
maintainerRe: [PATCH 3/9] f2fs: rework write preallocations
Quoted 10 lines · Eric Biggers
Quoted 6 lines · Jaegeuk Kim
Quoted 1 line · Jaegeuk Kim
Note that, this patch is failing generic/250.
correction: it's failing in 4.14 and 4.19 after simple cherry-pick, but giving no failure on 5.4, 5.10, and mainline.
For me, generic/250 fails on both mainline and f2fs/dev without my changes. So it isn't a regression.
fyi; I had to change 250 to pass like this. I'm digging the patch.
https://github.com/jaegeuk/xfstests-f2fs/commit/99c11b6550a2a24f831018d2e019eed86e517d44.
Quoted 2 lines
- Eric
Jaegeuk Kim
maintainer Tested-by Shin'ichiro Kawasaki Reviewed-by Chao Yu Reviewed-by Javier GonzálezRe: [PATCH 3/9] f2fs: rework write preallocations
In reply to Eric BiggersQuoted 36 lines · Eric Biggers
Quoted 11 lines · Chao Yu
Quoted 7 lines · Eric Biggers
From: Eric Biggers <[email protected]>
f2fs_write_begin()assumes that all blocks were preallocated by default unlessFI_NO_PREALLOCis explicitly set. This invites data corruption, as there are cases in which not all blocks are preallocated. Commit47501f87c61a("f2fs: preallocate DIO blocks when forcingbuffered_io") fixed one case, but there are others remaining.Could you please explain which cases we missed to handle previously? then I can check those related logic before and after the rework.
Any case where a buffered write happens while not all blocks were preallocated but
FI_NO_PREALLOCwasn't set. For example when ENOSPC was hit in the middle of the preallocations for a direct write that will fall back to a buffered write, e.g. due tof2fs_force_buffered_io()or page cache invalidation failure.Quoted 13 lines
fs/f2fs/file.c static ssize_t f2fs_file_write_iter(struct kiocb *iocb, struct iov_iter *from) · line 4296
Quoted 9 lines
fs/f2fs/file.c +0
-8-/* -* If force_buffere_io() is true, we have to allocate -* blocks all the time, since f2fs_direct_IO will fall -* back to buffered IO. -*/ -if (!f2fs_force_buffered_io (inode, iocb, from) && -f2fs_lfs_mode (F2FS_I_SB (inode))) - goto write;We should keep this OPU DIO logic, otherwise, in lfs mode, write dio will always allocate two block addresses for each 4k append IO.
Quoted 1 line
I jsut test based on codes of last f2fs dev-test branch.
Yes, I had misread that due to the weird goto and misleading comment and translated it into:
Quoted 8 lines
/* If it will be an in-place direct write, don't bother. */ if (dio && !f2fs_lfs_mode(sbi)) return 0;It should be:
if (dio && f2fs_lfs_mode(sbi)) return 0;
Hmm, this addresses my 250 failure. And, I think the below commit can explain the case.
commit 47501f87c61ad2aa234add63e1ae231521dbc3f5
Author: Jaegeuk Kim <[email protected]> Date: Tue Nov 26 15:01:42 2019 -0800
f2fs: preallocate DIO blocks when forcing buffered_io
The previous preallocation and DIO decision like below.
allow_outplace_dio !allow_outplace_dio
f2fs_force_buffered_io (*) No_Prealloc / Buffered_IO Prealloc / Buffered_IO
!f2fs_force_buffered_io No_Prealloc / DIO Prealloc / DIO
But, Javier reported Case (*) where zoned device bypassed preallocation but fell back to buffered writes in f2fs_direct_IO(), resulting in stale data being read.
In order to fix the issue, actually we need to preallocate blocks whenever we fall back to buffered IO like this. No change is made in the other cases.
allow_outplace_dio !allow_outplace_dio
f2fs_force_buffered_io (*) Prealloc / Buffered_IO Prealloc / Buffered_IO
!f2fs_force_buffered_io No_Prealloc / DIO Prealloc / DIO
Quoted 6 lines
Do you have a proper explanation for why preallocations shouldn't be done in this case? Note that preallocations are still done for buffered writes, which may be out-of-place as well; how are those different?
- Eric
Chao Yu
maintainerRe: [PATCH 3/9] f2fs: rework write preallocations
Quoted 11 lines · Jaegeuk Kim
Quoted 10 lines · Eric Biggers
Quoted 9 lines · Chao Yu
Quoted 7 lines · Eric Biggers
From: Eric Biggers <[email protected]>
f2fs_write_begin()assumes that all blocks were preallocated by default unlessFI_NO_PREALLOCis explicitly set. This invites data corruption, as there are cases in which not all blocks are preallocated. Commit47501f87c61a("f2fs: preallocate DIO blocks when forcingbuffered_io") fixed one case, but there are others remaining.
Quoted 7 lines
Quoted 7 lines
Quoted 2 lines
Could you please explain which cases we missed to handle previously? then I can check those related logic before and after the rework.
Any case where a buffered write happens while not all blocks were preallocated but
FI_NO_PREALLOCwasn't set. For example when ENOSPC was hit in the middle of the preallocations for a direct write that will fall back to a buffered write, e.g. due tof2fs_force_buffered_io()or page cache invalidation failure.
Indeed, IIUC, the buggy code is as below, if any preallocation failed, we need to set FI_NO_PREALLOC flag.
map_blocks:
err = f2fs_map_blocks(inode, &map, 1, flag);
if (map.m_len > 0 && err == -ENOSPC) {
if (!direct_io) <----
set_inode_flag(inode, FI_NO_PREALLOC);
err = 0;
}BTW, it will be better to include above issue details you explained into commit message?
Quoted 54 lines
Quoted 19 lines
Quoted 14 lines
fs/f2fs/file.c static ssize_t f2fs_file_write_iter(struct kiocb *iocb, struct iov_iter *from) · line 4296
Quoted 10 lines
fs/f2fs/file.c +0
-8-/* -* If force_buffere_io() is true, we have to allocate -* blocks all the time, since f2fs_direct_IO will fall -* back to buffered IO. -*/ -if (!f2fs_force_buffered_io (inode, iocb, from) && -f2fs_lfs_mode (F2FS_I_SB (inode))) - goto write;We should keep this OPU DIO logic, otherwise, in lfs mode, write dio will always allocate two block addresses for each 4k append IO.
Quoted 1 line
I jsut test based on codes of last f2fs dev-test branch.
Yes, I had misread that due to the weird goto and misleading comment and translated it into:
Quoted 8 lines
/* If it will be an in-place direct write, don't bother. */ if (dio && !f2fs_lfs_mode(sbi)) return 0;It should be:
if (dio && f2fs_lfs_mode(sbi)) return 0;Hmm, this addresses my 250 failure. And, I think the below commit can explain the case.
commit
47501f87c61ad2aa234add63e1ae231521dbc3f5Author: Jaegeuk Kim <[email protected]> Date: Tue Nov 26 15:01:42 2019 -0800f2fs: preallocate DIO blocks when forcing
buffered_ioThe previous preallocation and DIO decision like below.
allow_outplace_dio!allow_outplace_dio
f2fs_force_buffered_io(*)No_Prealloc/Buffered_IOPrealloc /Buffered_IO
!f2fs_force_buffered_ioNo_Prealloc/ DIO Prealloc / DIOBut, Javier reported Case (*) where zoned device bypassed preallocation but fell back to buffered writes in
f2fs_direct_IO(), resulting in stale data being read.In order to fix the issue, actually we need to preallocate blocks whenever we fall back to buffered IO like this. No change is made in the other cases.
allow_outplace_dio!allow_outplace_dio
f2fs_force_buffered_io(*) Prealloc /Buffered_IOPrealloc /Buffered_IO
!f2fs_force_buffered_ioNo_Prealloc/ DIO Prealloc / DIO
Quoted 7 lines
Reported-and-tested-by Javier Gonzalez <[email protected]>Signed-off-by Damien Le Moal <[email protected]>Tested-by Shin'ichiro Kawasaki <[email protected]>Reviewed-by Chao Yu <[email protected]>Reviewed-by Javier González <[email protected]>Signed-off-by Jaegeuk Kim <[email protected]>
Thanks for the explain.
Quoted 3 lines
Quoted 3 lines
Do you have a proper explanation for why preallocations shouldn't be done in
See commit f847c699cff3 ("f2fs: allow out-place-update for direct IO in LFS mode"), f2fs_map_blocks() logic was changed to force allocating a new block address no matter previous block address was existed if it is called from write path of DIO. So, in such condition, if we preallocate new block address in f2fs_file_write_iter(), we will suffer the problem which my trace indicates.
Quoted 2 lines
Quoted 2 lines
this case? Note that preallocations are still done for buffered writes, which may be out-of-place as well; how are those different?
Got your concern.
For buffered IO, we use F2FS_GET_BLOCK_PRE_AIO, in this mode, we just preserve filesystem block count and tag NEW_ADDR in dnode block, so, it's fine, double new block address allocation won't happen during data page writeback.
For direct IO, we use F2FS_GET_BLOCK_PRE_DIO, in this mode, we will allocate physical block address, after preallocation, if we fallback to buffered IO, we may suffer double new block address allocation issue... IIUC.
Well, can we relocate preallocation into f2fs_direct_IO() after all cases which may cause fallbacking DIO to buffered IO?
Thanks,
Quoted 2 lines
Quoted 2 lines
- Eric
Re: [PATCH 3/9] f2fs: rework write preallocations
Quoted 17 lines · Chao Yu
Quoted 2 lines
Quoted 2 lines
Do you have a proper explanation for why preallocations shouldn't be done in
See commit
f847c699cff3("f2fs: allow out-place-update for direct IO in LFS mode"),f2fs_map_blocks()logic was changed to force allocating a new block address no matter previous block address was existed if it is called from write path of DIO. So, in such condition, if we preallocate new block address inf2fs_file_write_iter(), we will suffer the problem which my trace indicates.Quoted 2 lines
Quoted 2 lines
this case? Note that preallocations are still done for buffered writes, which may be out-of-place as well; how are those different?
Got your concern.
For buffered IO, we use
F2FS_GET_BLOCK_PRE_AIO, in this mode, we just preserve filesystem block count and tagNEW_ADDRin dnode block, so, it's fine, double new block address allocation won't happen during data page writeback.
Quoted 7 lines
For direct IO, we use
F2FS_GET_BLOCK_PRE_DIO, in this mode, we will allocate physical block address, after preallocation, if we fallback to buffered IO, we may suffer double new block address allocation issue... IIUC.Well, can we relocate preallocation into
f2fs_direct_IO()after all cases which may cause fallbacking DIO to buffered IO?
That's somewhat helpful, but I've been doing some more investigation and now I'm even more confused. How can f2fs support non-overwrite DIO writes at all (meaning DIO writes in LFS mode as well as DIO writes to holes in non-LFS mode), given that it has no support for unwritten extents? AFAICS, as-is users can easily leak uninitialized disk contents on f2fs by issuing a DIO write that won't complete fully (or might not complete fully), then reading back the blocks that got allocated but not written to.
I think that f2fs will have to take the ext2 approach of not allowing non-overwrite DIO writes at all...
- Eric
Chao Yu
maintainerRe: [PATCH 3/9] f2fs: rework write preallocations
Quoted 4 lines · Eric Biggers
That's somewhat helpful, but I've been doing some more investigation and now I'm even more confused. How can f2fs support non-overwrite DIO writes at all (meaning DIO writes in LFS mode as well as DIO writes to holes in non-LFS mode), given that it has no support for unwritten extents? AFAICS, as-is users can
I'm trying to pick up DAX support patch created by Qiuyang from huawei, and it looks it faces the same issue, so it tries to fix this by calling sb_issue_zeroout() in f2fs_map_blocks() before it returns.
Quoted 6 lines
easily leak uninitialized disk contents on f2fs by issuing a DIO write that won't complete fully (or might not complete fully), then reading back the blocks that got allocated but not written to.
I think that f2fs will have to take the ext2 approach of not allowing non-overwrite DIO writes at all...
Yes,
Another option is to enhance f2fs metadata's scalability which needs to update layout of dnode block or SSA block, after that we can record the status of unwritten data block there... it's a big change though...
Thanks,
Quoted 3 lines
- Eric
Re: [PATCH 3/9] f2fs: rework write preallocations
Quoted 9 lines · Chao Yu
Quoted 4 lines · Eric Biggers
That's somewhat helpful, but I've been doing some more investigation and now I'm even more confused. How can f2fs support non-overwrite DIO writes at all (meaning DIO writes in LFS mode as well as DIO writes to holes in non-LFS mode), given that it has no support for unwritten extents? AFAICS, as-is users can
I'm trying to pick up DAX support patch created by Qiuyang from huawei, and it looks it faces the same issue, so it tries to fix this by calling
sb_issue_zeroout()inf2fs_map_blocks()before it returns.
I really hope you don't, because zeroing the region before memcpy'ing it is absurd. I don't know if f2fs can do that (xfs can't really) without pinning resources during a potentially lengthy memcpy operation, but you /could/ allocate the space in ->iomap_begin, attach some record of that to iomap->private, and only commit the mapping update in ->iomap_end.
--D
Quoted 6 lines
Quoted 6 lines
easily leak uninitialized disk contents on f2fs by issuing a DIO write that won't complete fully (or might not complete fully), then reading back the blocks that got allocated but not written to.
I think that f2fs will have to take the ext2 approach of not allowing non-overwrite DIO writes at all...
Quoted 11 lines
Yes,
Another option is to enhance f2fs metadata's scalability which needs to update layout of dnode block or SSA block, after that we can record the status of unwritten data block there... it's a big change though...
Thanks,
Quoted 3 lines
- Eric
_______________________________________________
Linux-f2fs-devel mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
Jaegeuk Kim
maintainerRe: [PATCH 3/9] f2fs: rework write preallocations
In reply to Jaegeuk KimQuoted 41 lines · Jaegeuk Kim
Quoted 40 lines · Eric Biggers
Quoted 11 lines · Chao Yu
Quoted 7 lines · Eric Biggers
From: Eric Biggers <[email protected]>
f2fs_write_begin()assumes that all blocks were preallocated by default unlessFI_NO_PREALLOCis explicitly set. This invites data corruption, as there are cases in which not all blocks are preallocated. Commit47501f87c61a("f2fs: preallocate DIO blocks when forcingbuffered_io") fixed one case, but there are others remaining.Could you please explain which cases we missed to handle previously? then I can check those related logic before and after the rework.
Any case where a buffered write happens while not all blocks were preallocated but
FI_NO_PREALLOCwasn't set. For example when ENOSPC was hit in the middle of the preallocations for a direct write that will fall back to a buffered write, e.g. due tof2fs_force_buffered_io()or page cache invalidation failure.Quoted 13 lines
Review
Quoted 9 lines
(quoted diff) +0
-8- /* - * If force_buffere_io() is true, we have to allocate - * blocks all the time, since f2fs_direct_IO will fall - * back to buffered IO. - */ - if (!f2fs_force_buffered_io(inode, iocb, from) && - f2fs_lfs_mode(F2FS_I_SB(inode))) - goto write;We should keep this OPU DIO logic, otherwise, in lfs mode, write dio will always allocate two block addresses for each 4k append IO.
Quoted 1 line
I jsut test based on codes of last f2fs dev-test branch.
Yes, I had misread that due to the weird goto and misleading comment and translated it into:
/* If it will be an in-place direct write, don't bother. */ if (dio && !f2fs_lfs_mode(sbi)) return 0;
Quoted 7 lines
Quoted 4 lines
It should be:
if (dio && f2fs_lfs_mode(sbi)) return 0;Hmm, this addresses my 250 failure. And, I think the below commit can explain the case.
In addition to this, I got failure on generic/263, and the below change fixes it. (I didn't take a look at deeply tho.)
fs/f2fs/file.c +7 -2
@@ -4344,8 +4344,13 @@ static int f2fs_preallocate_blocks(struct kiocb *iocb, struct iov_iter *iter)return ret; } - map.m_lblk = (pos >> inode->i_blkbits); - map.m_len = ((pos + count -1 ) >> inode->i_blkbits) - map.m_lblk +1 ; + map.m_lblk =F2FS_BLK_ALIGN (pos); + map.m_len =F2FS_BYTES_TO_BLK (pos + count); +if (map.m_len > map.m_lblk) + map.m_len -= map.m_lblk; +else + map.m_len =0 ; +
Chao Yu
maintainerRe: [PATCH 3/9] f2fs: rework write preallocations
In reply to Darrick J. WongQuoted 11 lines · Darrick J. Wong
Quoted 9 lines · Chao Yu
Quoted 4 lines · Eric Biggers
That's somewhat helpful, but I've been doing some more investigation and now I'm even more confused. How can f2fs support non-overwrite DIO writes at all (meaning DIO writes in LFS mode as well as DIO writes to holes in non-LFS mode), given that it has no support for unwritten extents? AFAICS, as-is users can
I'm trying to pick up DAX support patch created by Qiuyang from huawei, and it looks it faces the same issue, so it tries to fix this by calling
sb_issue_zeroout()inf2fs_map_blocks()before it returns.
Quoted 5 lines
I really hope you don't, because zeroing the region before memcpy'ing it is absurd. I don't know if f2fs can do that (xfs can't really) without pinning resources during a potentially lengthy memcpy operation, but you /could/ allocate the space in ->iomap_begin, attach some record of that to
iomap->private, and only commit the mapping update in ->iomap_end.
Thanks for the suggestion, let me check this a little bit later, since now I just try to stabilize the codes...
Thanks,
Quoted 20 lines
--D
Quoted 17 lines
Quoted 6 lines
easily leak uninitialized disk contents on f2fs by issuing a DIO write that won't complete fully (or might not complete fully), then reading back the blocks that got allocated but not written to.
I think that f2fs will have to take the ext2 approach of not allowing non-overwrite DIO writes at all...
Yes,
Another option is to enhance f2fs metadata's scalability which needs to update layout of dnode block or SSA block, after that we can record the status of unwritten data block there... it's a big change though...
Thanks,
Quoted 3 lines
- Eric