xfs: use the iomap writeback code v2
Subsystems (3)
This series cleans up the xfs writepage code and then lifts it to fs/iomap/ so that it could be use by other file systems. I've been wanting to [do] this for a while so that I could eventually convert gfs2 over to it, but I never got to it. Now Damien has a new zonefs file system for semi-raw access to zoned block devices that would like to use the iomap code instead of reinventing it, so I finally had to do the work.
Changes since v1:
- rebased to latest iomap-for-next
- fix up a comment to use iomap instead of imap
- update a commit log
PATCH 1/5 xfs: use a struct iomap in xfs_writepage_ctx
In preparation for moving the XFS writeback code to fs/iomap.c, switch it to use struct iomap instead of the XFS-specific struct xfs_bmbt_irec.
--- fs/xfs/libxfs/xfs_bmap.c | 14 +++++-- fs/xfs/libxfs/xfs_bmap.h | 3 +- fs/xfs/xfs_aops.c | 82 +++++++++++++++++++--------------------- fs/xfs/xfs_aops.h | 2 +- 4 files changed, 50 insertions(+), 51 deletions(-)
fs/xfs/libxfs/xfs_bmap.c +10 -4
@@ -34,6 +34,7 @@#include "xfs_ag_resv.h" #include "xfs_refcount.h" #include "xfs_icache.h" +#include "xfs_iomap.h" kmem_zone_t *xfs_bmap_free_item_zone;
@@ -4452,16 +4453,21 @@ intxfs_bmapi_convert_delalloc ( struct xfs_inode *ip, int whichfork, - xfs_fileoff_t offset_fsb, - struct xfs_bmbt_irec *imap, + xfs_off_t offset, + struct iomap *iomap, unsigned int *seq) { struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, whichfork);struct xfs_mount *mp = ip->i_mount; +xfs_fileoff_t offset_fsb =XFS_B_TO_FSBT (mp, offset);struct xfs_bmalloca bma = {NULL }; +u16 flags =0 ;struct xfs_trans *tp;int error; +if (whichfork ==XFS_COW_FORK ) + flags |=IOMAP_F_SHARED ; +/* * Space for the extent and indirect blocks was reserved when the * delalloc extent was created so there's no need to do so here.
@@ -4491,7 +4497,7 @@ xfs_bmapi_convert_delalloc(* the extent. Just return the real extent at this offset. */ if (!isnullstartblock (bma.got.br_startblock)) { - *imap = bma.got; +xfs_bmbt_to_iomap (ip, iomap, &bma.got, flags); *seq =READ_ONCE (ifp->if_seq); goto out_trans_cancel; }
@@ -4524,7 +4530,7 @@ xfs_bmapi_convert_delalloc(XFS_STATS_INC (mp, xs_xstrat_quick);ASSERT (!isnullstartblock (bma.got.br_startblock)); - *imap = bma.got; +xfs_bmbt_to_iomap (ip, iomap, &bma.got, flags); *seq =READ_ONCE (ifp->if_seq);if (whichfork ==XFS_COW_FORK ) {
fs/xfs/libxfs/xfs_bmap.h +1 -2
@@ -220,8 +220,7 @@ int xfs_bmapi_reserve_delalloc(struct xfs_inode *ip, int whichfork, struct xfs_bmbt_irec *got, struct xfs_iext_cursor *cur, int eof);int xfs_bmapi_convert_delalloc (struct xfs_inode *ip,int whichfork, -xfs_fileoff_t offset_fsb,struct xfs_bmbt_irec *imap, -unsigned int *seq); +xfs_off_t offset,struct iomap *iomap,unsigned int *seq); int xfs_bmap_add_extent_unwritten_real(struct xfs_trans *tp, struct xfs_inode *ip, int whichfork, struct xfs_iext_cursor *icur, struct xfs_btree_cur **curp,
fs/xfs/xfs_aops.c +38 -44
209 lines not on this page · raw message
fs/xfs/xfs_aops.h +1 -1
@@ -14,7 +14,7 @@ extern struct bio_set xfs_ioend_bioset;struct xfs_ioend {struct list_head io_list;/* next ioend in chain */ int io_fork;/* inode fork written back */ -xfs_exntst_t io_state;/* extent state */ +u16 io_type;struct inode *io_inode;/* file being written to */ size_t io_size;/* size of the extent */ xfs_off_t io_offset;/* offset in the file */
Signature · 1 line
2.20.1
PATCH 2/5 xfs: turn io_append_trans into an io_private void pointer
In reply to Christoph HellwigIn preparation for moving the ioend structure to common code we need to get rid of the xfs-specific xfs_trans type. Just make it a file system private void pointer instead.
--- fs/xfs/xfs_aops.c | 26 +++++++++++++------------- fs/xfs/xfs_aops.h | 2 +- 2 files changed, 14 insertions(+), 14 deletions(-)
fs/xfs/xfs_aops.c +13 -13
@@ -150,7 +150,7 @@ xfs_setfilesize_trans_alloc(if (error)return error; - ioend->io_append_trans = tp; + ioend->io_private = tp;/* * We may pass freeze protection with a transaction. So tell lockdep
@@ -217,7 +217,7 @@ xfs_setfilesize_ioend( int error) {struct xfs_inode *ip =XFS_I (ioend->io_inode); -struct xfs_trans *tp = ioend->io_append_trans; +struct xfs_trans *tp = ioend->io_private;/* * The transaction may have been allocated in the I/O submission thread,
@@ -282,10 +282,10 @@ xfs_end_ioend(else if (ioend->io_type ==IOMAP_UNWRITTEN ) error =xfs_iomap_write_unwritten (ip, offset, size, false);else -ASSERT (!xfs_ioend_is_append (ioend) || ioend->io_append_trans); +ASSERT (!xfs_ioend_is_append (ioend) || ioend->io_private); done: -if (ioend->io_append_trans) +if (ioend->io_private) error =xfs_setfilesize_ioend (ioend, error);xfs_destroy_ioends (ioend, error);memalloc_nofs_restore (nofs_flag);
@@ -318,13 +318,13 @@ xfs_ioend_can_merge(* as it is guaranteed to be clean. */ static void -xfs_ioend_merge_append_transactions ( +xfs_ioend_merge_private (struct xfs_ioend *ioend,struct xfs_ioend *next) { -if (!ioend->io_append_trans) { - ioend->io_append_trans = next->io_append_trans; - next->io_append_trans =NULL ; +if (!ioend->io_private) { + ioend->io_private = next->io_private; + next->io_private =NULL ; }else {xfs_setfilesize_ioend (next, -ECANCELED ); }
@@ -346,8 +346,8 @@ xfs_ioend_try_merge(break ;list_move_tail (&next->io_list, &ioend->io_list); ioend->io_size += next->io_size; -if (next->io_append_trans) -xfs_ioend_merge_append_transactions (ioend, next); +if (next->io_private) +xfs_ioend_merge_private (ioend, next); } }
@@ -410,7 +410,7 @@ xfs_end_bio( if (ioend->io_fork == XFS_COW_FORK || ioend->io_type == IOMAP_UNWRITTEN || - ioend->io_append_trans != NULL) { + ioend->io_private) { spin_lock_irqsave(&ip->i_ioend_lock, flags); if (list_empty(&ip->i_ioend_list)) WARN_ON_ONCE(!queue_work(mp->m_unwritten_workqueue,
@@ -675,7 +675,7 @@ xfs_submit_ioend( (ioend->io_fork == XFS_COW_FORK || ioend->io_type != IOMAP_UNWRITTEN) && xfs_ioend_is_append(ioend) && - !ioend->io_append_trans) + !ioend->io_private) status =xfs_setfilesize_trans_alloc (ioend);memalloc_nofs_restore (nofs_flag);
@@ -724,7 +724,7 @@ xfs_alloc_ioend( ioend->io_inode = inode; ioend->io_size =0 ; ioend->io_offset = offset; - ioend->io_append_trans =NULL ; + ioend->io_private =NULL ; ioend->io_bio = bio;return ioend; }
fs/xfs/xfs_aops.h +1 -1
@@ -18,7 +18,7 @@ struct xfs_ioend {struct inode *io_inode;/* file being written to */ size_t io_size;/* size of the extent */ xfs_off_t io_offset;/* offset in the file */ -struct xfs_trans *io_append_trans;/* xact. for size update */ +void *io_private;/* file system private data */ struct bio *io_bio;/* bio being built */ struct bio io_inline_bio;/* MUST BE LAST! */ };
Signature · 1 line
2.20.1
PATCH 3/5 xfs: remove the fork fields in the writepage_ctx and ioend
In reply to Christoph HellwigIn preparation for moving the writeback code to iomap.c, replace the XFS-specific COW fork concept with the iomap IOMAP_F_SHARED flag.
--- fs/xfs/xfs_aops.c | 42 ++++++++++++++++++++++-------------------- fs/xfs/xfs_aops.h | 2 +- 2 files changed, 23 insertions(+), 21 deletions(-)
fs/xfs/xfs_aops.c +22 -20
@@ -23,7 +23,6 @@*/ struct xfs_writepage_ctx {struct iomap iomap; -int fork;unsigned int data_seq;unsigned int cow_seq;struct xfs_ioend *ioend;
@@ -269,7 +268,7 @@ xfs_end_ioend(*/ error =blk_status_to_errno (ioend->io_bio->bi_status);if (unlikely (error)) { -if (ioend->io_fork ==XFS_COW_FORK ) +if (ioend->io_flags &IOMAP_F_SHARED )xfs_reflink_cancel_cow_range (ip, offset, size, true); goto done; }
@@ -277,7 +276,7 @@ xfs_end_ioend(/* * Success: commit the COW or unwritten blocks if needed. */ -if (ioend->io_fork ==XFS_COW_FORK ) +if (ioend->io_flags &IOMAP_F_SHARED ) error =xfs_reflink_end_cow (ip, offset, size);else if (ioend->io_type ==IOMAP_UNWRITTEN ) error =xfs_iomap_write_unwritten (ip, offset, size, false);
@@ -301,7 +300,8 @@ xfs_ioend_can_merge( {if (ioend->io_bio->bi_status != next->io_bio->bi_status)return false; -if ((ioend->io_fork ==XFS_COW_FORK ) ^ (next->io_fork ==XFS_COW_FORK )) +if ((ioend->io_flags &IOMAP_F_SHARED ) ^ + (next->io_flags &IOMAP_F_SHARED ))return false;if ((ioend->io_type ==IOMAP_UNWRITTEN ) ^ (next->io_type ==IOMAP_UNWRITTEN ))
@@ -408,7 +408,7 @@ xfs_end_bio(struct xfs_mount *mp = ip->i_mount;unsigned long flags; -if (ioend->io_fork ==XFS_COW_FORK || +if ((ioend->io_flags &IOMAP_F_SHARED ) || ioend->io_type ==IOMAP_UNWRITTEN || ioend->io_private) {spin_lock_irqsave (&ip->i_ioend_lock, flags);
@@ -439,7 +439,7 @@ xfs_imap_valid(* covers the offset. Be careful to check this first because the caller * can revalidate a COW mapping without updating the data seqno. */ -if (wpc->fork ==XFS_COW_FORK ) +if (wpc->iomap.flags &IOMAP_F_SHARED )return true;/*
@@ -469,6 +469,7 @@ static intxfs_convert_blocks ( struct xfs_writepage_ctx *wpc, struct xfs_inode *ip, + int whichfork, loff_t offset) { int error;
@@ -480,8 +481,8 @@ xfs_convert_blocks(* delalloc extent if free space is sufficiently fragmented. */ do { - error = xfs_bmapi_convert_delalloc(ip, wpc->fork, offset, - &wpc->iomap, wpc->fork == XFS_COW_FORK ? + error = xfs_bmapi_convert_delalloc(ip, whichfork, offset, + &wpc->iomap, whichfork == XFS_COW_FORK ? &wpc->cow_seq : &wpc->data_seq); if (error) return error;
@@ -502,6 +503,7 @@ xfs_map_blocks(xfs_fileoff_t offset_fsb =XFS_B_TO_FSBT (mp, offset);xfs_fileoff_t end_fsb =XFS_B_TO_FSB (mp, offset + count);xfs_fileoff_t cow_fsb =NULLFILEOFF ; +int whichfork =XFS_DATA_FORK ;struct xfs_bmbt_irec imap;struct xfs_iext_cursor icur;int retries =0 ;
@@ -550,7 +552,7 @@ xfs_map_blocks( wpc->cow_seq =READ_ONCE (ip->i_cowfp->if_seq);xfs_iunlock (ip,XFS_ILOCK_SHARED ); - wpc->fork =XFS_COW_FORK ; + whichfork =XFS_COW_FORK ; goto allocate_blocks; }
@@ -573,8 +575,6 @@ xfs_map_blocks( wpc->data_seq =READ_ONCE (ip->i_df.if_seq);xfs_iunlock (ip,XFS_ILOCK_SHARED ); - wpc->fork =XFS_DATA_FORK ; -/* landed in a hole or beyond EOF? */ if (imap.br_startoff > offset_fsb) { imap.br_blockcount = imap.br_startoff - offset_fsb;
@@ -599,10 +599,10 @@ xfs_map_blocks( goto allocate_blocks;xfs_bmbt_to_iomap (ip, &wpc->iomap, &imap,0 ); -trace_xfs_map_blocks_found (ip, offset, count, wpc->fork, &imap); +trace_xfs_map_blocks_found (ip, offset, count, whichfork, &imap);return 0 ; allocate_blocks: - error =xfs_convert_blocks (wpc, ip, offset); + error =xfs_convert_blocks (wpc, ip, whichfork, offset);if (error) {/* * If we failed to find the extent in the COW fork we might have
@@ -611,7 +611,8 @@ xfs_map_blocks(* the former case, but prevent additional retries to avoid * looping forever for the latter case. */ -if (error == -EAGAIN && wpc->fork ==XFS_COW_FORK && !retries++) +if (error == -EAGAIN && (wpc->iomap.flags &IOMAP_F_SHARED ) && + !retries++) goto retry;ASSERT (error != -EAGAIN );return error;
@@ -622,7 +623,7 @@ xfs_map_blocks(* original delalloc one. Trim the return extent to the next COW * boundary again to force a re-lookup. */ -if (wpc->fork !=XFS_COW_FORK && cow_fsb !=NULLFILEOFF ) { +if (!(wpc->iomap.flags &IOMAP_F_SHARED ) && cow_fsb !=NULLFILEOFF ) {loff_t cow_offset =XFS_FSB_TO_B (mp, cow_fsb);if (cow_offset < wpc->iomap.offset + wpc->iomap.length)
@@ -631,7 +632,7 @@ xfs_map_blocks(ASSERT (wpc->iomap.offset <= offset);ASSERT (wpc->iomap.offset + wpc->iomap.length > offset); -trace_xfs_map_blocks_alloc (ip, offset, count, wpc->fork, &imap); +trace_xfs_map_blocks_alloc (ip, offset, count, whichfork, &imap);return 0 ; }
@@ -665,14 +666,14 @@ xfs_submit_ioend( nofs_flag =memalloc_nofs_save ();/* Convert CoW extents to regular */ -if (!status && ioend->io_fork ==XFS_COW_FORK ) { +if (!status && (ioend->io_flags &IOMAP_F_SHARED )) { status =xfs_reflink_convert_cow (XFS_I (ioend->io_inode), ioend->io_offset, ioend->io_size); }/* Reserve log space if we might write beyond the on-disk inode size. */ if (!status && - (ioend->io_fork ==XFS_COW_FORK || + ((ioend->io_flags &IOMAP_F_SHARED ) || ioend->io_type !=IOMAP_UNWRITTEN ) &&xfs_ioend_is_append (ioend) && !ioend->io_private)
@@ -719,8 +720,8 @@ xfs_alloc_ioend( ioend = container_of(bio, struct xfs_ioend, io_inline_bio);INIT_LIST_HEAD (&ioend->io_list); - ioend->io_fork = wpc->fork; ioend->io_type = wpc->iomap.type; + ioend->io_flags = wpc->iomap.flags; ioend->io_inode = inode; ioend->io_size =0 ; ioend->io_offset = offset;
@@ -774,7 +775,8 @@ xfs_add_to_ioend(bool merged, same_page = false;if (!wpc->ioend || - wpc->fork != wpc->ioend->io_fork || + (wpc->iomap.flags &IOMAP_F_SHARED ) != + (wpc->ioend->io_flags &IOMAP_F_SHARED ) || wpc->iomap.type != wpc->ioend->io_type || sector !=bio_end_sector (wpc->ioend->io_bio) || offset != wpc->ioend->io_offset + wpc->ioend->io_size) {
fs/xfs/xfs_aops.h +1 -1
@@ -13,8 +13,8 @@ extern struct bio_set xfs_ioend_bioset;*/ struct xfs_ioend {struct list_head io_list;/* next ioend in chain */ -int io_fork;/* inode fork written back */ u16 io_type; +u16 io_flags;/* IOMAP_F_* */ struct inode *io_inode;/* file being written to */ size_t io_size;/* size of the extent */ xfs_off_t io_offset;/* offset in the file */
Signature · 1 line
2.20.1
PATCH 4/5 xfs: use the iomap write page code
In reply to Christoph HellwigUse the new iomap writeback code that was copied from XFS to perform writeback.
--- fs/xfs/xfs_aops.c | 649 +++++---------------------------------------- fs/xfs/xfs_aops.h | 17 -- fs/xfs/xfs_super.c | 11 +- fs/xfs/xfs_trace.h | 65 ----- 4 files changed, 60 insertions(+), 682 deletions(-)
fs/xfs/xfs_aops.c +59 -590
@@ -18,16 +18,18 @@#include "xfs_bmap_util.h" #include "xfs_reflink.h" -/* -* structure owned by writepages passed to individual writepage calls -*/ struct xfs_writepage_ctx { -struct iomap iomap; +struct iomap_writepage_ctx ctx;unsigned int data_seq;unsigned int cow_seq; -struct xfs_ioend *ioend; }; +static inline struct xfs_writepage_ctx * +XFS_WPC (struct iomap_writepage_ctx *ctx) +{ + return container_of(ctx, struct xfs_writepage_ctx, ctx); +} +struct block_device *xfs_find_bdev_for_inode (struct inode *inode)
@@ -54,84 +56,10 @@ xfs_find_daxdev_for_inode(return mp->m_ddev_targp->bt_daxdev; } -static void -xfs_finish_page_writeback ( -struct inode *inode, -struct bio_vec *bvec, -int error) -{ -struct iomap_page *iop =to_iomap_page (bvec->bv_page); - -if (error) { -SetPageError (bvec->bv_page); -mapping_set_error (inode->i_mapping, -EIO ); - } - -ASSERT (iop ||i_blocksize (inode) ==PAGE_SIZE ); -ASSERT (!iop ||atomic_read (&iop->write_count) >0 ); - -if (!iop ||atomic_dec_and_test (&iop->write_count)) -end_page_writeback (bvec->bv_page); -} - -/* -* We're now finished for good with this ioend structure. Update the page -* state, release holds on bios, and finally free up memory. Do not use the -* ioend after this. -*/ -STATIC void -xfs_destroy_ioend ( -struct xfs_ioend *ioend, -int error) -{ -struct inode *inode = ioend->io_inode; -struct bio *bio = &ioend->io_inline_bio; -struct bio *last = ioend->io_bio, *next; -u64 start = bio->bi_iter.bi_sector; -bool quiet =bio_flagged (bio,BIO_QUIET ); - -for (bio = &ioend->io_inline_bio; bio; bio = next) { -struct bio_vec *bvec; -struct bvec_iter_all iter_all; - -/* -* For the last bio, bi_private points to the ioend, so we -* need to explicitly end the iteration here. -*/ -if (bio == last) - next =NULL ; -else - next = bio->bi_private; - -/* walk each page on bio, ending page IO on them */ -bio_for_each_segment_all (bvec, bio, iter_all) -xfs_finish_page_writeback (inode, bvec, error); -bio_put (bio); - } - -if (unlikely (error && !quiet)) { -xfs_err_ratelimited (XFS_I (inode)->i_mount, -"writeback error on sector %llu" , start); - } -} - -static void -xfs_destroy_ioends ( -struct xfs_ioend *ioend, -int error) -{ -struct list_head tmp; - -list_replace_init (&ioend->io_list, &tmp); -xfs_destroy_ioend (ioend, error); - while ((ioend = list_pop_entry(&tmp, struct xfs_ioend, io_list))) -xfs_destroy_ioend (ioend, error); -} -/* * Fast and loose check if this write could update the on-disk inode size. */ -static inline bool xfs_ioend_is_append (struct xfs_ioend *ioend) +static inline bool xfs_ioend_is_append (struct iomap_ioend *ioend) {return ioend->io_offset + ioend->io_size >XFS_I (ioend->io_inode)->i_d.di_size;
@@ -139,7 +67,7 @@ static inline bool xfs_ioend_is_append(struct xfs_ioend *ioend) STATIC intxfs_setfilesize_trans_alloc ( -struct xfs_ioend *ioend) +struct iomap_ioend *ioend) {struct xfs_mount *mp =XFS_I (ioend->io_inode)->i_mount;struct xfs_trans *tp;
@@ -212,7 +140,7 @@ xfs_setfilesize( STATIC intxfs_setfilesize_ioend ( -struct xfs_ioend *ioend, +struct iomap_ioend *ioend,int error) {struct xfs_inode *ip =XFS_I (ioend->io_inode);
@@ -240,7 +168,7 @@ xfs_setfilesize_ioend(*/ STATIC voidxfs_end_ioend ( -struct xfs_ioend *ioend) +struct iomap_ioend *ioend) {struct xfs_inode *ip =XFS_I (ioend->io_inode);xfs_off_t offset = ioend->io_offset;
@@ -286,31 +214,10 @@ xfs_end_ioend( done:if (ioend->io_private) error =xfs_setfilesize_ioend (ioend, error); -xfs_destroy_ioends (ioend, error); +iomap_finish_ioends (ioend, error);memalloc_nofs_restore (nofs_flag); } -/* -* We can merge two adjacent ioends if they have the same set of work to do. -*/ -static bool -xfs_ioend_can_merge ( -struct xfs_ioend *ioend, -struct xfs_ioend *next) -{ -if (ioend->io_bio->bi_status != next->io_bio->bi_status) -return false; -if ((ioend->io_flags &IOMAP_F_SHARED ) ^ - (next->io_flags &IOMAP_F_SHARED )) -return false; -if ((ioend->io_type ==IOMAP_UNWRITTEN ) ^ - (next->io_type ==IOMAP_UNWRITTEN )) -return false; -if (ioend->io_offset + ioend->io_size != next->io_offset) -return false; -return true; -} -/* * If the to be merged ioend has a preallocated transaction for file * size updates we need to ensure the ioend it is merged into also
@@ -319,8 +226,8 @@ xfs_ioend_can_merge(*/ static void xfs_ioend_merge_private ( -struct xfs_ioend *ioend, -struct xfs_ioend *next) +struct iomap_ioend *ioend, +struct iomap_ioend *next) {if (!ioend->io_private) { ioend->io_private = next->io_private;
@@ -330,53 +237,6 @@ xfs_ioend_merge_private( } } -/* Try to merge adjacent completions. */ -STATIC void -xfs_ioend_try_merge ( -struct xfs_ioend *ioend, -struct list_head *more_ioends) -{ -struct xfs_ioend *next; - -INIT_LIST_HEAD (&ioend->io_list); - - while ((next = list_first_entry_or_null(more_ioends, struct xfs_ioend, - io_list))) { -if (!xfs_ioend_can_merge (ioend, next)) -break ; -list_move_tail (&next->io_list, &ioend->io_list); - ioend->io_size += next->io_size; -if (next->io_private) -xfs_ioend_merge_private (ioend, next); - } -} - -/* list_sort compare function for ioends */ -static int -xfs_ioend_compare ( -void *priv, -struct list_head *a, -struct list_head *b) -{ -struct xfs_ioend *ia; -struct xfs_ioend *ib; - - ia = container_of(a, struct xfs_ioend, io_list); - ib = container_of(b, struct xfs_ioend, io_list); -if (ia->io_offset < ib->io_offset) -return -1 ; -else if (ia->io_offset > ib->io_offset) -return 1 ; -return 0 ; -} - -static void -xfs_sort_ioends ( -struct list_head *ioend_list) -{ -list_sort (NULL , ioend_list, xfs_ioend_compare); -} -/* Finish all pending io completions. */ void xfs_end_io(
@@ -384,7 +244,7 @@ xfs_end_io( {struct xfs_inode *ip = container_of(work, struct xfs_inode, i_ioend_work); -struct xfs_ioend *ioend; +struct iomap_ioend *ioend;struct list_head tmp;unsigned long flags;
@@ -392,9 +252,9 @@ xfs_end_io(list_replace_init (&ip->i_ioend_list, &tmp);spin_unlock_irqrestore (&ip->i_ioend_lock, flags); -xfs_sort_ioends (&tmp); - while ((ioend = list_pop_entry(&tmp, struct xfs_ioend, io_list))) { -xfs_ioend_try_merge (ioend, &tmp); +iomap_sort_ioends (&tmp); + while ((ioend = list_pop_entry(&tmp, struct iomap_ioend, io_list))) { +iomap_ioend_try_merge (ioend, &tmp, xfs_ioend_merge_private);xfs_end_ioend (ioend); } }
@@ -403,22 +263,16 @@ STATIC voidxfs_end_bio ( struct bio *bio) { -struct xfs_ioend *ioend = bio->bi_private; +struct iomap_ioend *ioend = bio->bi_private;struct xfs_inode *ip =XFS_I (ioend->io_inode); -struct xfs_mount *mp = ip->i_mount;unsigned long flags; -if ((ioend->io_flags &IOMAP_F_SHARED ) || - ioend->io_type ==IOMAP_UNWRITTEN || - ioend->io_private) { -spin_lock_irqsave (&ip->i_ioend_lock, flags); -if (list_empty (&ip->i_ioend_list)) -WARN_ON_ONCE (!queue_work (mp->m_unwritten_workqueue, - &ip->i_ioend_work)); -list_add_tail (&ioend->io_list, &ip->i_ioend_list); -spin_unlock_irqrestore (&ip->i_ioend_lock, flags); - }else -xfs_destroy_ioend (ioend,blk_status_to_errno (bio->bi_status)); +spin_lock_irqsave (&ip->i_ioend_lock, flags); +if (list_empty (&ip->i_ioend_list)) +WARN_ON_ONCE (!queue_work (ip->i_mount->m_unwritten_workqueue, + &ip->i_ioend_work)); +list_add_tail (&ioend->io_list, &ip->i_ioend_list); +spin_unlock_irqrestore (&ip->i_ioend_lock, flags); }/*
@@ -427,7 +281,7 @@ xfs_end_bio(*/ static bool xfs_imap_valid ( -struct xfs_writepage_ctx *wpc, +struct iomap_writepage_ctx *wpc,struct xfs_inode *ip,loff_t offset) {
@@ -449,10 +303,10 @@ xfs_imap_valid(* checked (and found nothing at this offset) could have added * overlapping blocks. */ -if (wpc->data_seq !=READ_ONCE (ip->i_df.if_seq)) +if (XFS_WPC (wpc)->data_seq !=READ_ONCE (ip->i_df.if_seq))return false;if (xfs_inode_has_cow_data (ip) && - wpc->cow_seq !=READ_ONCE (ip->i_cowfp->if_seq)) +XFS_WPC (wpc)->cow_seq !=READ_ONCE (ip->i_cowfp->if_seq))return false;return true; }
@@ -467,12 +321,18 @@ xfs_imap_valid(*/ static int xfs_convert_blocks ( -struct xfs_writepage_ctx *wpc, +struct iomap_writepage_ctx *wpc,struct xfs_inode *ip,int whichfork,loff_t offset) {int error; +unsigned *seq; + +if (whichfork ==XFS_COW_FORK ) + seq = &XFS_WPC (wpc)->cow_seq; +else + seq = &XFS_WPC (wpc)->data_seq;/* * Attempt to allocate whatever delalloc extent currently backs offset
@@ -482,8 +342,7 @@ xfs_convert_blocks(*/ do { error =xfs_bmapi_convert_delalloc (ip, whichfork, offset, - &wpc->iomap, whichfork ==XFS_COW_FORK ? - &wpc->cow_seq : &wpc->data_seq); + &wpc->iomap, seq);if (error)return error; }while (wpc->iomap.offset + wpc->iomap.length <= offset);
@@ -491,9 +350,9 @@ xfs_convert_blocks(return 0 ; } -STATIC int +static int xfs_map_blocks ( -struct xfs_writepage_ctx *wpc, +struct iomap_writepage_ctx *wpc,struct inode *inode,loff_t offset) {
@@ -549,7 +408,7 @@ xfs_map_blocks( xfs_iext_lookup_extent(ip, ip->i_cowfp, offset_fsb, &icur, &imap)) cow_fsb = imap.br_startoff;if (cow_fsb !=NULLFILEOFF && cow_fsb <= offset_fsb) { - wpc->cow_seq =READ_ONCE (ip->i_cowfp->if_seq); +XFS_WPC (wpc)->cow_seq =READ_ONCE (ip->i_cowfp->if_seq);xfs_iunlock (ip,XFS_ILOCK_SHARED ); whichfork =XFS_COW_FORK ;
@@ -572,7 +431,7 @@ xfs_map_blocks(*/ if (!xfs_iext_lookup_extent (ip, &ip->i_df, offset_fsb, &icur, &imap)) imap.br_startoff = end_fsb;/* fake a hole past EOF */ - wpc->data_seq =READ_ONCE (ip->i_df.if_seq); +XFS_WPC (wpc)->data_seq =READ_ONCE (ip->i_df.if_seq);xfs_iunlock (ip,XFS_ILOCK_SHARED );/* landed in a hole or beyond EOF? */
@@ -636,24 +495,9 @@ xfs_map_blocks(return 0 ; } -/* -* Submit the bio for an ioend. We are passed an ioend with a bio attached to -* it, and we submit that bio. The ioend may be used for multiple bio -* submissions, so we only want to allocate an append transaction for the ioend -* once. In the case of multiple bio submission, each bio will take an IO -* reference to the ioend to ensure that the ioend completion is only done once -* all bios have been submitted and the ioend is really done. -* -* If @status is non-zero, it means that we have a situation where some part of -* the submission process has failed after we have marked paged for writeback -* and unlocked them. In this situation, we need to fail the bio and ioend -* rather than submit it to IO. This typically only happens on a filesystem -* shutdown. -*/ -STATIC int +static int xfs_submit_ioend ( -struct writeback_control *wbc, -struct xfs_ioend *ioend, +struct iomap_ioend *ioend,int status) {unsigned int nofs_flag;
@@ -680,135 +524,11 @@ xfs_submit_ioend( status =xfs_setfilesize_trans_alloc (ioend);memalloc_nofs_restore (nofs_flag); - - ioend->io_bio->bi_private = ioend; - ioend->io_bio->bi_end_io = xfs_end_bio; - -/* -* If we are failing the IO now, just mark the ioend with an -* error and finish it. This will run IO completion immediately -* as there is only one reference to the ioend at this point in -* time. -*/ -if (status) { - ioend->io_bio->bi_status =errno_to_blk_status (status); -bio_endio (ioend->io_bio); -return status; - } - -submit_bio (ioend->io_bio); -return 0 ; -} - -static struct xfs_ioend * -xfs_alloc_ioend ( -struct inode *inode, -struct xfs_writepage_ctx *wpc, -xfs_off_t offset, -sector_t sector, -struct writeback_control *wbc) -{ -struct xfs_ioend *ioend; -struct bio *bio; - - bio =bio_alloc_bioset (GFP_NOFS ,BIO_MAX_PAGES , &xfs_ioend_bioset); -bio_set_dev (bio, wpc->iomap.bdev); - bio->bi_iter.bi_sector = sector; - bio->bi_opf =REQ_OP_WRITE |wbc_to_write_flags (wbc); - bio->bi_write_hint = inode->i_write_hint; -wbc_init_bio (wbc, bio); - - ioend = container_of(bio, struct xfs_ioend, io_inline_bio); -INIT_LIST_HEAD (&ioend->io_list); - ioend->io_type = wpc->iomap.type; - ioend->io_flags = wpc->iomap.flags; - ioend->io_inode = inode; - ioend->io_size =0 ; - ioend->io_offset = offset; - ioend->io_private =NULL ; - ioend->io_bio = bio; -return ioend; -} - -/* -* Allocate a new bio, and chain the old bio to the new one. -* -* Note that we have to do perform the chaining in this unintuitive order -* so that the bi_private linkage is set up in the right direction for the -* traversal in xfs_destroy_ioend(). -*/ -static struct bio * -xfs_chain_bio ( -struct bio *prev) -{ -struct bio *new; - - new =bio_alloc (GFP_NOFS ,BIO_MAX_PAGES ); -bio_copy_dev (new, prev);/* also copies over blkcg information */ - new->bi_iter.bi_sector =bio_end_sector (prev); - new->bi_opf = prev->bi_opf; - new->bi_write_hint = prev->bi_write_hint; - -bio_chain (prev, new); -bio_get (prev);/* for xfs_destroy_ioend */ -submit_bio (prev); -return new; -} - -/* -* Test to see if we have an existing ioend structure that we could append to -* first, otherwise finish off the current ioend and start another. -*/ -STATIC void -xfs_add_to_ioend ( -struct inode *inode, -xfs_off_t offset, -struct page *page, -struct iomap_page *iop, -struct xfs_writepage_ctx *wpc, -struct writeback_control *wbc, -struct list_head *iolist) -{ -sector_t sector =iomap_sector (&wpc->iomap, offset); -unsigned len =i_blocksize (inode); -unsigned poff = offset & (PAGE_SIZE -1 ); -bool merged, same_page = false; - -if (!wpc->ioend || - (wpc->iomap.flags &IOMAP_F_SHARED ) != - (wpc->ioend->io_flags &IOMAP_F_SHARED ) || - wpc->iomap.type != wpc->ioend->io_type || - sector !=bio_end_sector (wpc->ioend->io_bio) || - offset != wpc->ioend->io_offset + wpc->ioend->io_size) { -if (wpc->ioend) -list_add (&wpc->ioend->io_list, iolist); - wpc->ioend =xfs_alloc_ioend (inode, wpc, offset, sector, wbc); - } - - merged =__bio_try_merge_page (wpc->ioend->io_bio, page, len, poff, - &same_page); - -if (iop && !same_page) -atomic_inc (&iop->write_count); - -if (!merged) { -if (bio_full (wpc->ioend->io_bio, len)) - wpc->ioend->io_bio =xfs_chain_bio (wpc->ioend->io_bio); -bio_add_page (wpc->ioend->io_bio, page, len, poff); - } - - wpc->ioend->io_size += len; -wbc_account_cgroup_owner (wbc, page, len); -} - -STATIC void -xfs_vm_invalidatepage ( -struct page *page, -unsigned int offset, -unsigned int length) -{ -trace_xfs_invalidatepage (page->mapping->host, page, offset, length); -iomap_invalidatepage (page, offset, length); +if ((ioend->io_flags &IOMAP_F_SHARED ) || + ioend->io_type ==IOMAP_UNWRITTEN || + ioend->io_private) + ioend->io_bio->bi_end_io = xfs_end_bio; +return status; }/*
@@ -822,8 +542,8 @@ xfs_vm_invalidatepage(* transaction as there is no space left for block reservation (typically why we * see a ENOSPC in writeback). */ -STATIC void -xfs_aops_discard_page ( +static void +xfs_discard_page (struct page *page) {struct inode *inode = page->mapping->host;
@@ -845,246 +565,14 @@ xfs_aops_discard_page(if (error && !XFS_FORCED_SHUTDOWN (mp))xfs_alert (mp,"page discard unable to remove delalloc mapping." ); out_invalidate: -xfs_vm_invalidatepage (page,0 ,PAGE_SIZE ); -} - -/* -* We implement an immediate ioend submission policy here to avoid needing to -* chain multiple ioends and hence nest mempool allocations which can violate -* forward progress guarantees we need to provide. The current ioend we are -* adding blocks to is cached on the writepage context, and if the new block -* does not append to the cached ioend it will create a new ioend and cache that -* instead. -* -* If a new ioend is created and cached, the old ioend is returned and queued -* locally for submission once the entire page is processed or an error has been -* detected. While ioends are submitted immediately after they are completed, -* batching optimisations are provided by higher level block plugging. -* -* At the end of a writeback pass, there will be a cached ioend remaining on the -* writepage context that the caller will need to submit. -*/ -static int -xfs_writepage_map ( -struct xfs_writepage_ctx *wpc, -struct writeback_control *wbc, -struct inode *inode, -struct page *page, -uint64_t end_offset) -{ -LIST_HEAD (submit_list); -struct iomap_page *iop =to_iomap_page (page); -unsigned len =i_blocksize (inode); -struct xfs_ioend *ioend, *next; -uint64_t file_offset;/* file offset of page */ -int error =0 , count =0 , i; - -ASSERT (iop ||i_blocksize (inode) ==PAGE_SIZE ); -ASSERT (!iop ||atomic_read (&iop->write_count) ==0 ); - -/* -* Walk through the page to find areas to write back. If we run off the -* end of the current map or find the current map invalid, grab a new -* one. -*/ -for (i =0 , file_offset =page_offset (page); - i < (PAGE_SIZE >> inode->i_blkbits) && file_offset < end_offset; - i++, file_offset += len) { -if (iop && !test_bit (i, iop->uptodate)) -continue ; - - error =xfs_map_blocks (wpc, inode, file_offset); -if (error) -break ; -if (wpc->iomap.type ==IOMAP_HOLE ) -continue ; -xfs_add_to_ioend (inode, file_offset, page, iop, wpc, wbc, - &submit_list); - count++; - } - -ASSERT (wpc->ioend ||list_empty (&submit_list)); -ASSERT (PageLocked (page)); -ASSERT (!PageWriteback (page)); - -/* -* On error, we have to fail the ioend here because we may have set -* pages under writeback, we have to make sure we run IO completion to -* mark the error state of the IO appropriately, so we can't cancel the -* ioend directly here. That means we have to mark this page as under -* writeback if we included any blocks from it in the ioend chain so -* that completion treats it correctly. -* -* If we didn't include the page in the ioend, the on error we can -* simply discard and unlock it as there are no other users of the page -* now. The caller will still need to trigger submission of outstanding -* ioends on the writepage context so they are treated correctly on -* error. -*/ -if (unlikely (error)) { -if (!count) { -xfs_aops_discard_page (page); -ClearPageUptodate (page); -unlock_page (page); - goto done; - } - -/* -* If the page was not fully cleaned, we need to ensure that the -* higher layers come back to it correctly. That means we need -* to keep the page dirty, and for WB_SYNC_ALL writeback we need -* to ensure the PAGECACHE_TAG_TOWRITE index mark is not removed -* so another attempt to write this page in this writeback sweep -* will be made. -*/ -set_page_writeback_keepwrite (page); - }else { -clear_page_dirty_for_io (page); -set_page_writeback (page); - } - -unlock_page (page); - -/* -* Preserve the original error if there was one, otherwise catch -* submission errors here and propagate into subsequent ioend -* submissions. -*/ -list_for_each_entry_safe (ioend, next, &submit_list, io_list) { -int error2; - -list_del_init (&ioend->io_list); - error2 =xfs_submit_ioend (wbc, ioend, error); -if (error2 && !error) - error = error2; - } - -/* -* We can end up here with no error and nothing to write only if we race -* with a partial page truncate on a sub-page block sized filesystem. -*/ -if (!count) -end_page_writeback (page); -done: -mapping_set_error (page->mapping, error); -return error; +iomap_invalidatepage (page,0 ,PAGE_SIZE ); } -/* -* Write out a dirty page. -* -* For delalloc space on the page we need to allocate space and flush it. -* For unwritten space on the page we need to start the conversion to -* regular allocated space. -*/ -STATIC int -xfs_do_writepage ( -struct page *page, -struct writeback_control *wbc, -void *data) -{ -struct xfs_writepage_ctx *wpc = data; -struct inode *inode = page->mapping->host; -loff_t offset; -uint64_t end_offset; -pgoff_t end_index; - -trace_xfs_writepage (inode, page,0 ,0 ); - -/* -* Refuse to write the page out if we are called from reclaim context. -* -* This avoids stack overflows when called from deeply used stacks in -* random callers for direct reclaim or memcg reclaim. We explicitly -* allow reclaim from kswapd as the stack usage there is relatively low. -* -* This should never happen except in the case of a VM regression so -* warn about it. -*/ -if (WARN_ON_ONCE ((current->flags & (PF_MEMALLOC |PF_KSWAPD )) == -PF_MEMALLOC )) - goto redirty; - -/* -* Given that we do not allow direct reclaim to call us, we should -* never be called while in a filesystem transaction. -*/ -if (WARN_ON_ONCE (current->flags &PF_MEMALLOC_NOFS )) - goto redirty; - -/* -* Is this page beyond the end of the file? -* -* The page index is less than the end_index, adjust the end_offset -* to the highest offset that this page should represent. -* ----------------------------------------------------- -* | file mapping | <EOF> | -* ----------------------------------------------------- -* | Page ... | Page N-2 | Page N-1 | Page N | | -* ^--------------------------------^----------|-------- -* | desired writeback range | see else | -* ---------------------------------^------------------| -*/ - offset =i_size_read (inode); - end_index = offset >>PAGE_SHIFT ; -if (page->index < end_index) - end_offset = (xfs_off_t)(page->index +1 ) <<PAGE_SHIFT ; -else { -/* -* Check whether the page to write out is beyond or straddles -* i_size or not. -* ------------------------------------------------------- -* | file mapping | <EOF> | -* ------------------------------------------------------- -* | Page ... | Page N-2 | Page N-1 | Page N | Beyond | -* ^--------------------------------^-----------|--------- -* | | Straddles | -* ---------------------------------^-----------|--------| -*/ -unsigned offset_into_page = offset & (PAGE_SIZE -1 ); - -/* -* Skip the page if it is fully outside i_size, e.g. due to a -* truncate operation that is in progress. We must redirty the -* page so that reclaim stops reclaiming it. Otherwise -* xfs_vm_releasepage() is called on it and gets confused. -* -* Note that the end_index is unsigned long, it would overflow -* if the given offset is greater than 16TB on 32-bit system -* and if we do check the page is fully outside i_size or not -* via "if (page->index >= end_index + 1)" as "end_index + 1" -* will be evaluated to 0. Hence this page will be redirtied -* and be written out repeatedly which would result in an -* infinite loop, the user program that perform this operation -* will hang. Instead, we can verify this situation by checking -* if the page to write is totally beyond the i_size or if it's -* offset is just equal to the EOF. -*/ -if (page->index > end_index || - (page->index == end_index && offset_into_page ==0 )) - goto redirty; - -/* -* The page straddles i_size. It must be zeroed out on each -* and every writepage invocation because it may be mmapped. -* "A file is mapped in multiples of the page size. For a file -* that is not a multiple of the page size, the remaining -* memory is zeroed when mapped, and writes to that region are -* not written out to the file." -*/ -zero_user_segment (page, offset_into_page,PAGE_SIZE ); - -/* Adjust the end_offset to the end of file */ - end_offset = offset; - } - -return xfs_writepage_map (wpc, wbc, inode, page, end_offset); - -redirty: -redirty_page_for_writepage (wbc, page); -unlock_page (page); -return 0 ; -} +static const struct iomap_writeback_ops xfs_writeback_ops = { + .map_blocks = xfs_map_blocks, + .submit_ioend = xfs_submit_ioend, + .discard_page = xfs_discard_page, +}; STATIC int xfs_vm_writepage(
@@ -1092,12 +580,8 @@ xfs_vm_writepage( struct writeback_control *wbc) {struct xfs_writepage_ctx wpc = { }; -int ret; - ret =xfs_do_writepage (page, wbc, &wpc); -if (wpc.ioend) - ret =xfs_submit_ioend (wbc, wpc.ioend, ret); -return ret; +return iomap_writepage (page, wbc, &wpc.ctx, &xfs_writeback_ops); }STATIC int
@@ -1106,13 +590,9 @@ xfs_vm_writepages( struct writeback_control *wbc) {struct xfs_writepage_ctx wpc = { }; -int ret;xfs_iflags_clear (XFS_I (mapping->host),XFS_ITRUNCATED ); - ret =write_cache_pages (mapping, wbc, xfs_do_writepage, &wpc); -if (wpc.ioend) - ret =xfs_submit_ioend (wbc, wpc.ioend, ret); -return ret; +return iomap_writepages (mapping, wbc, &wpc.ctx, &xfs_writeback_ops); }STATIC int
@@ -1125,15 +605,6 @@ xfs_dax_writepages( xfs_find_bdev_for_inode(mapping->host), wbc); } -STATIC int -xfs_vm_releasepage ( -struct page *page, -gfp_t gfp_mask) -{ -trace_xfs_releasepage (page->mapping->host, page,0 ,0 ); -return iomap_releasepage (page, gfp_mask); -} - STATIC sector_t xfs_vm_bmap( struct address_space *mapping,
@@ -1162,7 +633,6 @@ xfs_vm_readpage(struct file *unused, struct page *page) { - trace_xfs_vm_readpage(page->mapping->host, 1); return iomap_readpage(page, &xfs_iomap_ops); }
@@ -1173,7 +643,6 @@ xfs_vm_readpages( struct list_head *pages, unsigned nr_pages) { -trace_xfs_vm_readpages (mapping->host, nr_pages);return iomap_readpages (mapping, pages, nr_pages, &xfs_iomap_ops); }
@@ -1193,8 +662,8 @@ const struct address_space_operations xfs_address_space_operations = { .writepage = xfs_vm_writepage, .writepages = xfs_vm_writepages, .set_page_dirty = iomap_set_page_dirty, - .releasepage = xfs_vm_releasepage, - .invalidatepage = xfs_vm_invalidatepage, + .releasepage = iomap_releasepage, + .invalidatepage = iomap_invalidatepage, .bmap = xfs_vm_bmap, .direct_IO = noop_direct_IO, .migratepage = iomap_migrate_page,
fs/xfs/xfs_aops.h +0 -17
@@ -6,23 +6,6 @@#ifndef __XFS_AOPS_H__#define __XFS_AOPS_H__ -extern struct bio_set xfs_ioend_bioset; - -/* -* Structure for buffered I/O completions. -*/ -struct xfs_ioend { -struct list_head io_list;/* next ioend in chain */ -u16 io_type; -u16 io_flags;/* IOMAP_F_* */ -struct inode *io_inode;/* file being written to */ -size_t io_size;/* size of the extent */ -xfs_off_t io_offset;/* offset in the file */ -void *io_private;/* file system private data */ -struct bio *io_bio;/* bio being built */ -struct bio io_inline_bio;/* MUST BE LAST! */ -}; -extern const struct address_space_operations xfs_address_space_operations;extern const struct address_space_operations xfs_dax_aops;
fs/xfs/xfs_super.c +1 -10
@@ -40,7 +40,6 @@#include <linux/parser.h> static const struct super_operations xfs_super_operations; -struct bio_set xfs_ioend_bioset;static struct kset *xfs_kset;/* top-level xfs sysfs dir */ #ifdef DEBUG
@@ -1850,15 +1849,10 @@ MODULE_ALIAS_FS("xfs"); STATIC int __initxfs_init_zones (void ) { -if (bioset_init (&xfs_ioend_bioset,4 * (PAGE_SIZE /SECTOR_SIZE ), - offsetof(struct xfs_ioend , io_inline_bio), -BIOSET_NEED_BVECS )) - goto out; - xfs_log_ticket_zone =kmem_zone_init (sizeof (xlog_ticket_t),"xfs_log_ticket" );if (!xfs_log_ticket_zone) - goto out_free_ioend_bioset; + goto out; xfs_bmap_free_item_zone = kmem_zone_init( sizeof(struct xfs_extent_free_item),
@@ -1993,8 +1987,6 @@ xfs_init_zones(void)kmem_zone_destroy (xfs_bmap_free_item_zone); out_destroy_log_ticket_zone:kmem_zone_destroy (xfs_log_ticket_zone); - out_free_ioend_bioset: -bioset_exit (&xfs_ioend_bioset); out:return -ENOMEM ; }
@@ -2025,7 +2017,6 @@ xfs_destroy_zones(void)kmem_zone_destroy (xfs_btree_cur_zone);kmem_zone_destroy (xfs_bmap_free_item_zone);kmem_zone_destroy (xfs_log_ticket_zone); -bioset_exit (&xfs_ioend_bioset); }STATIC int__init
fs/xfs/xfs_trace.h +0 -65
71 lines not on this page · raw message
Signature · 1 line
2.20.1
PATCH 5/5 iomap: move struct iomap_page out of iomap.h
In reply to Christoph HellwigNow that all the writepage code is in the iomap code there is no need to keep this structure public.
--- fs/iomap/buffered-io.c | 17 +++++++++++++++++ include/linux/iomap.h | 17 ----------------- 2 files changed, 17 insertions(+), 17 deletions(-)
fs/iomap/buffered-io.c +17 -0
@@ -23,6 +23,23 @@#define CREATE_TRACE_POINTS #include <trace/events/iomap.h> +/* +* Structure allocated for each page when block size < PAGE_SIZE to track +* sub-page uptodate status and I/O completions. +*/ +struct iomap_page { +atomic_t read_count; +atomic_t write_count; + DECLARE_BITMAP(uptodate, PAGE_SIZE / 512); +}; + +static inline struct iomap_page *to_iomap_page (struct page *page) +{ +if (page_has_private (page)) +return (struct iomap_page *)page_private (page); +return NULL ; +} +static struct bio_set iomap_ioend_bioset; static struct iomap_page *
include/linux/iomap.h +0 -17
@@ -134,23 +134,6 @@ loff_t iomap_apply(struct inode *inode, loff_t pos, loff_t length, unsigned flags, const struct iomap_ops *ops, void *data, iomap_actor_t actor); -/* -* Structure allocate for each page when block size < PAGE_SIZE to track -* sub-page uptodate status and I/O completions. -*/ -struct iomap_page { -atomic_t read_count; -atomic_t write_count; - DECLARE_BITMAP(uptodate, PAGE_SIZE / 512); -}; - -static inline struct iomap_page *to_iomap_page (struct page *page) -{ -if (page_has_private (page)) -return (struct iomap_page *)page_private (page); -return NULL ; -} -ssize_t iomap_file_buffered_write (struct kiocb *iocb,struct iov_iter *from,const struct iomap_ops *ops);int iomap_readpage (struct page *page,const struct iomap_ops *ops);
Signature · 1 line
2.20.1