gfs2 iomap write support
Subsystems (5)
Andreas Gruenbacher
maintainerv7 cover gfs2 iomap write support
Here's an update of my gfs2 iomap write patches, with support for buffered writes as well as direct I/O reads and writes through iomap.
Significant changes since v6:
* Switch to Christoph's patch for splitting out __generic_write_end and put the inode-dirtying change in a separate commit.
* Switch froma mandatory write_end operation to an optional page_write_end hook.
* Add a patch to pass struct iomap_ops in struct iomap at the end for demonstration purposes.
Significant changes since v5:
* Initial gfs2 specific cleanups split off and posted separately.
* New patch for generic iomap inline data handling.
* Iomap write_begin operation removed.
A 4.17 based version of the patches can be found here:
https://git.kernel.org/pub/scm/linux/kernel/git/gfs2/linux-gfs2.git/log/?h=iomap-write
Thanks,
Andreas
Andreas Gruenbacher (10):
iomap: Mark newly allocated buffer heads as new
iomap: Complete partial direct I/O writes synchronously
fs: allow to always dirty inode in __generic_write_end
iomap: Generic inline data handling
iomap: Add page_write_end iomap hook
gfs2: iomap buffered write support
gfs2: gfs2_extent_length cleanup
gfs2: iomap direct I/O support
gfs2: Remove gfs2_write_{begin,end}
iomap: Pass struct iomap_ops to iomap actors
Christoph Hellwig (2):
iomap: inline data should be an iomap type, not a flag
fs: factor out a __generic_write_end helper
fs/buffer.c | 75 ++++----- fs/dax.c | 8 +- fs/ext4/inline.c | 4 +- fs/gfs2/aops.c | 328 ++----------------------------------- fs/gfs2/aops.h | 22 +++ fs/gfs2/bmap.c | 368 ++++++++++++++++++++++++++++++++++++------ fs/gfs2/file.c | 172 ++++++++++++++++++-- fs/internal.h | 2 + fs/iomap.c | 99 +++++++++--- include/linux/iomap.h | 13 +- 10 files changed, 653 insertions(+), 438 deletions(-) create mode 100644 fs/gfs2/aops.h
Signature · 1 line
2.17.0
Andreas Gruenbacher
maintainerPATCH v7 1/12 iomap: inline data should be an iomap type, not a flag
From: Christoph Hellwig <[email protected]>
Inline data is fundamentally different from our normal mapped case in that it doesn't even have a block address. So instead of having a flag for it it should be an entirely separate iomap range type.
--- fs/ext4/inline.c | 4 ++-- fs/gfs2/bmap.c | 4 ++-- fs/iomap.c | 8 ++++---- include/linux/iomap.h | 2 +- 4 files changed, 9 insertions(+), 9 deletions(-)
fs/ext4/inline.c +2 -2
@@ -1835,8 +1835,8 @@ int ext4_inline_data_iomap(struct inode *inode, struct iomap *iomap) iomap->offset =0 ; iomap->length =min_t (loff_t,ext4_get_inline_size (inode),i_size_read (inode)); - iomap->type =0 ; - iomap->flags =IOMAP_F_DATA_INLINE ; + iomap->type =IOMAP_INLINE ; + iomap->flags =0 ; out:up_read (&EXT4_I (inode)->xattr_sem);
fs/gfs2/bmap.c +2 -2
@@ -767,8 +767,8 @@ static void gfs2_stuffed_iomap(struct inode *inode, struct iomap *iomap)sizeof (struct gfs2_dinode ); iomap->offset =0 ; iomap->length =i_size_read (inode); - iomap->type =IOMAP_MAPPED ; - iomap->flags =IOMAP_F_DATA_INLINE ; + iomap->type =IOMAP_INLINE ; + iomap->flags =0 ; }/**
fs/iomap.c +4 -4
@@ -498,22 +498,22 @@ static int iomap_to_fiemap(struct fiemap_extent_info *fi,case IOMAP_HOLE :/* skip holes */ return 0 ; +case IOMAP_MAPPED : +break ;case IOMAP_DELALLOC : flags |=FIEMAP_EXTENT_DELALLOC |FIEMAP_EXTENT_UNKNOWN ;break ;case IOMAP_UNWRITTEN : flags |=FIEMAP_EXTENT_UNWRITTEN ;break ; -case IOMAP_MAPPED : -break ; +case IOMAP_INLINE : + flags |=FIEMAP_EXTENT_DATA_INLINE ; }if (iomap->flags &IOMAP_F_MERGED ) flags |=FIEMAP_EXTENT_MERGED ;if (iomap->flags &IOMAP_F_SHARED ) flags |=FIEMAP_EXTENT_SHARED ; -if (iomap->flags &IOMAP_F_DATA_INLINE ) - flags |=FIEMAP_EXTENT_DATA_INLINE ; return fiemap_fill_next_extent(fi, iomap->offset, iomap->addr != IOMAP_NULL_ADDR ? iomap->addr : 0,
include/linux/iomap.h +1 -1
@@ -18,6 +18,7 @@ struct vm_fault;#define IOMAP_DELALLOC 0x02/* delayed allocation blocks */ #define IOMAP_MAPPED 0x03/* blocks allocated at @addr */ #define IOMAP_UNWRITTEN 0x04/* blocks allocated at @addr in unwritten state */ +#define IOMAP_INLINE 0x05/* data inline in the inode */ /* * Flags for all iomap mappings:
@@ -34,7 +35,6 @@ struct vm_fault;*/ #define IOMAP_F_MERGED 0x10/* contains multiple blocks/extents */ #define IOMAP_F_SHARED 0x20/* block shared with another file */ -#define IOMAP_F_DATA_INLINE 0x40/* data inline in the inode */ /* * Magic value for addr:
Signature · 1 line
2.17.0
Andreas Gruenbacher
maintainerPATCH v7 2/12 iomap: Mark newly allocated buffer heads as new
In reply to Andreas GruenbacherIn iomap_to_bh, not only mark buffer heads in IOMAP_UNWRITTEN maps as new, but also buffer heads in IOMAP_MAPPED maps with the IOMAP_F_NEW flag set. This will be used by filesystems like gfs2, which allocate blocks in iomap->begin.
Minor corrections to the comment for IOMAP_UNWRITTEN maps.
--- fs/buffer.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-)
fs/buffer.c +5 -4
@@ -1900,15 +1900,16 @@ iomap_to_bh(struct inode *inode, sector_t block, struct buffer_head *bh,break ;case IOMAP_UNWRITTEN :/* -* For unwritten regions, we always need to ensure that -* sub-block writes cause the regions in the block we are not -* writing to are zeroed. Set the buffer as new to ensure this. +* For unwritten regions, we always need to ensure that regions +* in the block we are not writing to are zeroed. Mark the +* buffer as new to ensure this. */ set_buffer_new (bh);set_buffer_unwritten (bh);/* FALLTHRU */ case IOMAP_MAPPED : -if (offset >=i_size_read (inode)) +if ((iomap->flags &IOMAP_F_NEW ) || + offset >=i_size_read (inode))set_buffer_new (bh); bh->b_blocknr = (iomap->addr + offset - iomap->offset) >> inode->i_blkbits;
Signature · 1 line
2.17.0
Andreas Gruenbacher
maintainerPATCH v7 3/12 iomap: Complete partial direct I/O writes synchronously
In reply to Andreas GruenbacherAccording to xfstest generic/240, applications seem to expect direct I/O writes to either complete as a whole or to fail; short direct I/O writes are apparently not appreciated. This means that when only part of an asynchronous direct I/O write succeeds, we can either fail the entire write, or we can wait for the partial write to complete and retry the remaining write as buffered I/O. The old __blockdev_direct_IO helper has code for waiting for partial writes to complete; the new iomap_dio_rw iomap helper does not.
The above mentioned fallback mode is needed for gfs2, which doesn't allow block allocations under direct I/O to avoid taking cluster-wide exclusive locks. As a consequence, an asynchronous direct I/O write to a file range that contains a hole will result in a short write. In that case, wait for the short write to complete to allow gfs2 to recover.
This will make xfstest generic/240 work on gfs2.
--- fs/iomap.c | 22 ++++++++++++---------- 1 file changed, 12 insertions(+), 10 deletions(-)
fs/iomap.c +12 -10
@@ -696,6 +696,7 @@ struct iomap_dio {atomic_t ref;unsigned flags;int error; +bool wait_for_completion;union {/* used during submission and for synchronous completion: */
@@ -797,9 +798,8 @@ static void iomap_dio_bio_end_io(struct bio *bio)iomap_dio_set_error (dio,blk_status_to_errno (bio->bi_status));if (atomic_dec_and_test (&dio->ref)) { -if (is_sync_kiocb (dio->iocb)) { +if (dio->wait_for_completion) {struct task_struct *waiter = dio->submit.waiter; -WRITE_ONCE (dio->submit.waiter,NULL );wake_up_process (waiter); }else if (dio->flags &IOMAP_DIO_WRITE ) {
@@ -990,13 +990,12 @@ iomap_dio_rw(struct kiocb *iocb, struct iov_iter *iter, dio->end_io = end_io; dio->error =0 ; dio->flags =0 ; + dio->wait_for_completion =is_sync_kiocb (iocb); dio->submit.iter = iter; -if (is_sync_kiocb (iocb)) { - dio->submit.waiter = current; - dio->submit.cookie =BLK_QC_T_NONE ; - dio->submit.last_queue =NULL ; - } + dio->submit.waiter = current; + dio->submit.cookie =BLK_QC_T_NONE ; + dio->submit.last_queue =NULL ;if (iov_iter_rw (iter) ==READ ) {if (pos >= dio->i_size)
@@ -1033,7 +1032,7 @@ iomap_dio_rw(struct kiocb *iocb, struct iov_iter *iter,dio_warn_stale_pagecache (iocb->ki_filp); ret =0 ; -if (iov_iter_rw (iter) ==WRITE && !is_sync_kiocb (iocb) && +if (iov_iter_rw (iter) ==WRITE && !dio->wait_for_completion && !inode->i_sb->s_dio_done_wq) { ret =sb_init_dio_done_wq (inode->i_sb);if (ret <0 )
@@ -1048,8 +1047,10 @@ iomap_dio_rw(struct kiocb *iocb, struct iov_iter *iter, iomap_dio_actor);if (ret <=0 ) {/* magic error code to fall back to buffered I/O */ -if (ret == -ENOTBLK ) +if (ret == -ENOTBLK ) { + dio->wait_for_completion = true; ret =0 ; + }break ; } pos += ret;
@@ -1062,8 +1063,9 @@ iomap_dio_rw(struct kiocb *iocb, struct iov_iter *iter,if (ret <0 )iomap_dio_set_error (dio, ret); +smp_mb__before_atomic ();if (!atomic_dec_and_test (&dio->ref)) { -if (!is_sync_kiocb (iocb)) +if (!dio->wait_for_completion)return -EIOCBQUEUED ;for (;;) {
Signature · 1 line
2.17.0
Andreas Gruenbacher
maintainerPATCH v7 4/12 fs: factor out a __generic_write_end helper
In reply to Andreas GruenbacherFrom: Christoph Hellwig <[email protected]>
Bits of the buffer.c based write_end implementations that don't know about buffer_heads and can be reused by other implementations.
--- fs/buffer.c | 67 +++++++++++++++++++++++++++------------------------ fs/internal.h | 2 ++ 2 files changed, 37 insertions(+), 32 deletions(-)
fs/buffer.c +35 -32
@@ -2077,6 +2077,40 @@ int block_write_begin(struct address_space *mapping, loff_t pos, unsigned len, }EXPORT_SYMBOL (block_write_begin); +int __generic_write_end (struct inode *inode,loff_t pos,unsigned copied, +struct page *page) +{ +loff_t old_size = inode->i_size; +bool i_size_changed = false; + +/* +* No need to use i_size_read() here, the i_size cannot change under us +* because we hold i_rwsem. +* +* But it's important to update i_size while still holding page lock: +* page writeout could otherwise come in and zero beyond i_size. +*/ +if (pos + copied > inode->i_size) { +i_size_write (inode, pos + copied); + i_size_changed = true; + } + +unlock_page (page); +put_page (page); + +if (old_size < pos) +pagecache_isize_extended (inode, old_size, pos); +/* +* Don't mark the inode dirty under page lock. First, it unnecessarily +* makes the holding time of page lock longer. Second, it forces lock +* ordering of page lock and transaction start for journaling +* filesystems. +*/ +if (i_size_changed) +mark_inode_dirty (inode); +return copied; +} +int block_write_end (struct file *file,struct address_space *mapping,loff_t pos,unsigned len,unsigned copied,struct page *page,void *fsdata)
@@ -2117,39 +2151,8 @@ int generic_write_end(struct file *file, struct address_space *mapping, loff_t pos, unsigned len, unsigned copied, struct page *page, void *fsdata) { - struct inode *inode = mapping->host; -loff_t old_size = inode->i_size; -int i_size_changed =0 ; - copied =block_write_end (file, mapping, pos, len, copied, page, fsdata); - -/* -* No need to use i_size_read() here, the i_size -* cannot change under us because we hold i_mutex. -* -* But it's important to update i_size while still holding page lock: -* page writeout could otherwise come in and zero beyond i_size. -*/ -if (pos+copied > inode->i_size) { -i_size_write (inode, pos+copied); - i_size_changed =1 ; - } - -unlock_page (page); -put_page (page); - -if (old_size < pos) -pagecache_isize_extended (inode, old_size, pos); -/* -* Don't mark the inode dirty under page lock. First, it unnecessarily -* makes the holding time of page lock longer. Second, it forces lock -* ordering of page lock and transaction start for journaling -* filesystems. -*/ -if (i_size_changed) -mark_inode_dirty (inode); - -return copied; +return __generic_write_end (mapping->host, pos, copied, page); }EXPORT_SYMBOL (generic_write_end);
fs/internal.h +2 -0
@@ -43,6 +43,8 @@ static inline int __sync_blockdev(struct block_device *bdev, int wait)extern void guard_bio_eod (int rw,struct bio *bio);extern int __block_write_begin_int (struct page *page,loff_t pos,unsigned len,get_block_t *get_block,struct iomap *iomap); +int __generic_write_end (struct inode *inode,loff_t pos,unsigned copied, +struct page *page);/* * char_dev.c
Signature · 1 line
2.17.0
Andreas Gruenbacher
maintainerPATCH v7 5/12 fs: allow to always dirty inode in __generic_write_end
In reply to Andreas GruenbacherIn __generic_write_end, we usually dirty the inode only when the file size changes. Allow to dirty the inode even when the file size stays the same; this will be used when writing to inline data stored in the inode.
--- fs/buffer.c | 9 ++++----- fs/internal.h | 2 +- 2 files changed, 5 insertions(+), 6 deletions(-)
fs/buffer.c +4 -5
@@ -2078,10 +2078,9 @@ int block_write_begin(struct address_space *mapping, loff_t pos, unsigned len,EXPORT_SYMBOL (block_write_begin);int __generic_write_end (struct inode *inode,loff_t pos,unsigned copied, -struct page *page) +struct page *page,bool dirty_inode) {loff_t old_size = inode->i_size; -bool i_size_changed = false;/* * No need to use i_size_read() here, the i_size cannot change under us
@@ -2092,7 +2091,7 @@ int __generic_write_end(struct inode *inode, loff_t pos, unsigned copied,*/ if (pos + copied > inode->i_size) {i_size_write (inode, pos + copied); - i_size_changed = true; + dirty_inode = true; }unlock_page (page);
@@ -2106,7 +2105,7 @@ int __generic_write_end(struct inode *inode, loff_t pos, unsigned copied,* ordering of page lock and transaction start for journaling * filesystems. */ -if (i_size_changed) +if (dirty_inode)mark_inode_dirty (inode);return copied; }
@@ -2152,7 +2151,7 @@ int generic_write_end(struct file *file, struct address_space *mapping, struct page *page, void *fsdata) { copied =block_write_end (file, mapping, pos, len, copied, page, fsdata); -return __generic_write_end (mapping->host, pos, copied, page); +return __generic_write_end (mapping->host, pos, copied, page, false); }EXPORT_SYMBOL (generic_write_end);
fs/internal.h +1 -1
@@ -44,7 +44,7 @@ extern void guard_bio_eod(int rw, struct bio *bio);extern int __block_write_begin_int (struct page *page,loff_t pos,unsigned len,get_block_t *get_block,struct iomap *iomap);int __generic_write_end (struct inode *inode,loff_t pos,unsigned copied, -struct page *page); +struct page *page,bool dirty_inode);/* * char_dev.c
Signature · 1 line
2.17.0
Re: [PATCH v7 05/12] fs: allow to always dirty inode in __generic_write_end
fs/buffer.c int __generic_write_end(struct inode *inode, loff_t pos, unsigned copied, · line 2110
Quoted 8 lines · Andreas Gruenbacher
fs/buffer.c +1
-1@@ -2106,7 +2105,7 @@ int __generic_write_end(struct inode *inode, loff_t pos, unsigned copied,* ordering of page lock and transaction start for journaling * filesystems. */ -if (i_size_changed) +if (dirty_inode)mark_inode_dirty (inode);return copied;
Calling mark_inode_dirty on an already dirty inode is cheap, so how about just calling it directly in your caller that always wants to set the inode dirty?
Re: [PATCH v7 05/12] fs: allow to always dirty inode in __generic_write_end
2018-06-04 14:48 GMT+02:00 Christoph Hellwig <[email protected]>:
Quoted 5 lines · Andreas Gruenbacher
Quoted 4 lines
fs/buffer.c +0
-0@@ -2106,7 +2105,7 @@ int __generic_write_end(struct inode *inode, loff_t pos, unsigned copied,* ordering of page lock and transaction start for journaling * filesystems. */
Quoted 8 lines
fs/buffer.c int __generic_write_end(struct inode *inode, loff_t pos, unsigned copied, · line 2110
Quoted 4 lines
fs/buffer.c +1
-1-if (i_size_changed) +if (dirty_inode)mark_inode_dirty (inode);return copied;Calling
mark_inode_dirtyon an already dirty inode is cheap, so how about just calling it directly in your caller that always wants to set the inode dirty?
The dirty_inode hook is where gfs2 converts the in-core inode into the on-disk format (the equivalent of xfs_inode_to_disk), so it's not quite that cheap. I realize this could be done differently in gfs2, but that's not where we stand today, and I really can't fix ten things all at the same time.
Thanks,
Andreas
Andreas Gruenbacher
maintainerPATCH v7 6/12 iomap: Generic inline data handling
In reply to Andreas GruenbacherAdd generic inline data handling by adding a pointer to the inline data region to struct iomap. When handling a buffered IOMAP_INLINE write, iomap_write_begin will copy the current inline data from the inline data region into the page cache, and iomap_write_end will copy the changes in the page cache back to the inline data region.
This doesn't cover inline data reads and direct I/O yet because so far, we have no users.
--- fs/iomap.c | 55 +++++++++++++++++++++++++++++++++++++++---- include/linux/iomap.h | 1 + 2 files changed, 52 insertions(+), 4 deletions(-)
fs/iomap.c +51 -4
@@ -108,6 +108,40 @@ iomap_write_failed(struct inode *inode, loff_t pos, unsigned len)truncate_pagecache_range (inode,max (pos, i_size), pos + len); } +static void +iomap_read_inline_data (struct page *page,struct iomap *iomap,loff_t size) +{ +void *data = iomap->inline_data; +void *addr; + +if (PageUptodate (page)) +return ; + +BUG_ON (page->index); +BUG_ON (size >PAGE_SIZE -offset_in_page (data)); + + addr =kmap_atomic (page); +memcpy (addr, data, size); +memset (addr + size,0 ,PAGE_SIZE - size); +kunmap_atomic (addr); +SetPageUptodate (page); +} + +static void +iomap_write_inline_data (struct page *page,struct iomap *iomap,off_t pos, +unsigned copied) +{ +void *data = iomap->inline_data; +void *addr; + +BUG_ON (pos + copied >PAGE_SIZE -offset_in_page (data)); +WARN_ON_ONCE (!PageUptodate (page)); + + addr =kmap_atomic (page); +memcpy (data + pos, addr + pos, copied); +kunmap_atomic (addr); +} +static int iomap_write_begin (struct inode *inode,loff_t pos,unsigned len,unsigned flags,struct page **pagep,struct iomap *iomap)
@@ -125,6 +159,11 @@ iomap_write_begin(struct inode *inode, loff_t pos, unsigned len, unsigned flags,if (!page)return -ENOMEM ; +if (iomap->type ==IOMAP_INLINE ) { +iomap_read_inline_data (page, iomap, inode->i_size); + goto out; + } + status =__block_write_begin_int (page, pos, len,NULL , iomap);if (unlikely (status)) {unlock_page (page);
@@ -134,16 +173,23 @@ iomap_write_begin(struct inode *inode, loff_t pos, unsigned len, unsigned flags,iomap_write_failed (inode, pos, len); } +out: *pagep = page;return status; }static int iomap_write_end (struct inode *inode,loff_t pos,unsigned len, -unsigned copied,struct page *page) +unsigned copied,struct page *page,struct iomap *iomap) {int ret; +if (iomap->type ==IOMAP_INLINE ) { +iomap_write_inline_data (page, iomap, pos, copied); +__generic_write_end (inode, pos, copied, page, true); +return copied; + } + ret =generic_write_end (NULL , inode->i_mapping, pos, len, copied, page,NULL );if (ret < len)
@@ -200,7 +246,8 @@ iomap_write_actor(struct inode *inode, loff_t pos, loff_t length, void *data,flush_dcache_page (page); - status =iomap_write_end (inode, pos, bytes, copied, page); + status =iomap_write_end (inode, pos, bytes, copied, page, + iomap);if (unlikely (status <0 ))break ; copied = status;
@@ -294,7 +341,7 @@ iomap_dirty_actor(struct inode *inode, loff_t pos, loff_t length, void *data,WARN_ON_ONCE (!PageUptodate (page)); - status =iomap_write_end (inode, pos, bytes, bytes, page); + status =iomap_write_end (inode, pos, bytes, bytes, page, iomap);if (unlikely (status <=0 )) {if (WARN_ON_ONCE (status ==0 ))return -EIO ;
@@ -346,7 +393,7 @@ static int iomap_zero(struct inode *inode, loff_t pos, unsigned offset,zero_user (page, offset, bytes);mark_page_accessed (page); -return iomap_write_end (inode, pos, bytes, bytes, page); +return iomap_write_end (inode, pos, bytes, bytes, page, iomap); } static int iomap_dax_zero(loff_t pos, unsigned offset, unsigned bytes,
include/linux/iomap.h +1 -0
@@ -47,6 +47,7 @@ struct iomap {u64 length;/* length of mapping, bytes */ u16 type;/* type of mapping */ u16 flags;/* flags for mapping */ +void *inline_data;/* inline data buffer */ struct block_device *bdev;/* block device for I/O */ struct dax_device *dax_dev;/* dax_dev for dax operations */ };
Signature · 1 line
2.17.0
Andreas Gruenbacher
maintainerPATCH v7 7/12 iomap: Add page_write_end iomap hook
In reply to Andreas GruenbacherAdd a page_write_end hook called when done writing to a page, for filesystems that implement data journaling: in that case, pages are written to the journal before being written back to their proper on-disk locations. The new hook is bypassed for IOMAP_INLINE mappings.
--- fs/iomap.c | 56 ++++++++++++++++++++++++++++++++----------- include/linux/iomap.h | 8 +++++++ 2 files changed, 50 insertions(+), 14 deletions(-)
fs/iomap.c +42 -14
@@ -180,7 +180,8 @@ iomap_write_begin(struct inode *inode, loff_t pos, unsigned len, unsigned flags,static int iomap_write_end (struct inode *inode,loff_t pos,unsigned len, -unsigned copied,struct page *page,struct iomap *iomap) +unsigned copied,struct page *page,struct iomap *iomap, +const struct iomap_ops *ops) {int ret;
@@ -190,6 +191,9 @@ iomap_write_end(struct inode *inode, loff_t pos, unsigned len,return copied; } +if (ops->page_write_end) + ops->page_write_end (inode, pos, copied, page); + ret =generic_write_end (NULL , inode->i_mapping, pos, len, copied, page,NULL );if (ret < len)
@@ -197,11 +201,17 @@ iomap_write_end(struct inode *inode, loff_t pos, unsigned len,return ret; } +struct iomap_write_args { +const struct iomap_ops *ops; +struct iov_iter *iter; +}; +static loff_t iomap_write_actor (struct inode *inode,loff_t pos,loff_t length,void *data,struct iomap *iomap) { -struct iov_iter *i = data; +struct iomap_write_args *args = data; +struct iov_iter *i = args->iter;long status =0 ;ssize_t written =0 ;unsigned int flags =AOP_FLAG_NOFS ;
@@ -247,7 +257,7 @@ iomap_write_actor(struct inode *inode, loff_t pos, loff_t length, void *data,flush_dcache_page (page); status =iomap_write_end (inode, pos, bytes, copied, page, - iomap); + iomap, args->ops);if (unlikely (status <0 ))break ; copied = status;
@@ -284,10 +294,14 @@ iomap_file_buffered_write(struct kiocb *iocb, struct iov_iter *iter, {struct inode *inode = iocb->ki_filp->f_mapping->host;loff_t pos = iocb->ki_pos, ret =0 , written =0 ; +struct iomap_write_args args = { + .ops = ops, + .iter = iter, + };while (iov_iter_count (iter)) { ret =iomap_apply (inode, pos,iov_iter_count (iter), -IOMAP_WRITE , ops, iter, iomap_write_actor); +IOMAP_WRITE , ops, &args, iomap_write_actor);if (ret <=0 )break ; pos += ret;
@@ -318,6 +332,7 @@ static loff_t iomap_dirty_actor(struct inode *inode, loff_t pos, loff_t length, void *data, struct iomap *iomap) { + const struct iomap_ops *ops = data;long status =0 ;ssize_t written =0 ;
@@ -341,7 +356,8 @@ iomap_dirty_actor(struct inode *inode, loff_t pos, loff_t length, void *data,WARN_ON_ONCE (!PageUptodate (page)); - status =iomap_write_end (inode, pos, bytes, bytes, page, iomap); + status =iomap_write_end (inode, pos, bytes, bytes, page, iomap, + ops);if (unlikely (status <=0 )) {if (WARN_ON_ONCE (status ==0 ))return -EIO ;
@@ -367,8 +383,8 @@ iomap_file_dirty(struct inode *inode, loff_t pos, loff_t len,loff_t ret;while (len) { - ret =iomap_apply (inode, pos, len,IOMAP_WRITE , ops,NULL , - iomap_dirty_actor); + ret =iomap_apply (inode, pos, len,IOMAP_WRITE , ops, + (void *)ops, iomap_dirty_actor);if (ret <=0 )return ret; pos += ret;
@@ -380,7 +396,8 @@ iomap_file_dirty(struct inode *inode, loff_t pos, loff_t len,EXPORT_SYMBOL_GPL (iomap_file_dirty);static int iomap_zero (struct inode *inode,loff_t pos,unsigned offset, -unsigned bytes,struct iomap *iomap) +unsigned bytes,const struct iomap_ops *ops, +struct iomap *iomap) {struct page *page;int status;
@@ -393,7 +410,8 @@ static int iomap_zero(struct inode *inode, loff_t pos, unsigned offset,zero_user (page, offset, bytes);mark_page_accessed (page); -return iomap_write_end (inode, pos, bytes, bytes, page, iomap); +return iomap_write_end (inode, pos, bytes, bytes, page, iomap, + ops); } static int iomap_dax_zero(loff_t pos, unsigned offset, unsigned bytes,
@@ -406,11 +424,16 @@ static int iomap_dax_zero(loff_t pos, unsigned offset, unsigned bytes, offset, bytes); } +struct iomap_zero_range_args { +const struct iomap_ops *ops; +bool *did_zero; +}; +static loff_t iomap_zero_range_actor (struct inode *inode,loff_t pos,loff_t count,void *data,struct iomap *iomap) { -bool *did_zero = data; +struct iomap_zero_range_args *args = data;loff_t written =0 ;int status;
@@ -427,15 +450,16 @@ iomap_zero_range_actor(struct inode *inode, loff_t pos, loff_t count,if (IS_DAX (inode)) status =iomap_dax_zero (pos, offset, bytes, iomap);else - status =iomap_zero (inode, pos, offset, bytes, iomap); + status =iomap_zero (inode, pos, offset, bytes, + args->ops, iomap);if (status <0 )return status; pos += bytes; count -= bytes; written += bytes; -if (did_zero) - *did_zero = true; +if (args->did_zero) + *args->did_zero = true; }while (count >0 );return written;
@@ -445,11 +469,15 @@ int iomap_zero_range(struct inode *inode, loff_t pos, loff_t len, bool *did_zero, const struct iomap_ops *ops) { + struct iomap_zero_range_args args = { + .ops = ops, + .did_zero = did_zero, + };loff_t ret;while (len >0 ) { ret =iomap_apply (inode, pos, len,IOMAP_ZERO , - ops, did_zero, iomap_zero_range_actor); + ops, &args, iomap_zero_range_actor);if (ret <=0 )return ret;
include/linux/iomap.h +8 -0
@@ -8,6 +8,7 @@ struct fiemap_extent_info;struct inode ;struct iov_iter ;struct kiocb ; +struct page ;struct vm_area_struct ;struct vm_fault ;
@@ -71,6 +72,13 @@ struct iomap_ops {int (*iomap_begin)(struct inode *inode,loff_t pos,loff_t length,unsigned flags,struct iomap *iomap); +/* +* Called when done writing to a page (optional; skipped for +* IOMAP_INLINE mappings). +*/ +void (*page_write_end)(struct inode *inode,loff_t pos,unsigned copied, +struct page *page); +/* * Commit and/or unreserve space previous allocated using iomap_begin. * Written indicates the length of the successful write operation which
Signature · 1 line
2.17.0
Re: [PATCH v7 07/12] iomap: Add page_write_end iomap hook
Quoted 4 lines · Andreas Gruenbacher
Add a
page_write_endhook called when done writing to a page, for filesystems that implement data journaling: in that case, pages are written to the journal before being written back to their proper on-disk locations. The new hook is bypassed forIOMAP_INLINEmappings.
I'd rather not bypass it in common code. Can you pass the iomap to the callback and then do the bypass in gfs2 to keep it generic?
Re: [PATCH v7 07/12] iomap: Add page_write_end iomap hook
2018-06-04 14:50 GMT+02:00 Christoph Hellwig <[email protected]>:
Quoted 8 lines · Andreas Gruenbacher
Quoted 4 lines
Add a
page_write_endhook called when done writing to a page, for filesystems that implement data journaling: in that case, pages are written to the journal before being written back to their proper on-disk locations. The new hook is bypassed forIOMAP_INLINEmappings.I'd rather not bypass it in common code. Can you pass the iomap to the callback and then do the bypass in gfs2 to keep it generic?
As you wish. You realize we're in extreme bike shed coloring land though, right?
Andreas
Andreas Gruenbacher
maintainerPATCH v7 8/12 gfs2: iomap buffered write support
In reply to Andreas GruenbacherWith the traditional page-based writes, blocks are allocated separately for each page written to. With iomap writes, we can allocate a lot more blocks at once, with a fraction of the allocation overhead for each page.
Split calculating the number of blocks that can be allocated at a given position (gfs2_alloc_size) off from gfs2_iomap_alloc: that size determines the number of blocks to allocate and reserve in the journal.
In gfs2_iomap_alloc, set the type of newly allocated extents to IOMAP_MAPPED so that iomap_to_bh will set the bh states correctly:
otherwise, the bhs would not be marked as mapped, confusing __mpage_writepage. This means that we need to check for the IOMAP_F_NEW flag in fallocate_chunk now.
--- fs/gfs2/aops.c | 20 +-- fs/gfs2/aops.h | 22 ++++ fs/gfs2/bmap.c | 325 ++++++++++++++++++++++++++++++++++++++++++++----- fs/gfs2/file.c | 46 +++++-- 4 files changed, 367 insertions(+), 46 deletions(-) create mode 100644 fs/gfs2/aops.h
fs/gfs2/aops.c +11 -9
@@ -22,6 +22,7 @@#include <linux/backing-dev.h> #include <linux/uio.h> #include <trace/events/writeback.h> +#include <linux/sched/signal.h> #include "gfs2.h" #include "incore.h"
@@ -36,10 +37,11 @@#include "super.h" #include "util.h" #include "glops.h" +#include "aops.h" -static void gfs2_page_add_databufs (struct gfs2_inode *ip,struct page *page, -unsigned int from,unsigned int len) +void gfs2_page_add_databufs (struct gfs2_inode *ip,struct page *page, +unsigned int from,unsigned int len) {struct buffer_head *head =page_buffers (page);unsigned int bsize = head->b_size;
@@ -462,7 +464,7 @@ static int gfs2_jdata_writepages(struct address_space *mapping,* Returns: errno */ -static int stuffed_readpage (struct gfs2_inode *ip,struct page *page) +int stuffed_readpage (struct gfs2_inode *ip,struct page *page) {struct buffer_head *dibh;u64 dsize =i_size_read (&ip->i_inode);
@@ -773,7 +775,7 @@ static int gfs2_write_begin(struct file *file, struct address_space *mapping,* adjust_fs_space - Adjusts the free space available due to gfs2_grow * @inode: the rindex inode */ -static void adjust_fs_space (struct inode *inode) +void adjust_fs_space (struct inode *inode) {struct gfs2_sbd *sdp = inode->i_sb->s_fs_info;struct gfs2_inode *m_ip =GFS2_I (sdp->sd_statfs_inode);
@@ -819,11 +821,11 @@ static void adjust_fs_space(struct inode *inode)* This copies the data from the page into the inode block after * the inode data structure itself. * -* Returns: errno +* Returns: copied bytes or errno */ -static int gfs2_stuffed_write_end (struct inode *inode,struct buffer_head *dibh, -loff_t pos,unsigned copied, -struct page *page) +int gfs2_stuffed_write_end (struct inode *inode,struct buffer_head *dibh, +loff_t pos,unsigned copied, +struct page *page) {struct gfs2_inode *ip =GFS2_I (inode);u64 to = pos + copied;
@@ -862,7 +864,7 @@ static int gfs2_stuffed_write_end(struct inode *inode, struct buffer_head *dibh,* The main write_end function for GFS2. We just put our locking around the VFS * provided functions. * -* Returns: errno +* Returns: copied bytes or errno */ static int gfs2_write_end(struct file *file, struct address_space *mapping,
fs/gfs2/aops.h new file +22 -0
@@ -0,0 +1,22 @@ +/* +* Copyright (C) 2017 Red Hat, Inc. All rights reserved. +* +* This copyrighted material is made available to anyone wishing to use, +* modify, copy, or redistribute it subject to the terms and conditions +* of the GNU General Public License version 2. +*/ + +#ifndef __AOPS_DOT_H__ +#define __AOPS_DOT_H__ + +#include "incore.h" + +extern int stuffed_readpage (struct gfs2_inode *ip,struct page *page); +extern int gfs2_stuffed_write_end (struct inode *inode,struct buffer_head *dibh, +loff_t pos,unsigned copied, +struct page *page); +extern void adjust_fs_space (struct inode *inode); +extern void gfs2_page_add_databufs (struct gfs2_inode *ip,struct page *page, +unsigned int from,unsigned int len); + +#endif /* __AOPS_DOT_H__ */
fs/gfs2/bmap.c +295 -30
432 lines not on this page · raw message
fs/gfs2/file.c +39 -7
80 lines not on this page · raw message
Signature · 1 line
2.17.0
Andreas Gruenbacher
maintainerPATCH v7 9/12 gfs2: gfs2_extent_length cleanup
In reply to Andreas GruenbacherNow that gfs2_extent_length is no longer used for determining the size of a hole and always with an upper size limit, the function can be simplified.
--- fs/gfs2/bmap.c | 24 ++++++++---------------- 1 file changed, 8 insertions(+), 16 deletions(-)
fs/gfs2/bmap.c +8 -16
@@ -406,22 +406,17 @@ static void release_metapath(struct metapath *mp)/** * gfs2_extent_length - Returns length of an extent of blocks -* @start: Start of the buffer -* @len: Length of the buffer in bytes -* @ptr: Current position in the buffer -* @limit: Max extent length to return (0 = unlimited) +* @bh: The metadata block +* @ptr: Current position in @bh +* @limit: Max extent length to return * @eob: Set to 1 if we hit "end of block" * -* If the first block is zero (unallocated) it will return the number of -* unallocated blocks in the extent, otherwise it will return the number -* of contiguous blocks in the extent. -* * Returns: The length of the extent (minimum of one block) */ -static inline unsigned int gfs2_extent_length (void *start,unsigned int len,__be64 *ptr,size_t limit,int *eob) +static inline unsigned int gfs2_extent_length (struct buffer_head *bh,__be64 *ptr,size_t limit,int *eob) { -const __be64 *end = (start + len); +const __be64 *end = (__be64 *)(bh->b_data + bh->b_size);const __be64 *first = ptr;u64 d =be64_to_cpu (*ptr);
@@ -430,14 +425,11 @@ static inline unsigned int gfs2_extent_length(void *start, unsigned int len, __b ptr++;if (ptr >= end)break ; -if (limit && --limit ==0 ) -break ; -if (d) - d++; + d++; }while (be64_to_cpu (*ptr) == d);if (ptr >= end) *eob =1 ; -return (ptr - first); +return ptr - first; } typedef const __be64 *(*gfs2_metadata_walker)(
@@ -883,7 +875,7 @@ static int gfs2_iomap_get(struct inode *inode, loff_t pos, loff_t length, goto do_alloc; bh = mp->mp_bh[ip->i_height -1 ]; - len =gfs2_extent_length (bh->b_data, bh->b_size, ptr, len, &eob); + len =gfs2_extent_length (bh, ptr, len, &eob); iomap->addr =be64_to_cpu (*ptr) << inode->i_blkbits; iomap->length = len << inode->i_blkbits;
Signature · 1 line
2.17.0
Andreas Gruenbacher
maintainerPATCH v7 10/12 gfs2: iomap direct I/O support
In reply to Andreas GruenbacherThe page unmapping previously done in gfs2_direct_IO is now done generically in iomap_dio_rw.
--- fs/gfs2/aops.c | 100 +---------------------------------- fs/gfs2/bmap.c | 15 +++++- fs/gfs2/file.c | 138 +++++++++++++++++++++++++++++++++++++++++++++---- 3 files changed, 143 insertions(+), 110 deletions(-)
fs/gfs2/aops.c +2 -98
@@ -84,12 +84,6 @@ static int gfs2_get_block_noalloc(struct inode *inode, sector_t lblock,return 0 ; } -static int gfs2_get_block_direct (struct inode *inode,sector_t lblock, -struct buffer_head *bh_result,int create) -{ -return gfs2_block_map (inode, lblock, bh_result,0 ); -} -/** * gfs2_writepage_common - Common bits of writepage * @page: The page to be written
@@ -1021,96 +1015,6 @@ static void gfs2_invalidatepage(struct page *page, unsigned int offset,try_to_release_page (page,0 ); } -/** -* gfs2_ok_for_dio - check that dio is valid on this file -* @ip: The inode -* @offset: The offset at which we are reading or writing -* -* Returns: 0 (to ignore the i/o request and thus fall back to buffered i/o) -* 1 (to accept the i/o request) -*/ -static int gfs2_ok_for_dio (struct gfs2_inode *ip,loff_t offset) -{ -/* -* Should we return an error here? I can't see that O_DIRECT for -* a stuffed file makes any sense. For now we'll silently fall -* back to buffered I/O -*/ -if (gfs2_is_stuffed (ip)) -return 0 ; - -if (offset >=i_size_read (&ip->i_inode)) -return 0 ; -return 1 ; -} - - - -static ssize_t gfs2_direct_IO (struct kiocb *iocb,struct iov_iter *iter) -{ -struct file *file = iocb->ki_filp; -struct inode *inode = file->f_mapping->host; -struct address_space *mapping = inode->i_mapping; -struct gfs2_inode *ip =GFS2_I (inode); -loff_t offset = iocb->ki_pos; -struct gfs2_holder gh; -int rv; - -/* -* Deferred lock, even if its a write, since we do no allocation -* on this path. All we need change is atime, and this lock mode -* ensures that other nodes have flushed their buffered read caches -* (i.e. their page cache entries for this inode). We do not, -* unfortunately have the option of only flushing a range like -* the VFS does. -*/ -gfs2_holder_init (ip->i_gl,LM_ST_DEFERRED ,0 , &gh); - rv =gfs2_glock_nq (&gh); -if (rv) - goto out_uninit; - rv =gfs2_ok_for_dio (ip, offset); -if (rv !=1 ) - goto out;/* dio not valid, fall back to buffered i/o */ - -/* -* Now since we are holding a deferred (CW) lock at this point, you -* might be wondering why this is ever needed. There is a case however -* where we've granted a deferred local lock against a cached exclusive -* glock. That is ok provided all granted local locks are deferred, but -* it also means that it is possible to encounter pages which are -* cached and possibly also mapped. So here we check for that and sort -* them out ahead of the dio. The glock state machine will take care of -* everything else. -* -* If in fact the cached glock state (gl->gl_state) is deferred (CW) in -* the first place, mapping->nr_pages will always be zero. -*/ -if (mapping->nrpages) { -loff_t lstart = offset & ~(PAGE_SIZE -1 ); -loff_t len =iov_iter_count (iter); -loff_t end =PAGE_ALIGN (offset + len) -1 ; - - rv =0 ; -if (len ==0 ) - goto out; -if (test_and_clear_bit (GIF_SW_PAGED , &ip->i_flags)) -unmap_shared_mapping_range (ip->i_inode.i_mapping, offset, len); - rv =filemap_write_and_wait_range (mapping, lstart, end); -if (rv) - goto out; -if (iov_iter_rw (iter) ==WRITE ) -truncate_inode_pages_range (mapping, lstart, end); - } - - rv =__blockdev_direct_IO (iocb, inode, inode->i_sb->s_bdev, iter, - gfs2_get_block_direct,NULL ,NULL ,0 ); -out: -gfs2_glock_dq (&gh); -out_uninit: -gfs2_holder_uninit (&gh); -return rv; -} -/** * gfs2_releasepage - free the metadata associated with a page * @page: the page that's being released
@@ -1191,7 +1095,7 @@ static const struct address_space_operations gfs2_writeback_aops = { .bmap = gfs2_bmap, .invalidatepage = gfs2_invalidatepage, .releasepage = gfs2_releasepage, - .direct_IO = gfs2_direct_IO, + .direct_IO = noop_direct_IO, .migratepage = buffer_migrate_page, .is_partially_uptodate = block_is_partially_uptodate, .error_remove_page = generic_error_remove_page,
@@ -1208,7 +1112,7 @@ static const struct address_space_operations gfs2_ordered_aops = { .bmap = gfs2_bmap, .invalidatepage = gfs2_invalidatepage, .releasepage = gfs2_releasepage, - .direct_IO = gfs2_direct_IO, + .direct_IO = noop_direct_IO, .migratepage = buffer_migrate_page, .is_partially_uptodate = block_is_partially_uptodate, .error_remove_page = generic_error_remove_page,
fs/gfs2/bmap.c +13 -2
@@ -905,6 +905,10 @@ static int gfs2_iomap_get(struct inode *inode, loff_t pos, loff_t length, iomap->length = size - pos; }else if (flags &IOMAP_WRITE ) {u64 size; + +if (flags &IOMAP_DIRECT ) + goto out; + size =gfs2_alloc_size (inode, mp, len) << inode->i_blkbits;if (size < iomap->length) iomap->length = size;
@@ -1066,7 +1070,14 @@ static int gfs2_iomap_begin(struct inode *inode, loff_t pos, loff_t length,trace_gfs2_iomap_start (ip, pos, length, flags);if (flags &IOMAP_WRITE ) { - ret =gfs2_iomap_begin_write (inode, pos, length, flags, iomap); +if (flags &IOMAP_DIRECT ) { + ret =gfs2_iomap_get (inode, pos, length, flags, iomap, &mp); +release_metapath (&mp); +if (iomap->type !=IOMAP_MAPPED ) + ret = -ENOTBLK ; + }else { + ret =gfs2_iomap_begin_write (inode, pos, length, flags, iomap); + } }else { ret =gfs2_iomap_get (inode, pos, length, flags, iomap, &mp);release_metapath (&mp);
@@ -1091,7 +1102,7 @@ static int gfs2_iomap_end(struct inode *inode, loff_t pos, loff_t length,struct gfs2_sbd *sdp =GFS2_SB (inode);struct gfs2_trans *tr = current->journal_info; -if (!(flags &IOMAP_WRITE )) +if ((flags & (IOMAP_WRITE |IOMAP_DIRECT )) !=IOMAP_WRITE )return 0 ;if (iomap->type ==IOMAP_INLINE ) {
fs/gfs2/file.c +128 -10
183 lines not on this page · raw message
Signature · 1 line
2.17.0
Andreas Gruenbacher
maintainerPATCH v7 11/12 gfs2: Remove gfs2_write_{begin,end}
In reply to Andreas GruenbacherNow that generic_file_write_iter is no longer used, there are no remaining users of these address space operations.
--- fs/gfs2/aops.c | 210 ------------------------------------------------- 1 file changed, 210 deletions(-)
fs/gfs2/aops.c +0 -210
@@ -639,132 +639,6 @@ static int gfs2_readpages(struct file *file, struct address_space *mapping,return ret; } -/** -* gfs2_write_begin - Begin to write to a file -* @file: The file to write to -* @mapping: The mapping in which to write -* @pos: The file offset at which to start writing -* @len: Length of the write -* @flags: Various flags -* @pagep: Pointer to return the page -* @fsdata: Pointer to return fs data (unused by GFS2) -* -* Returns: errno -*/ - -static int gfs2_write_begin (struct file *file,struct address_space *mapping, -loff_t pos,unsigned len,unsigned flags, -struct page **pagep,void **fsdata) -{ -struct gfs2_inode *ip =GFS2_I (mapping->host); -struct gfs2_sbd *sdp =GFS2_SB (mapping->host); -struct gfs2_inode *m_ip =GFS2_I (sdp->sd_statfs_inode); -unsigned int data_blocks =0 , ind_blocks =0 , rblocks; -unsigned requested =0 ; -int alloc_required; -int error =0 ; -pgoff_t index = pos >>PAGE_SHIFT ; -unsigned from = pos & (PAGE_SIZE -1 ); -struct page *page; - -gfs2_holder_init (ip->i_gl,LM_ST_EXCLUSIVE ,0 , &ip->i_gh); - error =gfs2_glock_nq (&ip->i_gh); -if (unlikely (error)) - goto out_uninit; -if (&ip->i_inode == sdp->sd_rindex) { - error =gfs2_glock_nq_init (m_ip->i_gl,LM_ST_EXCLUSIVE , -GL_NOCACHE , &m_ip->i_gh); -if (unlikely (error)) { -gfs2_glock_dq (&ip->i_gh); - goto out_uninit; - } - } - - alloc_required =gfs2_write_alloc_required (ip, pos, len); - -if (alloc_required ||gfs2_is_jdata (ip)) -gfs2_write_calc_reserv (ip, len, &data_blocks, &ind_blocks); - -if (alloc_required) { -struct gfs2_alloc_parms ap = { .aflags =0 , }; - requested = data_blocks + ind_blocks; - ap.target = requested; - error =gfs2_quota_lock_check (ip, &ap); -if (error) - goto out_unlock; - - error =gfs2_inplace_reserve (ip, &ap); -if (error) - goto out_qunlock; - } - - rblocks =RES_DINODE + ind_blocks; -if (gfs2_is_jdata (ip)) - rblocks += data_blocks ? data_blocks :1 ; -if (ind_blocks || data_blocks) - rblocks +=RES_STATFS +RES_QUOTA ; -if (&ip->i_inode == sdp->sd_rindex) - rblocks +=2 *RES_STATFS ; -if (alloc_required) - rblocks +=gfs2_rg_blocks (ip, requested); - - error =gfs2_trans_begin (sdp, rblocks, -PAGE_SIZE /sdp->sd_sb.sb_bsize); -if (error) - goto out_trans_fail; - - error = -ENOMEM ; - flags |=AOP_FLAG_NOFS ; - page =grab_cache_page_write_begin (mapping, index, flags); - *pagep = page; -if (unlikely (!page)) - goto out_endtrans; - -if (gfs2_is_stuffed (ip)) { - error =0 ; -if (pos + len >gfs2_max_stuffed_size (ip)) { - error =gfs2_unstuff_dinode (ip, page); -if (error ==0 ) - goto prepare_write; - }else if (!PageUptodate (page)) { - error =stuffed_readpage (ip, page); - } - goto out; - } - -prepare_write: - error =__block_write_begin (page, from, len, gfs2_block_map); -out: -if (error ==0 ) -return 0 ; - -unlock_page (page); -put_page (page); - -gfs2_trans_end (sdp); -if (pos + len > ip->i_inode.i_size) -gfs2_trim_blocks (&ip->i_inode); - goto out_trans_fail; - -out_endtrans: -gfs2_trans_end (sdp); -out_trans_fail: -if (alloc_required) { -gfs2_inplace_release (ip); -out_qunlock: -gfs2_quota_unlock (ip); - } -out_unlock: -if (&ip->i_inode == sdp->sd_rindex) { -gfs2_glock_dq (&m_ip->i_gh); -gfs2_holder_uninit (&m_ip->i_gh); - } -gfs2_glock_dq (&ip->i_gh); -out_uninit: -gfs2_holder_uninit (&ip->i_gh); -return error; -} -/** * adjust_fs_space - Adjusts the free space available due to gfs2_grow * @inode: the rindex inode
@@ -845,84 +719,6 @@ int gfs2_stuffed_write_end(struct inode *inode, struct buffer_head *dibh,return copied; } -/** -* gfs2_write_end -* @file: The file to write to -* @mapping: The address space to write to -* @pos: The file position -* @len: The length of the data -* @copied: How much was actually copied by the VFS -* @page: The page that has been written -* @fsdata: The fsdata (unused in GFS2) -* -* The main write_end function for GFS2. We just put our locking around the VFS -* provided functions. -* -* Returns: copied bytes or errno -*/ - -static int gfs2_write_end (struct file *file,struct address_space *mapping, -loff_t pos,unsigned len,unsigned copied, -struct page *page,void *fsdata) -{ -struct inode *inode = page->mapping->host; -struct gfs2_inode *ip =GFS2_I (inode); -struct gfs2_sbd *sdp =GFS2_SB (inode); -struct gfs2_inode *m_ip =GFS2_I (sdp->sd_statfs_inode); -struct buffer_head *dibh; -int ret; -struct gfs2_trans *tr = current->journal_info; -BUG_ON (!tr); - -BUG_ON (gfs2_glock_is_locked_by_me (ip->i_gl) ==NULL ); - - ret =gfs2_meta_inode_buffer (ip, &dibh); -if (unlikely (ret)) - goto out; - -if (gfs2_is_stuffed (ip)) { - ret =gfs2_stuffed_write_end (inode, dibh, pos, copied, page); - page =NULL ; - goto out2; - } - -if (gfs2_is_jdata (ip)) -gfs2_page_add_databufs (ip, page, pos & ~PAGE_MASK , len); -else -gfs2_ordered_add_inode (ip); - - ret =generic_write_end (file, mapping, pos, len, copied, page, fsdata); - page =NULL ; -if (tr->tr_num_buf_new) -__mark_inode_dirty (inode,I_DIRTY_DATASYNC ); -else -gfs2_trans_add_meta (ip->i_gl, dibh); - -out2: -if (inode == sdp->sd_rindex) { -adjust_fs_space (inode); - sdp->sd_rindex_uptodate =0 ; - } - -brelse (dibh); -out: -if (page) { -unlock_page (page); -put_page (page); - } -gfs2_trans_end (sdp); -gfs2_inplace_release (ip); -if (ip->i_qadata && ip->i_qadata->qa_qd_num) -gfs2_quota_unlock (ip); -if (inode == sdp->sd_rindex) { -gfs2_glock_dq (&m_ip->i_gh); -gfs2_holder_uninit (&m_ip->i_gh); - } -gfs2_glock_dq (&ip->i_gh); -gfs2_holder_uninit (&ip->i_gh); -return ret; -} -/** * jdata_set_page_dirty - Page dirtying function * @page: The page to dirty
@@ -1090,8 +886,6 @@ static const struct address_space_operations gfs2_writeback_aops = { .writepages = gfs2_writepages, .readpage = gfs2_readpage, .readpages = gfs2_readpages, - .write_begin = gfs2_write_begin, - .write_end = gfs2_write_end, .bmap = gfs2_bmap, .invalidatepage = gfs2_invalidatepage, .releasepage = gfs2_releasepage,
@@ -1106,8 +900,6 @@ static const struct address_space_operations gfs2_ordered_aops = { .writepages = gfs2_writepages, .readpage = gfs2_readpage, .readpages = gfs2_readpages, - .write_begin = gfs2_write_begin, - .write_end = gfs2_write_end, .set_page_dirty = __set_page_dirty_buffers, .bmap = gfs2_bmap, .invalidatepage = gfs2_invalidatepage,
@@ -1123,8 +915,6 @@ static const struct address_space_operations gfs2_jdata_aops = { .writepages = gfs2_jdata_writepages, .readpage = gfs2_readpage, .readpages = gfs2_readpages, - .write_begin = gfs2_write_begin, - .write_end = gfs2_write_end, .set_page_dirty = jdata_set_page_dirty, .bmap = gfs2_bmap, .invalidatepage = gfs2_invalidatepage,
Signature · 1 line
2.17.0
Andreas Gruenbacher
maintainerPATCH v7 12/12 iomap: Put struct iomap_ops into struct iomap
In reply to Andreas GruenbacherWe need access to the struct iomap_ops in iomap_write_end to call the (optional) page_write_end hook, so instead of passing the operators to iomap_write_end differently depending on the code path, add an ops field to struct iomap.
--- fs/dax.c | 8 ++++-- fs/gfs2/bmap.c | 4 ++- fs/gfs2/file.c | 4 ++- fs/iomap.c | 58 ++++++++++++++----------------------------- include/linux/iomap.h | 2 ++ 5 files changed, 32 insertions(+), 44 deletions(-)
fs/dax.c +6 -2
@@ -1140,7 +1140,9 @@ static int dax_iomap_pte_fault(struct vm_fault *vmf, pfn_t *pfnp,struct inode *inode = mapping->host;unsigned long vaddr = vmf->address;loff_t pos = (loff_t )vmf->pgoff <<PAGE_SHIFT ; -struct iomap iomap = {0 }; +struct iomap iomap = { + .ops = ops + };unsigned flags =IOMAP_FAULT ;int error, major =0 ;bool write = vmf->flags &FAULT_FLAG_WRITE ;
@@ -1359,7 +1361,9 @@ static int dax_iomap_pmd_fault(struct vm_fault *vmf, pfn_t *pfnp,unsigned int iomap_flags = (write ?IOMAP_WRITE :0 ) |IOMAP_FAULT ;struct inode *inode = mapping->host;int result =VM_FAULT_FALLBACK ; -struct iomap iomap = {0 }; +struct iomap iomap = { + .ops = ops + };pgoff_t max_pgoff, pgoff;void *entry;loff_t pos;
fs/gfs2/bmap.c +3 -1
@@ -1192,7 +1192,9 @@ int gfs2_block_map(struct inode *inode, sector_t lblock,loff_t pos = (loff_t )lblock << inode->i_blkbits;loff_t length = bh_map->b_size;struct metapath mp = { .mp_aheight =1 , }; -struct iomap iomap = { }; +struct iomap iomap = { +/* no need to initialize .ops here */ + };int ret;clear_buffer_mapped (bh_map);
fs/gfs2/file.c +3 -1
@@ -883,7 +883,9 @@ static int fallocate_chunk(struct inode *inode, loff_t offset, loff_t len,struct gfs2_inode *ip =GFS2_I (inode);loff_t end = offset + len;struct buffer_head *dibh; -struct iomap iomap = { }; +struct iomap iomap = { +/* no need to initialize .ops here */ + };int error; error =gfs2_meta_inode_buffer (ip, &dibh);
fs/iomap.c +18 -40
163 lines not on this page · raw message
include/linux/iomap.h +2 -0
@@ -6,6 +6,7 @@struct fiemap_extent_info ;struct inode ; +struct iomap_ops ;struct iov_iter ;struct kiocb ;struct page ;
@@ -43,6 +44,7 @@ struct vm_fault;#define IOMAP_NULL_ADDR -1ULL/* addr is not valid */ struct iomap { +const struct iomap_ops *ops;u64 addr;/* disk offset of mapping, bytes */ loff_t offset;/* file offset of mapping, bytes */ u64 length;/* length of mapping, bytes */
Signature · 1 line
2.17.0
Re: [PATCH v7 12/12] iomap: Put struct iomap_ops into struct iomap
Quoted 4 lines · Andreas Gruenbacher
We need access to the struct
iomap_opsiniomap_write_endto call the (optional)page_write_endhook, so instead of passing the operators toiomap_write_enddifferently depending on the code path, add an ops field to struct iomap.
I don't really like this. We already pass the iomap_ops to the function we call from iomap.c, and in fact ->iomap_begin is called through the ops.
But what we could do is to move the page_write_end callback out of iomap_ops and just attached it to the iomap, especially given that it isn't really as generic as the other ops.
Can't say I like the implications of this callback in general, but the use case is real, so..
Re: [PATCH v7 12/12] iomap: Put struct iomap_ops into struct iomap
2018-06-04 14:52 GMT+02:00 Christoph Hellwig <[email protected]>:
Quoted 9 lines · Andreas Gruenbacher
Quoted 4 lines
We need access to the struct
iomap_opsiniomap_write_endto call the (optional)page_write_endhook, so instead of passing the operators toiomap_write_enddifferently depending on the code path, add an ops field to struct iomap.I don't really like this. We already pass the
iomap_opsto the function we call fromiomap.c, and in fact ->iomap_begin is called through the ops.
There's no duplicate ops passing going on if that's what you mean.
Quoted 3 lines
But what we could do is to move the
page_write_endcallback out ofiomap_opsand just attached it to the iomap, especially given that it isn't really as generic as the other ops.
Given that struct iomap is allocated inside iomap_apply(), if page_write_end is moved to struct iomap, how would the filesystem set it?
Quoted 2 lines
Can't say I like the implications of this callback in general, but the use case is real, so..
Yes, it's not very pretty.
Thanks,
Andreas