* lift the xfs writepage code into iomap v2
@ 2019-06-27 10:48 Christoph Hellwig
2019-06-27 10:48 ` [PATCH 01/13] list.h: add list_pop and list_pop_entry helpers Christoph Hellwig
` (13 more replies)
0 siblings, 14 replies; 28+ messages in thread
From: Christoph Hellwig @ 2019-06-27 10:48 UTC (permalink / raw)
To: Darrick J . Wong
Cc: Damien Le Moal, Andreas Gruenbacher, linux-xfs, linux-fsdevel,
linux-kernel
Hi all,
this series cleans up the xfs writepage code and then lifts it to
fs/iomap.c so that it could be use by other file system. I've been
wanting to 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.
This new version should have addressed all comments from the review,
except that I haven't split iomap.c, which is a little too invasive
with other pending changes to the file. I do however offer to submit
a split right at the end of the merge window when it is least invasive.
Changes since v1:
- rebased to the latest xfs for-next tree
- keep the preallocated transactions for size updates
- rename list_pop to list_pop_entry and related cleanups
- better document the nofs context handling
- document that the iomap tracepoints are not a stable API
^ permalink raw reply [flat|nested] 28+ messages in thread
* [PATCH 01/13] list.h: add list_pop and list_pop_entry helpers
2019-06-27 10:48 lift the xfs writepage code into iomap v2 Christoph Hellwig
@ 2019-06-27 10:48 ` Christoph Hellwig
2019-06-27 20:48 ` Darrick J. Wong
2019-06-27 10:48 ` [PATCH 02/13] xfs: remove the unused xfs_count_page_state declaration Christoph Hellwig
` (12 subsequent siblings)
13 siblings, 1 reply; 28+ messages in thread
From: Christoph Hellwig @ 2019-06-27 10:48 UTC (permalink / raw)
To: Darrick J . Wong
Cc: Damien Le Moal, Andreas Gruenbacher, linux-xfs, linux-fsdevel,
linux-kernel
We have a very common pattern where we want to delete the first entry
from a list and return it as the properly typed container structure.
Add two helpers to implement this behavior.
Signed-off-by: Christoph Hellwig <hch@lst.de>
---
include/linux/list.h | 33 +++++++++++++++++++++++++++++++++
1 file changed, 33 insertions(+)
diff --git a/include/linux/list.h b/include/linux/list.h
index e951228db4b2..ba6e27d2235a 100644
--- a/include/linux/list.h
+++ b/include/linux/list.h
@@ -500,6 +500,39 @@ static inline void list_splice_tail_init(struct list_head *list,
pos__ != head__ ? list_entry(pos__, type, member) : NULL; \
})
+/**
+ * list_pop - delete the first entry from a list and return it
+ * @list: the list to take the element from.
+ *
+ * Return the list entry after @list. If @list is empty return NULL.
+ */
+static inline struct list_head *list_pop(struct list_head *list)
+{
+ struct list_head *pos = READ_ONCE(list->next);
+
+ if (pos == list)
+ return NULL;
+ list_del(pos);
+ return pos;
+}
+
+/**
+ * list_pop_entry - delete the first entry from a list and return the
+ * containing structure
+ * @list: the list to take the element from.
+ * @type: the type of the struct this is embedded in.
+ * @member: the name of the list_head within the struct.
+ *
+ * Return the containing structure for the list entry after @list. If @list
+ * is empty return NULL.
+ */
+#define list_pop_entry(list, type, member) \
+({ \
+ struct list_head *pos__ = list_pop(list); \
+ \
+ pos__ ? list_entry(pos__, type, member) : NULL; \
+})
+
/**
* list_next_entry - get the next element in list
* @pos: the type * to cursor
--
2.20.1
^ permalink raw reply related [flat|nested] 28+ messages in thread
* [PATCH 02/13] xfs: remove the unused xfs_count_page_state declaration
2019-06-27 10:48 lift the xfs writepage code into iomap v2 Christoph Hellwig
2019-06-27 10:48 ` [PATCH 01/13] list.h: add list_pop and list_pop_entry helpers Christoph Hellwig
@ 2019-06-27 10:48 ` Christoph Hellwig
2019-06-27 17:50 ` Darrick J. Wong
2019-06-27 10:48 ` [PATCH 03/13] xfs: fix a comment typo in xfs_submit_ioend Christoph Hellwig
` (11 subsequent siblings)
13 siblings, 1 reply; 28+ messages in thread
From: Christoph Hellwig @ 2019-06-27 10:48 UTC (permalink / raw)
To: Darrick J . Wong
Cc: Damien Le Moal, Andreas Gruenbacher, linux-xfs, linux-fsdevel,
linux-kernel
Signed-off-by: Christoph Hellwig <hch@lst.de>
---
fs/xfs/xfs_aops.h | 1 -
1 file changed, 1 deletion(-)
diff --git a/fs/xfs/xfs_aops.h b/fs/xfs/xfs_aops.h
index f62b03186c62..45a1ea240cbb 100644
--- a/fs/xfs/xfs_aops.h
+++ b/fs/xfs/xfs_aops.h
@@ -28,7 +28,6 @@ extern const struct address_space_operations xfs_dax_aops;
int xfs_setfilesize(struct xfs_inode *ip, xfs_off_t offset, size_t size);
-extern void xfs_count_page_state(struct page *, int *, int *);
extern struct block_device *xfs_find_bdev_for_inode(struct inode *);
extern struct dax_device *xfs_find_daxdev_for_inode(struct inode *);
--
2.20.1
^ permalink raw reply related [flat|nested] 28+ messages in thread
* [PATCH 03/13] xfs: fix a comment typo in xfs_submit_ioend
2019-06-27 10:48 lift the xfs writepage code into iomap v2 Christoph Hellwig
2019-06-27 10:48 ` [PATCH 01/13] list.h: add list_pop and list_pop_entry helpers Christoph Hellwig
2019-06-27 10:48 ` [PATCH 02/13] xfs: remove the unused xfs_count_page_state declaration Christoph Hellwig
@ 2019-06-27 10:48 ` Christoph Hellwig
2019-06-27 10:48 ` [PATCH 04/13] xfs: initialize iomap->flags in xfs_bmbt_to_iomap Christoph Hellwig
` (10 subsequent siblings)
13 siblings, 0 replies; 28+ messages in thread
From: Christoph Hellwig @ 2019-06-27 10:48 UTC (permalink / raw)
To: Darrick J . Wong
Cc: Damien Le Moal, Andreas Gruenbacher, linux-xfs, linux-fsdevel,
linux-kernel
The fail argument is long gone, update the comment.
Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Darrick J. Wong <darrick.wong@oracle.com>
---
fs/xfs/xfs_aops.c | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/fs/xfs/xfs_aops.c b/fs/xfs/xfs_aops.c
index 73c291aeae17..8f7b2d91d9a4 100644
--- a/fs/xfs/xfs_aops.c
+++ b/fs/xfs/xfs_aops.c
@@ -626,7 +626,7 @@ xfs_map_blocks(
* 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 @fail is non-zero, it means that we have a situation where some part of
+ * 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
--
2.20.1
^ permalink raw reply related [flat|nested] 28+ messages in thread
* [PATCH 04/13] xfs: initialize iomap->flags in xfs_bmbt_to_iomap
2019-06-27 10:48 lift the xfs writepage code into iomap v2 Christoph Hellwig
` (2 preceding siblings ...)
2019-06-27 10:48 ` [PATCH 03/13] xfs: fix a comment typo in xfs_submit_ioend Christoph Hellwig
@ 2019-06-27 10:48 ` Christoph Hellwig
2019-06-27 20:44 ` Darrick J. Wong
2019-06-27 10:48 ` [PATCH 05/13] xfs: use a struct iomap in xfs_writepage_ctx Christoph Hellwig
` (9 subsequent siblings)
13 siblings, 1 reply; 28+ messages in thread
From: Christoph Hellwig @ 2019-06-27 10:48 UTC (permalink / raw)
To: Darrick J . Wong
Cc: Damien Le Moal, Andreas Gruenbacher, linux-xfs, linux-fsdevel,
linux-kernel
Currently we don't overwrite the flags field in the iomap in
xfs_bmbt_to_iomap. This works fine with 0-initialized iomaps on stack,
but is harmful once we want to be able to reuse an iomap in the
writeback code. Replace the shared paramter with a set of initial
flags an thus ensures the flags field is always reinitialized.
Signed-off-by: Christoph Hellwig <hch@lst.de>
---
fs/xfs/xfs_iomap.c | 28 +++++++++++++++++-----------
fs/xfs/xfs_iomap.h | 2 +-
fs/xfs/xfs_pnfs.c | 2 +-
3 files changed, 19 insertions(+), 13 deletions(-)
diff --git a/fs/xfs/xfs_iomap.c b/fs/xfs/xfs_iomap.c
index 63d323916bba..6b29452bfba0 100644
--- a/fs/xfs/xfs_iomap.c
+++ b/fs/xfs/xfs_iomap.c
@@ -57,7 +57,7 @@ xfs_bmbt_to_iomap(
struct xfs_inode *ip,
struct iomap *iomap,
struct xfs_bmbt_irec *imap,
- bool shared)
+ u16 flags)
{
struct xfs_mount *mp = ip->i_mount;
@@ -82,12 +82,11 @@ xfs_bmbt_to_iomap(
iomap->length = XFS_FSB_TO_B(mp, imap->br_blockcount);
iomap->bdev = xfs_find_bdev_for_inode(VFS_I(ip));
iomap->dax_dev = xfs_find_daxdev_for_inode(VFS_I(ip));
+ iomap->flags = flags;
if (xfs_ipincount(ip) &&
(ip->i_itemp->ili_fsync_fields & ~XFS_ILOG_TIMESTAMP))
iomap->flags |= IOMAP_F_DIRTY;
- if (shared)
- iomap->flags |= IOMAP_F_SHARED;
return 0;
}
@@ -543,6 +542,7 @@ xfs_file_iomap_begin_delay(
struct xfs_iext_cursor icur, ccur;
xfs_fsblock_t prealloc_blocks = 0;
bool eof = false, cow_eof = false, shared = false;
+ u16 iomap_flags = 0;
int whichfork = XFS_DATA_FORK;
int error = 0;
@@ -710,7 +710,7 @@ xfs_file_iomap_begin_delay(
* Flag newly allocated delalloc blocks with IOMAP_F_NEW so we punch
* them out if the write happens to fail.
*/
- iomap->flags |= IOMAP_F_NEW;
+ iomap_flags |= IOMAP_F_NEW;
trace_xfs_iomap_alloc(ip, offset, count, whichfork,
whichfork == XFS_DATA_FORK ? &imap : &cmap);
done:
@@ -718,14 +718,17 @@ xfs_file_iomap_begin_delay(
if (imap.br_startoff > offset_fsb) {
xfs_trim_extent(&cmap, offset_fsb,
imap.br_startoff - offset_fsb);
- error = xfs_bmbt_to_iomap(ip, iomap, &cmap, true);
+ error = xfs_bmbt_to_iomap(ip, iomap, &cmap,
+ IOMAP_F_SHARED);
goto out_unlock;
}
/* ensure we only report blocks we have a reservation for */
xfs_trim_extent(&imap, cmap.br_startoff, cmap.br_blockcount);
shared = true;
}
- error = xfs_bmbt_to_iomap(ip, iomap, &imap, shared);
+ if (shared)
+ iomap_flags |= IOMAP_F_SHARED;
+ error = xfs_bmbt_to_iomap(ip, iomap, &imap, iomap_flags);
out_unlock:
xfs_iunlock(ip, XFS_ILOCK_EXCL);
return error;
@@ -933,6 +936,7 @@ xfs_file_iomap_begin(
xfs_fileoff_t offset_fsb, end_fsb;
int nimaps = 1, error = 0;
bool shared = false;
+ u16 iomap_flags = 0;
unsigned lockmode;
if (XFS_FORCED_SHUTDOWN(mp))
@@ -1048,11 +1052,13 @@ xfs_file_iomap_begin(
if (error)
return error;
- iomap->flags |= IOMAP_F_NEW;
+ iomap_flags |= IOMAP_F_NEW;
trace_xfs_iomap_alloc(ip, offset, length, XFS_DATA_FORK, &imap);
out_finish:
- return xfs_bmbt_to_iomap(ip, iomap, &imap, shared);
+ if (shared)
+ iomap_flags |= IOMAP_F_SHARED;
+ return xfs_bmbt_to_iomap(ip, iomap, &imap, iomap_flags);
out_found:
ASSERT(nimaps);
@@ -1196,7 +1202,7 @@ xfs_seek_iomap_begin(
if (data_fsb < cow_fsb + cmap.br_blockcount)
end_fsb = min(end_fsb, data_fsb);
xfs_trim_extent(&cmap, offset_fsb, end_fsb);
- error = xfs_bmbt_to_iomap(ip, iomap, &cmap, true);
+ error = xfs_bmbt_to_iomap(ip, iomap, &cmap, IOMAP_F_SHARED);
/*
* This is a COW extent, so we must probe the page cache
* because there could be dirty page cache being backed
@@ -1218,7 +1224,7 @@ xfs_seek_iomap_begin(
imap.br_state = XFS_EXT_NORM;
done:
xfs_trim_extent(&imap, offset_fsb, end_fsb);
- error = xfs_bmbt_to_iomap(ip, iomap, &imap, false);
+ error = xfs_bmbt_to_iomap(ip, iomap, &imap, 0);
out_unlock:
xfs_iunlock(ip, lockmode);
return error;
@@ -1264,7 +1270,7 @@ xfs_xattr_iomap_begin(
if (error)
return error;
ASSERT(nimaps);
- return xfs_bmbt_to_iomap(ip, iomap, &imap, false);
+ return xfs_bmbt_to_iomap(ip, iomap, &imap, 0);
}
const struct iomap_ops xfs_xattr_iomap_ops = {
diff --git a/fs/xfs/xfs_iomap.h b/fs/xfs/xfs_iomap.h
index 5c2f6aa6d78f..71d0ae460c44 100644
--- a/fs/xfs/xfs_iomap.h
+++ b/fs/xfs/xfs_iomap.h
@@ -16,7 +16,7 @@ int xfs_iomap_write_direct(struct xfs_inode *, xfs_off_t, size_t,
int xfs_iomap_write_unwritten(struct xfs_inode *, xfs_off_t, xfs_off_t, bool);
int xfs_bmbt_to_iomap(struct xfs_inode *, struct iomap *,
- struct xfs_bmbt_irec *, bool shared);
+ struct xfs_bmbt_irec *, u16);
xfs_extlen_t xfs_eof_alignment(struct xfs_inode *ip, xfs_extlen_t extsize);
static inline xfs_filblks_t
diff --git a/fs/xfs/xfs_pnfs.c b/fs/xfs/xfs_pnfs.c
index 2d95355a8a0a..97cdb57e58bc 100644
--- a/fs/xfs/xfs_pnfs.c
+++ b/fs/xfs/xfs_pnfs.c
@@ -186,7 +186,7 @@ xfs_fs_map_blocks(
}
xfs_iunlock(ip, XFS_IOLOCK_EXCL);
- error = xfs_bmbt_to_iomap(ip, iomap, &imap, false);
+ error = xfs_bmbt_to_iomap(ip, iomap, &imap, 0);
*device_generation = mp->m_generation;
return error;
out_unlock:
--
2.20.1
^ permalink raw reply related [flat|nested] 28+ messages in thread
* [PATCH 05/13] xfs: use a struct iomap in xfs_writepage_ctx
2019-06-27 10:48 lift the xfs writepage code into iomap v2 Christoph Hellwig
` (3 preceding siblings ...)
2019-06-27 10:48 ` [PATCH 04/13] xfs: initialize iomap->flags in xfs_bmbt_to_iomap Christoph Hellwig
@ 2019-06-27 10:48 ` Christoph Hellwig
2019-06-27 10:48 ` [PATCH 06/13] xfs: remove XFS_TRANS_NOFS Christoph Hellwig
` (8 subsequent siblings)
13 siblings, 0 replies; 28+ messages in thread
From: Christoph Hellwig @ 2019-06-27 10:48 UTC (permalink / raw)
To: Darrick J . Wong
Cc: Damien Le Moal, Andreas Gruenbacher, linux-xfs, linux-fsdevel,
linux-kernel
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.
Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Darrick J. Wong <darrick.wong@oracle.com>
---
fs/xfs/libxfs/xfs_bmap.c | 14 +++++--
fs/xfs/libxfs/xfs_bmap.h | 3 +-
fs/xfs/xfs_aops.c | 80 +++++++++++++++++++---------------------
fs/xfs/xfs_aops.h | 2 +-
4 files changed, 50 insertions(+), 49 deletions(-)
diff --git a/fs/xfs/libxfs/xfs_bmap.c b/fs/xfs/libxfs/xfs_bmap.c
index 4133bc461e3e..de35a0376156 100644
--- a/fs/xfs/libxfs/xfs_bmap.c
+++ b/fs/xfs/libxfs/xfs_bmap.c
@@ -39,6 +39,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;
@@ -4457,16 +4458,21 @@ int
xfs_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.
@@ -4496,7 +4502,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;
}
@@ -4529,7 +4535,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) {
diff --git a/fs/xfs/libxfs/xfs_bmap.h b/fs/xfs/libxfs/xfs_bmap.h
index 8f597f9abdbe..3c3470f11648 100644
--- a/fs/xfs/libxfs/xfs_bmap.h
+++ b/fs/xfs/libxfs/xfs_bmap.h
@@ -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,
diff --git a/fs/xfs/xfs_aops.c b/fs/xfs/xfs_aops.c
index 8f7b2d91d9a4..243548b9d0cc 100644
--- a/fs/xfs/xfs_aops.c
+++ b/fs/xfs/xfs_aops.c
@@ -27,7 +27,7 @@
* structure owned by writepages passed to individual writepage calls
*/
struct xfs_writepage_ctx {
- struct xfs_bmbt_irec imap;
+ struct iomap iomap;
int fork;
unsigned int data_seq;
unsigned int cow_seq;
@@ -265,7 +265,7 @@ xfs_end_ioend(
*/
if (ioend->io_fork == XFS_COW_FORK)
error = xfs_reflink_end_cow(ip, offset, size);
- else if (ioend->io_state == XFS_EXT_UNWRITTEN)
+ 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);
@@ -300,8 +300,8 @@ xfs_ioend_can_merge(
return false;
if ((ioend->io_fork == XFS_COW_FORK) ^ (next->io_fork == XFS_COW_FORK))
return false;
- if ((ioend->io_state == XFS_EXT_UNWRITTEN) ^
- (next->io_state == XFS_EXT_UNWRITTEN))
+ 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;
@@ -395,7 +395,7 @@ xfs_end_bio(
unsigned long flags;
if (ioend->io_fork == XFS_COW_FORK ||
- ioend->io_state == XFS_EXT_UNWRITTEN ||
+ ioend->io_type == IOMAP_UNWRITTEN ||
ioend->io_append_trans != NULL) {
spin_lock_irqsave(&ip->i_ioend_lock, flags);
if (list_empty(&ip->i_ioend_list))
@@ -415,10 +415,10 @@ static bool
xfs_imap_valid(
struct xfs_writepage_ctx *wpc,
struct xfs_inode *ip,
- xfs_fileoff_t offset_fsb)
+ loff_t offset)
{
- if (offset_fsb < wpc->imap.br_startoff ||
- offset_fsb >= wpc->imap.br_startoff + wpc->imap.br_blockcount)
+ if (offset < wpc->iomap.offset ||
+ offset >= wpc->iomap.offset + wpc->iomap.length)
return false;
/*
* If this is a COW mapping, it is sufficient to check that the mapping
@@ -445,7 +445,7 @@ xfs_imap_valid(
/*
* Pass in a dellalloc extent and convert it to real extents, return the real
- * extent that maps offset_fsb in wpc->imap.
+ * extent that maps offset_fsb in wpc->iomap.
*
* The current page is held locked so nothing could have removed the block
* backing offset_fsb, although it could have moved from the COW to the data
@@ -455,23 +455,23 @@ static int
xfs_convert_blocks(
struct xfs_writepage_ctx *wpc,
struct xfs_inode *ip,
- xfs_fileoff_t offset_fsb)
+ loff_t offset)
{
int error;
/*
- * Attempt to allocate whatever delalloc extent currently backs
- * offset_fsb and put the result into wpc->imap. Allocate in a loop
- * because it may take several attempts to allocate real blocks for a
- * contiguous delalloc extent if free space is sufficiently fragmented.
+ * Attempt to allocate whatever delalloc extent currently backs offset
+ * and put the result into wpc->imap. Allocate in a loop because it may
+ * take several attempts to allocate real blocks for a contiguous
+ * delalloc extent if free space is sufficiently fragmented.
*/
do {
- error = xfs_bmapi_convert_delalloc(ip, wpc->fork, offset_fsb,
- &wpc->imap, wpc->fork == XFS_COW_FORK ?
+ error = xfs_bmapi_convert_delalloc(ip, wpc->fork, offset,
+ &wpc->iomap, wpc->fork == XFS_COW_FORK ?
&wpc->cow_seq : &wpc->data_seq);
if (error)
return error;
- } while (wpc->imap.br_startoff + wpc->imap.br_blockcount <= offset_fsb);
+ } while (wpc->iomap.offset + wpc->iomap.length <= offset);
return 0;
}
@@ -511,7 +511,7 @@ xfs_map_blocks(
* against concurrent updates and provides a memory barrier on the way
* out that ensures that we always see the current value.
*/
- if (xfs_imap_valid(wpc, ip, offset_fsb))
+ if (xfs_imap_valid(wpc, ip, offset))
return 0;
/*
@@ -544,7 +544,7 @@ xfs_map_blocks(
* No COW extent overlap. Revalidate now that we may have updated
* ->cow_seq. If the data mapping is still valid, we're done.
*/
- if (xfs_imap_valid(wpc, ip, offset_fsb)) {
+ if (xfs_imap_valid(wpc, ip, offset)) {
xfs_iunlock(ip, XFS_ILOCK_SHARED);
return 0;
}
@@ -584,11 +584,11 @@ xfs_map_blocks(
isnullstartblock(imap.br_startblock))
goto allocate_blocks;
- wpc->imap = imap;
+ xfs_bmbt_to_iomap(ip, &wpc->iomap, &imap, 0);
trace_xfs_map_blocks_found(ip, offset, count, wpc->fork, &imap);
return 0;
allocate_blocks:
- error = xfs_convert_blocks(wpc, ip, offset_fsb);
+ error = xfs_convert_blocks(wpc, ip, offset);
if (error) {
/*
* If we failed to find the extent in the COW fork we might have
@@ -608,12 +608,15 @@ 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 &&
- cow_fsb < wpc->imap.br_startoff + wpc->imap.br_blockcount)
- wpc->imap.br_blockcount = cow_fsb - wpc->imap.br_startoff;
+ if (wpc->fork != XFS_COW_FORK && cow_fsb != NULLFILEOFF) {
+ loff_t cow_offset = XFS_FSB_TO_B(mp, cow_fsb);
+
+ if (cow_offset < wpc->iomap.offset + wpc->iomap.length)
+ wpc->iomap.length = cow_offset - wpc->iomap.offset;
+ }
- ASSERT(wpc->imap.br_startoff <= offset_fsb);
- ASSERT(wpc->imap.br_startoff + wpc->imap.br_blockcount > offset_fsb);
+ ASSERT(wpc->iomap.offset <= offset);
+ ASSERT(wpc->iomap.offset + wpc->iomap.length > offset);
trace_xfs_map_blocks_alloc(ip, offset, count, wpc->fork, &imap);
return 0;
}
@@ -658,7 +661,7 @@ xfs_submit_ioend(
/* Reserve log space if we might write beyond the on-disk inode size. */
if (!status &&
(ioend->io_fork == XFS_COW_FORK ||
- ioend->io_state != XFS_EXT_UNWRITTEN) &&
+ ioend->io_type != IOMAP_UNWRITTEN) &&
xfs_ioend_is_append(ioend) &&
!ioend->io_append_trans)
status = xfs_setfilesize_trans_alloc(ioend);
@@ -685,10 +688,8 @@ xfs_submit_ioend(
static struct xfs_ioend *
xfs_alloc_ioend(
struct inode *inode,
- int fork,
- xfs_exntst_t state,
+ struct xfs_writepage_ctx *wpc,
xfs_off_t offset,
- struct block_device *bdev,
sector_t sector,
struct writeback_control *wbc)
{
@@ -696,7 +697,7 @@ xfs_alloc_ioend(
struct bio *bio;
bio = bio_alloc_bioset(GFP_NOFS, BIO_MAX_PAGES, &xfs_ioend_bioset);
- bio_set_dev(bio, bdev);
+ 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;
@@ -704,8 +705,8 @@ xfs_alloc_ioend(
ioend = container_of(bio, struct xfs_ioend, io_inline_bio);
INIT_LIST_HEAD(&ioend->io_list);
- ioend->io_fork = fork;
- ioend->io_state = state;
+ ioend->io_fork = wpc->fork;
+ ioend->io_type = wpc->iomap.type;
ioend->io_inode = inode;
ioend->io_size = 0;
ioend->io_offset = offset;
@@ -753,25 +754,20 @@ xfs_add_to_ioend(
struct writeback_control *wbc,
struct list_head *iolist)
{
- struct xfs_inode *ip = XFS_I(inode);
- struct xfs_mount *mp = ip->i_mount;
- struct block_device *bdev = xfs_find_bdev_for_inode(inode);
unsigned len = i_blocksize(inode);
unsigned poff = offset & (PAGE_SIZE - 1);
sector_t sector;
- sector = xfs_fsb_to_db(ip, wpc->imap.br_startblock) +
- ((offset - XFS_FSB_TO_B(mp, wpc->imap.br_startoff)) >> 9);
+ sector = (wpc->iomap.addr + offset - wpc->iomap.offset) >> 9;
if (!wpc->ioend ||
wpc->fork != wpc->ioend->io_fork ||
- wpc->imap.br_state != wpc->ioend->io_state ||
+ 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->fork,
- wpc->imap.br_state, offset, bdev, sector, wbc);
+ wpc->ioend = xfs_alloc_ioend(inode, wpc, offset, sector, wbc);
}
if (!__bio_try_merge_page(wpc->ioend->io_bio, page, len, poff, true)) {
@@ -881,7 +877,7 @@ xfs_writepage_map(
error = xfs_map_blocks(wpc, inode, file_offset);
if (error)
break;
- if (wpc->imap.br_startblock == HOLESTARTBLOCK)
+ if (wpc->iomap.type == IOMAP_HOLE)
continue;
xfs_add_to_ioend(inode, file_offset, page, iop, wpc, wbc,
&submit_list);
diff --git a/fs/xfs/xfs_aops.h b/fs/xfs/xfs_aops.h
index 45a1ea240cbb..4af8ec0115cd 100644
--- a/fs/xfs/xfs_aops.h
+++ b/fs/xfs/xfs_aops.h
@@ -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 */
--
2.20.1
^ permalink raw reply related [flat|nested] 28+ messages in thread
* [PATCH 06/13] xfs: remove XFS_TRANS_NOFS
2019-06-27 10:48 lift the xfs writepage code into iomap v2 Christoph Hellwig
` (4 preceding siblings ...)
2019-06-27 10:48 ` [PATCH 05/13] xfs: use a struct iomap in xfs_writepage_ctx Christoph Hellwig
@ 2019-06-27 10:48 ` Christoph Hellwig
2019-06-27 22:30 ` Darrick J. Wong
2019-06-27 10:48 ` [PATCH 07/13] xfs: allow merging ioends over append boundaries Christoph Hellwig
` (7 subsequent siblings)
13 siblings, 1 reply; 28+ messages in thread
From: Christoph Hellwig @ 2019-06-27 10:48 UTC (permalink / raw)
To: Darrick J . Wong
Cc: Damien Le Moal, Andreas Gruenbacher, linux-xfs, linux-fsdevel,
linux-kernel
Instead of a magic flag for xfs_trans_alloc, just ensure all callers
that can't relclaim through the file system use memalloc_nofs_save to
set the per-task nofs flag.
Signed-off-by: Christoph Hellwig <hch@lst.de>
---
fs/xfs/libxfs/xfs_shared.h | 1 -
fs/xfs/xfs_aops.c | 35 ++++++++++++++++++++++-------------
fs/xfs/xfs_file.c | 12 +++++++++---
fs/xfs/xfs_iomap.c | 2 +-
fs/xfs/xfs_reflink.c | 4 ++--
fs/xfs/xfs_trans.c | 4 +---
6 files changed, 35 insertions(+), 23 deletions(-)
diff --git a/fs/xfs/libxfs/xfs_shared.h b/fs/xfs/libxfs/xfs_shared.h
index b9094709bc79..c45acbd3add9 100644
--- a/fs/xfs/libxfs/xfs_shared.h
+++ b/fs/xfs/libxfs/xfs_shared.h
@@ -65,7 +65,6 @@ void xfs_log_get_max_trans_res(struct xfs_mount *mp,
#define XFS_TRANS_DQ_DIRTY 0x10 /* at least one dquot in trx dirty */
#define XFS_TRANS_RESERVE 0x20 /* OK to use reserved data blocks */
#define XFS_TRANS_NO_WRITECOUNT 0x40 /* do not elevate SB writecount */
-#define XFS_TRANS_NOFS 0x80 /* pass KM_NOFS to kmem_alloc */
/*
* LOWMODE is used by the allocator to activate the lowspace algorithm - when
* free space is running low the extent allocator may choose to allocate an
diff --git a/fs/xfs/xfs_aops.c b/fs/xfs/xfs_aops.c
index 243548b9d0cc..8b3070a40245 100644
--- a/fs/xfs/xfs_aops.c
+++ b/fs/xfs/xfs_aops.c
@@ -138,8 +138,7 @@ xfs_setfilesize_trans_alloc(
struct xfs_trans *tp;
int error;
- error = xfs_trans_alloc(mp, &M_RES(mp)->tr_fsyncts, 0, 0,
- XFS_TRANS_NOFS, &tp);
+ error = xfs_trans_alloc(mp, &M_RES(mp)->tr_fsyncts, 0, 0, 0, &tp);
if (error)
return error;
@@ -240,8 +239,16 @@ xfs_end_ioend(
struct xfs_inode *ip = XFS_I(ioend->io_inode);
xfs_off_t offset = ioend->io_offset;
size_t size = ioend->io_size;
+ unsigned int nofs_flag;
int error;
+ /*
+ * We can do memory allocation here, but aren't in transactional
+ * context. To avoid memory allocation deadlocks set the task-wide
+ * nofs context for the following operations.
+ */
+ nofs_flag = memalloc_nofs_save();
+
/*
* Just clean up the in-memory strutures if the fs has been shut down.
*/
@@ -282,6 +289,8 @@ xfs_end_ioend(
list_del_init(&ioend->io_list);
xfs_destroy_ioend(ioend, error);
}
+
+ memalloc_nofs_restore(nofs_flag);
}
/*
@@ -641,21 +650,19 @@ xfs_submit_ioend(
struct xfs_ioend *ioend,
int status)
{
+ unsigned int nofs_flag;
+
+ /*
+ * We can do memory allocation here, but aren't in transactional
+ * context. To avoid memory allocation deadlocks set the task-wide
+ * nofs context for the following operations.
+ */
+ nofs_flag = memalloc_nofs_save();
+
/* Convert CoW extents to regular */
if (!status && ioend->io_fork == XFS_COW_FORK) {
- /*
- * Yuk. This can do memory allocation, but is not a
- * transactional operation so everything is done in GFP_KERNEL
- * context. That can deadlock, because we hold pages in
- * writeback state and GFP_KERNEL allocations can block on them.
- * Hence we must operate in nofs conditions here.
- */
- unsigned nofs_flag;
-
- nofs_flag = memalloc_nofs_save();
status = xfs_reflink_convert_cow(XFS_I(ioend->io_inode),
ioend->io_offset, ioend->io_size);
- memalloc_nofs_restore(nofs_flag);
}
/* Reserve log space if we might write beyond the on-disk inode size. */
@@ -666,6 +673,8 @@ xfs_submit_ioend(
!ioend->io_append_trans)
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;
diff --git a/fs/xfs/xfs_file.c b/fs/xfs/xfs_file.c
index 916a35cae5e9..f2d806ef8f06 100644
--- a/fs/xfs/xfs_file.c
+++ b/fs/xfs/xfs_file.c
@@ -379,6 +379,7 @@ xfs_dio_write_end_io(
struct inode *inode = file_inode(iocb->ki_filp);
struct xfs_inode *ip = XFS_I(inode);
loff_t offset = iocb->ki_pos;
+ unsigned int nofs_flag;
int error = 0;
trace_xfs_end_io_direct_write(ip, offset, size);
@@ -395,10 +396,11 @@ xfs_dio_write_end_io(
*/
XFS_STATS_ADD(ip->i_mount, xs_write_bytes, size);
+ nofs_flag = memalloc_nofs_save();
if (flags & IOMAP_DIO_COW) {
error = xfs_reflink_end_cow(ip, offset, size);
if (error)
- return error;
+ goto out;
}
/*
@@ -407,8 +409,10 @@ xfs_dio_write_end_io(
* earlier allows a racing dio read to find unwritten extents before
* they are converted.
*/
- if (flags & IOMAP_DIO_UNWRITTEN)
- return xfs_iomap_write_unwritten(ip, offset, size, true);
+ if (flags & IOMAP_DIO_UNWRITTEN) {
+ error = xfs_iomap_write_unwritten(ip, offset, size, true);
+ goto out;
+ }
/*
* We need to update the in-core inode size here so that we don't end up
@@ -430,6 +434,8 @@ xfs_dio_write_end_io(
spin_unlock(&ip->i_flags_lock);
}
+out:
+ memalloc_nofs_restore(nofs_flag);
return error;
}
diff --git a/fs/xfs/xfs_iomap.c b/fs/xfs/xfs_iomap.c
index 6b29452bfba0..461ea023b910 100644
--- a/fs/xfs/xfs_iomap.c
+++ b/fs/xfs/xfs_iomap.c
@@ -782,7 +782,7 @@ xfs_iomap_write_unwritten(
* complete here and might deadlock on the iolock.
*/
error = xfs_trans_alloc(mp, &M_RES(mp)->tr_write, resblks, 0,
- XFS_TRANS_RESERVE | XFS_TRANS_NOFS, &tp);
+ XFS_TRANS_RESERVE, &tp);
if (error)
return error;
diff --git a/fs/xfs/xfs_reflink.c b/fs/xfs/xfs_reflink.c
index 680ae7662a78..0b23c2b29609 100644
--- a/fs/xfs/xfs_reflink.c
+++ b/fs/xfs/xfs_reflink.c
@@ -572,7 +572,7 @@ xfs_reflink_cancel_cow_range(
/* Start a rolling transaction to remove the mappings */
error = xfs_trans_alloc(ip->i_mount, &M_RES(ip->i_mount)->tr_write,
- 0, 0, XFS_TRANS_NOFS, &tp);
+ 0, 0, 0, &tp);
if (error)
goto out;
@@ -631,7 +631,7 @@ xfs_reflink_end_cow_extent(
resblks = XFS_EXTENTADD_SPACE_RES(mp, XFS_DATA_FORK);
error = xfs_trans_alloc(mp, &M_RES(mp)->tr_write, resblks, 0,
- XFS_TRANS_RESERVE | XFS_TRANS_NOFS, &tp);
+ XFS_TRANS_RESERVE, &tp);
if (error)
return error;
diff --git a/fs/xfs/xfs_trans.c b/fs/xfs/xfs_trans.c
index b026f87608ce..2ad3faa12206 100644
--- a/fs/xfs/xfs_trans.c
+++ b/fs/xfs/xfs_trans.c
@@ -264,9 +264,7 @@ xfs_trans_alloc(
* GFP_NOFS allocation context so that we avoid lockdep false positives
* by doing GFP_KERNEL allocations inside sb_start_intwrite().
*/
- tp = kmem_zone_zalloc(xfs_trans_zone,
- (flags & XFS_TRANS_NOFS) ? KM_NOFS : KM_SLEEP);
-
+ tp = kmem_zone_zalloc(xfs_trans_zone, KM_SLEEP);
if (!(flags & XFS_TRANS_NO_WRITECOUNT))
sb_start_intwrite(mp->m_super);
--
2.20.1
^ permalink raw reply related [flat|nested] 28+ messages in thread
* [PATCH 07/13] xfs: allow merging ioends over append boundaries
2019-06-27 10:48 lift the xfs writepage code into iomap v2 Christoph Hellwig
` (5 preceding siblings ...)
2019-06-27 10:48 ` [PATCH 06/13] xfs: remove XFS_TRANS_NOFS Christoph Hellwig
@ 2019-06-27 10:48 ` Christoph Hellwig
2019-06-27 18:23 ` Darrick J. Wong
2019-06-27 10:48 ` [PATCH 08/13] xfs: simplify xfs_ioend_can_merge Christoph Hellwig
` (6 subsequent siblings)
13 siblings, 1 reply; 28+ messages in thread
From: Christoph Hellwig @ 2019-06-27 10:48 UTC (permalink / raw)
To: Darrick J . Wong
Cc: Damien Le Moal, Andreas Gruenbacher, linux-xfs, linux-fsdevel,
linux-kernel
There is no real problem merging ioends that go beyond i_size into an
ioend that doesn't. We just need to move the append transaction to the
base ioend. Also use the opportunity to use a real error code instead
of the magic 1 to cancel the transactions, and write a comment
explaining the scheme.
Signed-off-by: Christoph Hellwig <hch@lst.de>
---
fs/xfs/xfs_aops.c | 28 +++++++++++++++++++++-------
1 file changed, 21 insertions(+), 7 deletions(-)
diff --git a/fs/xfs/xfs_aops.c b/fs/xfs/xfs_aops.c
index 8b3070a40245..4ef8343c3759 100644
--- a/fs/xfs/xfs_aops.c
+++ b/fs/xfs/xfs_aops.c
@@ -314,11 +314,28 @@ xfs_ioend_can_merge(
return false;
if (ioend->io_offset + ioend->io_size != next->io_offset)
return false;
- if (xfs_ioend_is_append(ioend) != xfs_ioend_is_append(next))
- 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
+ * has one. If it already has one we can simply cancel the transaction
+ * as it is guaranteed to be clean.
+ */
+static void
+xfs_ioend_merge_append_transactions(
+ 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;
+ } else {
+ xfs_setfilesize_ioend(next, -ECANCELED);
+ }
+}
+
/* Try to merge adjacent completions. */
STATIC void
xfs_ioend_try_merge(
@@ -327,7 +344,6 @@ xfs_ioend_try_merge(
{
struct xfs_ioend *next_ioend;
int ioend_error;
- int error;
if (list_empty(more_ioends))
return;
@@ -341,10 +357,8 @@ xfs_ioend_try_merge(
break;
list_move_tail(&next_ioend->io_list, &ioend->io_list);
ioend->io_size += next_ioend->io_size;
- if (ioend->io_append_trans) {
- error = xfs_setfilesize_ioend(next_ioend, 1);
- ASSERT(error == 1);
- }
+ if (next_ioend->io_append_trans)
+ xfs_ioend_merge_append_transactions(ioend, next_ioend);
}
}
--
2.20.1
^ permalink raw reply related [flat|nested] 28+ messages in thread
* [PATCH 08/13] xfs: simplify xfs_ioend_can_merge
2019-06-27 10:48 lift the xfs writepage code into iomap v2 Christoph Hellwig
` (6 preceding siblings ...)
2019-06-27 10:48 ` [PATCH 07/13] xfs: allow merging ioends over append boundaries Christoph Hellwig
@ 2019-06-27 10:48 ` Christoph Hellwig
2019-06-27 10:48 ` [PATCH 09/13] xfs: refactor the ioend merging code Christoph Hellwig
` (5 subsequent siblings)
13 siblings, 0 replies; 28+ messages in thread
From: Christoph Hellwig @ 2019-06-27 10:48 UTC (permalink / raw)
To: Darrick J . Wong
Cc: Damien Le Moal, Andreas Gruenbacher, linux-xfs, linux-fsdevel,
linux-kernel
Compare the block layer status directly instead of converting it to
an errno first.
Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Darrick J. Wong <darrick.wong@oracle.com>
---
fs/xfs/xfs_aops.c | 14 ++------------
1 file changed, 2 insertions(+), 12 deletions(-)
diff --git a/fs/xfs/xfs_aops.c b/fs/xfs/xfs_aops.c
index 4ef8343c3759..cd839f24c7ef 100644
--- a/fs/xfs/xfs_aops.c
+++ b/fs/xfs/xfs_aops.c
@@ -299,13 +299,9 @@ xfs_end_ioend(
static bool
xfs_ioend_can_merge(
struct xfs_ioend *ioend,
- int ioend_error,
struct xfs_ioend *next)
{
- int next_error;
-
- next_error = blk_status_to_errno(next->io_bio->bi_status);
- if (ioend_error != next_error)
+ 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))
return false;
@@ -343,17 +339,11 @@ xfs_ioend_try_merge(
struct list_head *more_ioends)
{
struct xfs_ioend *next_ioend;
- int ioend_error;
-
- if (list_empty(more_ioends))
- return;
-
- ioend_error = blk_status_to_errno(ioend->io_bio->bi_status);
while (!list_empty(more_ioends)) {
next_ioend = list_first_entry(more_ioends, struct xfs_ioend,
io_list);
- if (!xfs_ioend_can_merge(ioend, ioend_error, next_ioend))
+ if (!xfs_ioend_can_merge(ioend, next_ioend))
break;
list_move_tail(&next_ioend->io_list, &ioend->io_list);
ioend->io_size += next_ioend->io_size;
--
2.20.1
^ permalink raw reply related [flat|nested] 28+ messages in thread
* [PATCH 09/13] xfs: refactor the ioend merging code
2019-06-27 10:48 lift the xfs writepage code into iomap v2 Christoph Hellwig
` (7 preceding siblings ...)
2019-06-27 10:48 ` [PATCH 08/13] xfs: simplify xfs_ioend_can_merge Christoph Hellwig
@ 2019-06-27 10:48 ` Christoph Hellwig
2019-06-27 10:48 ` [PATCH 10/13] xfs: turn io_append_trans into an io_private void pointer Christoph Hellwig
` (4 subsequent siblings)
13 siblings, 0 replies; 28+ messages in thread
From: Christoph Hellwig @ 2019-06-27 10:48 UTC (permalink / raw)
To: Darrick J . Wong
Cc: Damien Le Moal, Andreas Gruenbacher, linux-xfs, linux-fsdevel,
linux-kernel
Introduce two nicely abstracted helper, which can be moved to the
iomap code later. Also use list_pop_entry and list_first_entry_or_null
to simplify the code a bit.
Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Darrick J. Wong <darrick.wong@oracle.com>
---
fs/xfs/xfs_aops.c | 70 +++++++++++++++++++++++++----------------------
1 file changed, 38 insertions(+), 32 deletions(-)
diff --git a/fs/xfs/xfs_aops.c b/fs/xfs/xfs_aops.c
index cd839f24c7ef..f3b99b0a9999 100644
--- a/fs/xfs/xfs_aops.c
+++ b/fs/xfs/xfs_aops.c
@@ -121,6 +121,19 @@ xfs_destroy_ioend(
}
}
+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.
*/
@@ -235,7 +248,6 @@ STATIC void
xfs_end_ioend(
struct xfs_ioend *ioend)
{
- struct list_head ioend_list;
struct xfs_inode *ip = XFS_I(ioend->io_inode);
xfs_off_t offset = ioend->io_offset;
size_t size = ioend->io_size;
@@ -280,16 +292,7 @@ xfs_end_ioend(
done:
if (ioend->io_append_trans)
error = xfs_setfilesize_ioend(ioend, error);
- list_replace_init(&ioend->io_list, &ioend_list);
- xfs_destroy_ioend(ioend, error);
-
- while (!list_empty(&ioend_list)) {
- ioend = list_first_entry(&ioend_list, struct xfs_ioend,
- io_list);
- list_del_init(&ioend->io_list);
- xfs_destroy_ioend(ioend, error);
- }
-
+ xfs_destroy_ioends(ioend, error);
memalloc_nofs_restore(nofs_flag);
}
@@ -338,17 +341,18 @@ xfs_ioend_try_merge(
struct xfs_ioend *ioend,
struct list_head *more_ioends)
{
- struct xfs_ioend *next_ioend;
+ struct xfs_ioend *next;
- while (!list_empty(more_ioends)) {
- next_ioend = list_first_entry(more_ioends, struct xfs_ioend,
- io_list);
- if (!xfs_ioend_can_merge(ioend, next_ioend))
+ 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_ioend->io_list, &ioend->io_list);
- ioend->io_size += next_ioend->io_size;
- if (next_ioend->io_append_trans)
- xfs_ioend_merge_append_transactions(ioend, next_ioend);
+ 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);
}
}
@@ -371,29 +375,31 @@ xfs_ioend_compare(
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(
struct work_struct *work)
{
- struct xfs_inode *ip;
+ struct xfs_inode *ip =
+ container_of(work, struct xfs_inode, i_ioend_work);
struct xfs_ioend *ioend;
- struct list_head completion_list;
+ struct list_head tmp;
unsigned long flags;
- ip = container_of(work, struct xfs_inode, i_ioend_work);
-
spin_lock_irqsave(&ip->i_ioend_lock, flags);
- list_replace_init(&ip->i_ioend_list, &completion_list);
+ list_replace_init(&ip->i_ioend_list, &tmp);
spin_unlock_irqrestore(&ip->i_ioend_lock, flags);
- list_sort(NULL, &completion_list, xfs_ioend_compare);
-
- while (!list_empty(&completion_list)) {
- ioend = list_first_entry(&completion_list, struct xfs_ioend,
- io_list);
- list_del_init(&ioend->io_list);
- xfs_ioend_try_merge(ioend, &completion_list);
+ xfs_sort_ioends(&tmp);
+ while ((ioend = list_pop_entry(&tmp, struct xfs_ioend, io_list))) {
+ xfs_ioend_try_merge(ioend, &tmp);
xfs_end_ioend(ioend);
}
}
--
2.20.1
^ permalink raw reply related [flat|nested] 28+ messages in thread
* [PATCH 10/13] xfs: turn io_append_trans into an io_private void pointer
2019-06-27 10:48 lift the xfs writepage code into iomap v2 Christoph Hellwig
` (8 preceding siblings ...)
2019-06-27 10:48 ` [PATCH 09/13] xfs: refactor the ioend merging code Christoph Hellwig
@ 2019-06-27 10:48 ` Christoph Hellwig
2019-06-27 10:48 ` [PATCH 11/13] xfs: remove the fork fields in the writepage_ctx and ioend Christoph Hellwig
` (3 subsequent siblings)
13 siblings, 0 replies; 28+ messages in thread
From: Christoph Hellwig @ 2019-06-27 10:48 UTC (permalink / raw)
To: Darrick J . Wong
Cc: Damien Le Moal, Andreas Gruenbacher, linux-xfs, linux-fsdevel,
linux-kernel
In 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.
Signed-off-by: Christoph Hellwig <hch@lst.de>
---
fs/xfs/xfs_aops.c | 26 +++++++++++++-------------
fs/xfs/xfs_aops.h | 2 +-
2 files changed, 14 insertions(+), 14 deletions(-)
diff --git a/fs/xfs/xfs_aops.c b/fs/xfs/xfs_aops.c
index f3b99b0a9999..5f77ac93e5ab 100644
--- a/fs/xfs/xfs_aops.c
+++ b/fs/xfs/xfs_aops.c
@@ -155,7 +155,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
@@ -222,7 +222,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,
@@ -287,10 +287,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);
@@ -323,13 +323,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);
}
@@ -351,8 +351,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);
}
}
@@ -415,7 +415,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,
@@ -680,7 +680,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);
@@ -729,7 +729,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;
}
diff --git a/fs/xfs/xfs_aops.h b/fs/xfs/xfs_aops.h
index 4af8ec0115cd..6a45d675dcba 100644
--- a/fs/xfs/xfs_aops.h
+++ b/fs/xfs/xfs_aops.h
@@ -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! */
};
--
2.20.1
^ permalink raw reply related [flat|nested] 28+ messages in thread
* [PATCH 11/13] xfs: remove the fork fields in the writepage_ctx and ioend
2019-06-27 10:48 lift the xfs writepage code into iomap v2 Christoph Hellwig
` (9 preceding siblings ...)
2019-06-27 10:48 ` [PATCH 10/13] xfs: turn io_append_trans into an io_private void pointer Christoph Hellwig
@ 2019-06-27 10:48 ` Christoph Hellwig
2019-06-27 10:48 ` [PATCH 12/13] iomap: move the xfs writeback code to iomap.c Christoph Hellwig
` (2 subsequent siblings)
13 siblings, 0 replies; 28+ messages in thread
From: Christoph Hellwig @ 2019-06-27 10:48 UTC (permalink / raw)
To: Darrick J . Wong
Cc: Damien Le Moal, Andreas Gruenbacher, linux-xfs, linux-fsdevel,
linux-kernel
In preparation for moving the writeback code to iomap.c, replace the
XFS-specific COW fork concept with the iomap IOMAP_F_SHARED flag.
Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Darrick J. Wong <darrick.wong@oracle.com>
---
fs/xfs/xfs_aops.c | 42 ++++++++++++++++++++++--------------------
fs/xfs/xfs_aops.h | 2 +-
2 files changed, 23 insertions(+), 21 deletions(-)
diff --git a/fs/xfs/xfs_aops.c b/fs/xfs/xfs_aops.c
index 5f77ac93e5ab..8afefe744471 100644
--- a/fs/xfs/xfs_aops.c
+++ b/fs/xfs/xfs_aops.c
@@ -28,7 +28,6 @@
*/
struct xfs_writepage_ctx {
struct iomap iomap;
- int fork;
unsigned int data_seq;
unsigned int cow_seq;
struct xfs_ioend *ioend;
@@ -274,7 +273,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;
}
@@ -282,7 +281,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);
@@ -306,7 +305,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))
@@ -413,7 +413,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);
@@ -444,7 +444,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;
/*
@@ -474,6 +474,7 @@ static int
xfs_convert_blocks(
struct xfs_writepage_ctx *wpc,
struct xfs_inode *ip,
+ int whichfork,
loff_t offset)
{
int error;
@@ -485,8 +486,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;
@@ -507,6 +508,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;
@@ -555,7 +557,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;
}
@@ -578,8 +580,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;
@@ -604,10 +604,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
@@ -616,7 +616,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;
@@ -627,7 +628,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)
@@ -636,7 +637,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;
}
@@ -670,14 +671,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)
@@ -724,8 +725,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;
@@ -780,7 +781,8 @@ xfs_add_to_ioend(
sector = (wpc->iomap.addr + offset - wpc->iomap.offset) >> 9;
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) {
diff --git a/fs/xfs/xfs_aops.h b/fs/xfs/xfs_aops.h
index 6a45d675dcba..4a0226cdad4f 100644
--- a/fs/xfs/xfs_aops.h
+++ b/fs/xfs/xfs_aops.h
@@ -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 */
--
2.20.1
^ permalink raw reply related [flat|nested] 28+ messages in thread
* [PATCH 12/13] iomap: move the xfs writeback code to iomap.c
2019-06-27 10:48 lift the xfs writepage code into iomap v2 Christoph Hellwig
` (10 preceding siblings ...)
2019-06-27 10:48 ` [PATCH 11/13] xfs: remove the fork fields in the writepage_ctx and ioend Christoph Hellwig
@ 2019-06-27 10:48 ` Christoph Hellwig
2019-06-27 10:48 ` [PATCH 13/13] iomap: add tracing for the address space operations Christoph Hellwig
2019-06-28 1:32 ` lift the xfs writepage code into iomap v2 Darrick J. Wong
13 siblings, 0 replies; 28+ messages in thread
From: Christoph Hellwig @ 2019-06-27 10:48 UTC (permalink / raw)
To: Darrick J . Wong
Cc: Damien Le Moal, Andreas Gruenbacher, linux-xfs, linux-fsdevel,
linux-kernel
Takes the xfs writeback code and move it to iomap.c. A new structure
with three methods is added as the abstraction from the generic
writeback code to the file system. These methods are used to map
blocks, submit an ioend, and cancel a page that encountered an error
before it was added to an ioend.
Note that we temporarily lose the writepage tracing, but that will
be added back soon.
Signed-off-by: Christoph Hellwig <hch@lst.de>
---
fs/iomap.c | 528 ++++++++++++++++++++++++++++++++++++-
fs/xfs/xfs_aops.c | 597 ++++--------------------------------------
fs/xfs/xfs_aops.h | 17 --
fs/xfs/xfs_super.c | 11 +-
include/linux/iomap.h | 44 ++++
5 files changed, 619 insertions(+), 578 deletions(-)
diff --git a/fs/iomap.c b/fs/iomap.c
index 23ef63fd1669..bb5c42561398 100644
--- a/fs/iomap.c
+++ b/fs/iomap.c
@@ -1,7 +1,7 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (C) 2010 Red Hat, Inc.
- * Copyright (c) 2016-2018 Christoph Hellwig.
+ * Copyright (c) 2016-2019 Christoph Hellwig.
*/
#include <linux/module.h>
#include <linux/compiler.h>
@@ -12,6 +12,7 @@
#include <linux/migrate.h>
#include <linux/mm.h>
#include <linux/mm_inline.h>
+#include <linux/list_sort.h>
#include <linux/swap.h>
#include <linux/pagemap.h>
#include <linux/pagevec.h>
@@ -25,6 +26,8 @@
#include "internal.h"
+static struct bio_set iomap_ioend_bioset;
+
/*
* Execute a iomap write on a segment of the mapping that spans a
* contiguous range of pages that have identical block mapping state.
@@ -2192,3 +2195,526 @@ iomap_bmap(struct address_space *mapping, sector_t bno,
return bno;
}
EXPORT_SYMBOL_GPL(iomap_bmap);
+
+static void
+iomap_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);
+ }
+
+ WARN_ON_ONCE(i_blocksize(inode) < PAGE_SIZE && !iop);
+ WARN_ON_ONCE(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.
+ */
+void
+iomap_finish_ioend(struct iomap_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)
+ iomap_finish_page_writeback(inode, bvec, error);
+ bio_put(bio);
+ }
+
+ if (unlikely(error && !quiet)) {
+ printk_ratelimited(KERN_ERR
+ "%s: writeback error on sector %llu",
+ inode->i_sb->s_id, start);
+ }
+}
+EXPORT_SYMBOL_GPL(iomap_finish_ioend);
+
+void
+iomap_finish_ioends(struct iomap_ioend *ioend, int error)
+{
+ struct list_head tmp;
+
+ list_replace_init(&ioend->io_list, &tmp);
+ iomap_finish_ioend(ioend, error);
+ while ((ioend = list_pop_entry(&tmp, struct iomap_ioend, io_list)))
+ iomap_finish_ioend(ioend, error);
+}
+EXPORT_SYMBOL_GPL(iomap_finish_ioends);
+
+/*
+ * We can merge two adjacent ioends if they have the same set of work to do.
+ */
+static bool
+iomap_ioend_can_merge(struct iomap_ioend *ioend, struct iomap_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;
+}
+
+void
+iomap_ioend_try_merge(struct iomap_ioend *ioend, struct list_head *more_ioends,
+ void (*merge_private)(struct iomap_ioend *ioend,
+ struct iomap_ioend *next))
+{
+ struct iomap_ioend *next;
+
+ INIT_LIST_HEAD(&ioend->io_list);
+
+ while ((next = list_first_entry_or_null(more_ioends, struct iomap_ioend,
+ io_list))) {
+ if (!iomap_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 && merge_private)
+ merge_private(ioend, next);
+ }
+}
+EXPORT_SYMBOL_GPL(iomap_ioend_try_merge);
+
+static int
+iomap_ioend_compare(void *priv, struct list_head *a, struct list_head *b)
+{
+ struct iomap_ioend *ia, *ib;
+
+ ia = container_of(a, struct iomap_ioend, io_list);
+ ib = container_of(b, struct iomap_ioend, io_list);
+ if (ia->io_offset < ib->io_offset)
+ return -1;
+ else if (ia->io_offset > ib->io_offset)
+ return 1;
+ return 0;
+}
+
+void
+iomap_sort_ioends(struct list_head *ioend_list)
+{
+ list_sort(NULL, ioend_list, iomap_ioend_compare);
+}
+EXPORT_SYMBOL_GPL(iomap_sort_ioends);
+
+/*
+ * 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 @error 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
+iomap_submit_ioend(struct iomap_writepage_ctx *wpc, struct iomap_ioend *ioend,
+ int error)
+{
+ /*
+ * 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.
+ */
+ ioend->io_bio->bi_private = ioend;
+ error = wpc->ops->submit_ioend(ioend, error);
+ if (error) {
+ ioend->io_bio->bi_status = errno_to_blk_status(error);
+ bio_endio(ioend->io_bio);
+ return error;
+ }
+
+ submit_bio(ioend->io_bio);
+ return 0;
+}
+
+static struct iomap_ioend *
+iomap_alloc_ioend(struct inode *inode, struct iomap_writepage_ctx *wpc,
+ loff_t offset, sector_t sector, struct writeback_control *wbc)
+{
+ struct iomap_ioend *ioend;
+ struct bio *bio;
+
+ bio = bio_alloc_bioset(GFP_NOFS, BIO_MAX_PAGES, &iomap_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 iomap_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 iomap_finish_ioend().
+ */
+static struct bio *
+iomap_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 iomap_finish_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
+iomap_add_to_ioend(struct inode *inode, loff_t offset, struct page *page,
+ struct iomap_page *iop, struct iomap_writepage_ctx *wpc,
+ struct writeback_control *wbc, struct list_head *iolist)
+{
+ unsigned len = i_blocksize(inode);
+ unsigned poff = offset & (PAGE_SIZE - 1);
+ sector_t sector = iomap_sector(&wpc->iomap, offset);
+
+ 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 = iomap_alloc_ioend(inode, wpc, offset, sector, wbc);
+ }
+
+ if (!__bio_try_merge_page(wpc->ioend->io_bio, page, len, poff, true)) {
+ if (iop)
+ atomic_inc(&iop->write_count);
+ if (bio_full(wpc->ioend->io_bio)) {
+ wpc->ioend->io_bio =
+ iomap_chain_bio(wpc->ioend->io_bio);
+ }
+ bio_add_page(wpc->ioend->io_bio, page, len, poff);
+ }
+
+ wpc->ioend->io_size += len;
+ wbc_account_io(wbc, page, len);
+}
+
+/*
+ * 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
+iomap_writepage_map(struct iomap_writepage_ctx *wpc,
+ struct writeback_control *wbc, struct inode *inode,
+ struct page *page, u64 end_offset)
+{
+ struct iomap_page *iop = to_iomap_page(page);
+ struct iomap_ioend *ioend, *next;
+ unsigned len = i_blocksize(inode);
+ u64 file_offset; /* file offset of page */
+ int error = 0, count = 0, i;
+ LIST_HEAD(submit_list);
+
+ WARN_ON_ONCE(i_blocksize(inode) < PAGE_SIZE && !iop);
+ WARN_ON_ONCE(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 = wpc->ops->map_blocks(wpc, inode, file_offset);
+ if (error)
+ break;
+ if (wpc->iomap.type == IOMAP_HOLE)
+ continue;
+ iomap_add_to_ioend(inode, file_offset, page, iop, wpc, wbc,
+ &submit_list);
+ count++;
+ }
+
+ WARN_ON_ONCE(!wpc->ioend && !list_empty(&submit_list));
+ WARN_ON_ONCE(!PageLocked(page));
+ WARN_ON_ONCE(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) {
+ wpc->ops->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 = iomap_submit_ioend(wpc, 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;
+}
+
+/*
+ * 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
+iomap_do_writepage(struct page *page, struct writeback_control *wbc, void *data)
+{
+ struct iomap_writepage_ctx *wpc = data;
+ struct inode *inode = page->mapping->host;
+ pgoff_t end_index;
+ u64 end_offset;
+ loff_t offset;
+
+ /*
+ * 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 = (loff_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
+ * iomap_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 iomap_writepage_map(wpc, wbc, inode, page, end_offset);
+
+redirty:
+ redirty_page_for_writepage(wbc, page);
+ unlock_page(page);
+ return 0;
+}
+
+int
+iomap_writepage(struct page *page, struct writeback_control *wbc,
+ struct iomap_writepage_ctx *wpc,
+ const struct iomap_writeback_ops *ops)
+{
+ int ret;
+
+ wpc->ops = ops;
+ ret = iomap_do_writepage(page, wbc, wpc);
+ if (!wpc->ioend)
+ return ret;
+ return iomap_submit_ioend(wpc, wpc->ioend, ret);
+}
+EXPORT_SYMBOL_GPL(iomap_writepage);
+
+int
+iomap_writepages(struct address_space *mapping, struct writeback_control *wbc,
+ struct iomap_writepage_ctx *wpc,
+ const struct iomap_writeback_ops *ops)
+{
+ int ret;
+
+ wpc->ops = ops;
+ ret = write_cache_pages(mapping, wbc, iomap_do_writepage, wpc);
+ if (!wpc->ioend)
+ return ret;
+ return iomap_submit_ioend(wpc, wpc->ioend, ret);
+}
+EXPORT_SYMBOL_GPL(iomap_writepages);
+
+static int __init iomap_init(void)
+{
+ return bioset_init(&iomap_ioend_bioset, 4 * (PAGE_SIZE / SECTOR_SIZE),
+ offsetof(struct iomap_ioend, io_inline_bio),
+ BIOSET_NEED_BVECS);
+}
+fs_initcall(iomap_init);
diff --git a/fs/xfs/xfs_aops.c b/fs/xfs/xfs_aops.c
index 8afefe744471..072750f34fe6 100644
--- a/fs/xfs/xfs_aops.c
+++ b/fs/xfs/xfs_aops.c
@@ -23,16 +23,18 @@
#include "xfs_reflink.h"
#include <linux/writeback.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)
@@ -59,84 +61,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;
@@ -144,7 +72,7 @@ static inline bool xfs_ioend_is_append(struct xfs_ioend *ioend)
STATIC int
xfs_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;
@@ -217,7 +145,7 @@ xfs_setfilesize(
STATIC int
xfs_setfilesize_ioend(
- struct xfs_ioend *ioend,
+ struct iomap_ioend *ioend,
int error)
{
struct xfs_inode *ip = XFS_I(ioend->io_inode);
@@ -245,7 +173,7 @@ xfs_setfilesize_ioend(
*/
STATIC void
xfs_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;
@@ -291,31 +219,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
@@ -324,8 +231,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;
@@ -335,53 +242,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(
@@ -389,7 +249,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;
@@ -397,9 +257,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);
}
}
@@ -408,7 +268,7 @@ STATIC void
xfs_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;
@@ -423,7 +283,7 @@ xfs_end_bio(
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));
+ iomap_finish_ioend(ioend, blk_status_to_errno(bio->bi_status));
}
/*
@@ -432,7 +292,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)
{
@@ -454,10 +314,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;
}
@@ -472,12 +332,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
@@ -487,8 +353,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);
@@ -496,9 +361,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)
{
@@ -554,7 +419,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;
@@ -577,7 +442,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? */
@@ -641,24 +506,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;
@@ -686,121 +536,8 @@ xfs_submit_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)
-{
- unsigned len = i_blocksize(inode);
- unsigned poff = offset & (PAGE_SIZE - 1);
- sector_t sector;
-
- sector = (wpc->iomap.addr + offset - wpc->iomap.offset) >> 9;
-
- 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);
- }
-
- if (!__bio_try_merge_page(wpc->ioend->io_bio, page, len, poff, true)) {
- if (iop)
- atomic_inc(&iop->write_count);
- if (bio_full(wpc->ioend->io_bio))
- 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_io(wbc, page, len);
+ return status;
}
STATIC void
@@ -824,8 +561,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;
@@ -850,243 +587,11 @@ xfs_aops_discard_page(
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;
-}
-
-/*
- * 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(
@@ -1094,12 +599,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
@@ -1108,13 +609,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
diff --git a/fs/xfs/xfs_aops.h b/fs/xfs/xfs_aops.h
index 4a0226cdad4f..687b11f34fa2 100644
--- a/fs/xfs/xfs_aops.h
+++ b/fs/xfs/xfs_aops.h
@@ -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;
diff --git a/fs/xfs/xfs_super.c b/fs/xfs/xfs_super.c
index 94fd0a6e3842..fc76bd27d9f3 100644
--- a/fs/xfs/xfs_super.c
+++ b/fs/xfs/xfs_super.c
@@ -53,7 +53,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
@@ -1863,15 +1862,10 @@ MODULE_ALIAS_FS("xfs");
STATIC int __init
xfs_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),
@@ -2006,8 +2000,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;
}
@@ -2038,7 +2030,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
diff --git a/include/linux/iomap.h b/include/linux/iomap.h
index 2103b94cb1bf..9dea3b1c8217 100644
--- a/include/linux/iomap.h
+++ b/include/linux/iomap.h
@@ -4,6 +4,7 @@
#include <linux/atomic.h>
#include <linux/bitmap.h>
+#include <linux/blk_types.h>
#include <linux/mm.h>
#include <linux/types.h>
#include <linux/mm_types.h>
@@ -11,6 +12,7 @@
struct address_space;
struct fiemap_extent_info;
struct inode;
+struct iomap_writepage_ctx;
struct iov_iter;
struct kiocb;
struct page;
@@ -165,6 +167,48 @@ loff_t iomap_seek_data(struct inode *inode, loff_t offset,
sector_t iomap_bmap(struct address_space *mapping, sector_t bno,
const struct iomap_ops *ops);
+/*
+ * Structure for writeback I/O completions.
+ */
+struct iomap_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 */
+ loff_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! */
+};
+
+struct iomap_writeback_ops {
+ int (*map_blocks)(struct iomap_writepage_ctx *wpc, struct inode *inode,
+ loff_t offset);
+ int (*submit_ioend)(struct iomap_ioend *ioend, int status);
+ void (*discard_page)(struct page *page);
+};
+
+struct iomap_writepage_ctx {
+ struct iomap iomap;
+ struct iomap_ioend *ioend;
+ const struct iomap_writeback_ops *ops;
+};
+
+void iomap_finish_ioend(struct iomap_ioend *ioend, int error);
+void iomap_finish_ioends(struct iomap_ioend *ioend, int error);
+void iomap_ioend_try_merge(struct iomap_ioend *ioend,
+ struct list_head *more_ioends,
+ void (*merge_private)(struct iomap_ioend *ioend,
+ struct iomap_ioend *next));
+void iomap_sort_ioends(struct list_head *ioend_list);
+int iomap_writepage(struct page *page, struct writeback_control *wbc,
+ struct iomap_writepage_ctx *wpc,
+ const struct iomap_writeback_ops *ops);
+int iomap_writepages(struct address_space *mapping,
+ struct writeback_control *wbc, struct iomap_writepage_ctx *wpc,
+ const struct iomap_writeback_ops *ops);
+
/*
* Flags for direct I/O ->end_io:
*/
--
2.20.1
^ permalink raw reply related [flat|nested] 28+ messages in thread
* [PATCH 13/13] iomap: add tracing for the address space operations
2019-06-27 10:48 lift the xfs writepage code into iomap v2 Christoph Hellwig
` (11 preceding siblings ...)
2019-06-27 10:48 ` [PATCH 12/13] iomap: move the xfs writeback code to iomap.c Christoph Hellwig
@ 2019-06-27 10:48 ` Christoph Hellwig
2019-06-28 1:32 ` lift the xfs writepage code into iomap v2 Darrick J. Wong
13 siblings, 0 replies; 28+ messages in thread
From: Christoph Hellwig @ 2019-06-27 10:48 UTC (permalink / raw)
To: Darrick J . Wong
Cc: Damien Le Moal, Andreas Gruenbacher, linux-xfs, linux-fsdevel,
linux-kernel
Lift the xfs code for tracing address space operations to the iomap
layer.
Signed-off-by: Christoph Hellwig <hch@lst.de>
---
fs/iomap.c | 13 +++++-
fs/xfs/xfs_aops.c | 27 ++----------
fs/xfs/xfs_trace.h | 65 ---------------------------
include/trace/events/iomap.h | 85 ++++++++++++++++++++++++++++++++++++
4 files changed, 100 insertions(+), 90 deletions(-)
create mode 100644 include/trace/events/iomap.h
diff --git a/fs/iomap.c b/fs/iomap.c
index bb5c42561398..5db939468499 100644
--- a/fs/iomap.c
+++ b/fs/iomap.c
@@ -23,7 +23,8 @@
#include <linux/task_io_accounting_ops.h>
#include <linux/dax.h>
#include <linux/sched/signal.h>
-
+#define CREATE_TRACE_POINTS
+#include <trace/events/iomap.h>
#include "internal.h"
static struct bio_set iomap_ioend_bioset;
@@ -369,6 +370,8 @@ iomap_readpage(struct page *page, const struct iomap_ops *ops)
unsigned poff;
loff_t ret;
+ trace_iomap_readpage(page->mapping->host, 1);
+
for (poff = 0; poff < PAGE_SIZE; poff += ret) {
ret = iomap_apply(inode, page_offset(page) + poff,
PAGE_SIZE - poff, 0, ops, &ctx,
@@ -465,6 +468,8 @@ iomap_readpages(struct address_space *mapping, struct list_head *pages,
loff_t last = page_offset(list_entry(pages->next, struct page, lru));
loff_t length = last - pos + PAGE_SIZE, ret = 0;
+ trace_iomap_readpages(mapping->host, nr_pages);
+
while (length > 0) {
ret = iomap_apply(mapping->host, pos, length, 0, ops,
&ctx, iomap_readpages_actor);
@@ -531,6 +536,8 @@ EXPORT_SYMBOL_GPL(iomap_is_partially_uptodate);
int
iomap_releasepage(struct page *page, gfp_t gfp_mask)
{
+ trace_iomap_releasepage(page->mapping->host, page, 0, 0);
+
/*
* mm accommodates an old ext3 case where clean pages might not have had
* the dirty bit cleared. Thus, it can send actual dirty pages to
@@ -546,6 +553,8 @@ EXPORT_SYMBOL_GPL(iomap_releasepage);
void
iomap_invalidatepage(struct page *page, unsigned int offset, unsigned int len)
{
+ trace_iomap_invalidatepage(page->mapping->host, page, offset, len);
+
/*
* If we are invalidating the entire page, clear the dirty state from it
* and release it to avoid unnecessary buildup of the LRU.
@@ -2586,6 +2595,8 @@ iomap_do_writepage(struct page *page, struct writeback_control *wbc, void *data)
u64 end_offset;
loff_t offset;
+ trace_iomap_writepage(inode, page, 0, 0);
+
/*
* Refuse to write the page out if we are called from reclaim context.
*
diff --git a/fs/xfs/xfs_aops.c b/fs/xfs/xfs_aops.c
index 072750f34fe6..bdcde2ece779 100644
--- a/fs/xfs/xfs_aops.c
+++ b/fs/xfs/xfs_aops.c
@@ -540,16 +540,6 @@ xfs_submit_ioend(
return status;
}
-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 the page has delalloc blocks on it, we need to punch them out before we
* invalidate the page. If we don't, we leave a stale delalloc mapping on the
@@ -584,7 +574,7 @@ xfs_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);
+ iomap_invalidatepage(page, 0, PAGE_SIZE);
}
static const struct iomap_writeback_ops xfs_writeback_ops = {
@@ -624,15 +614,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,
@@ -661,7 +642,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);
}
@@ -672,7 +652,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);
}
@@ -692,8 +671,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,
diff --git a/fs/xfs/xfs_trace.h b/fs/xfs/xfs_trace.h
index 65c920554b96..c44dadb6faba 100644
--- a/fs/xfs/xfs_trace.h
+++ b/fs/xfs/xfs_trace.h
@@ -1153,71 +1153,6 @@ DEFINE_RW_EVENT(xfs_file_buffered_write);
DEFINE_RW_EVENT(xfs_file_direct_write);
DEFINE_RW_EVENT(xfs_file_dax_write);
-DECLARE_EVENT_CLASS(xfs_page_class,
- TP_PROTO(struct inode *inode, struct page *page, unsigned long off,
- unsigned int len),
- TP_ARGS(inode, page, off, len),
- TP_STRUCT__entry(
- __field(dev_t, dev)
- __field(xfs_ino_t, ino)
- __field(pgoff_t, pgoff)
- __field(loff_t, size)
- __field(unsigned long, offset)
- __field(unsigned int, length)
- ),
- TP_fast_assign(
- __entry->dev = inode->i_sb->s_dev;
- __entry->ino = XFS_I(inode)->i_ino;
- __entry->pgoff = page_offset(page);
- __entry->size = i_size_read(inode);
- __entry->offset = off;
- __entry->length = len;
- ),
- TP_printk("dev %d:%d ino 0x%llx pgoff 0x%lx size 0x%llx offset %lx "
- "length %x",
- MAJOR(__entry->dev), MINOR(__entry->dev),
- __entry->ino,
- __entry->pgoff,
- __entry->size,
- __entry->offset,
- __entry->length)
-)
-
-#define DEFINE_PAGE_EVENT(name) \
-DEFINE_EVENT(xfs_page_class, name, \
- TP_PROTO(struct inode *inode, struct page *page, unsigned long off, \
- unsigned int len), \
- TP_ARGS(inode, page, off, len))
-DEFINE_PAGE_EVENT(xfs_writepage);
-DEFINE_PAGE_EVENT(xfs_releasepage);
-DEFINE_PAGE_EVENT(xfs_invalidatepage);
-
-DECLARE_EVENT_CLASS(xfs_readpage_class,
- TP_PROTO(struct inode *inode, int nr_pages),
- TP_ARGS(inode, nr_pages),
- TP_STRUCT__entry(
- __field(dev_t, dev)
- __field(xfs_ino_t, ino)
- __field(int, nr_pages)
- ),
- TP_fast_assign(
- __entry->dev = inode->i_sb->s_dev;
- __entry->ino = inode->i_ino;
- __entry->nr_pages = nr_pages;
- ),
- TP_printk("dev %d:%d ino 0x%llx nr_pages %d",
- MAJOR(__entry->dev), MINOR(__entry->dev),
- __entry->ino,
- __entry->nr_pages)
-)
-
-#define DEFINE_READPAGE_EVENT(name) \
-DEFINE_EVENT(xfs_readpage_class, name, \
- TP_PROTO(struct inode *inode, int nr_pages), \
- TP_ARGS(inode, nr_pages))
-DEFINE_READPAGE_EVENT(xfs_vm_readpage);
-DEFINE_READPAGE_EVENT(xfs_vm_readpages);
-
DECLARE_EVENT_CLASS(xfs_imap_class,
TP_PROTO(struct xfs_inode *ip, xfs_off_t offset, ssize_t count,
int whichfork, struct xfs_bmbt_irec *irec),
diff --git a/include/trace/events/iomap.h b/include/trace/events/iomap.h
new file mode 100644
index 000000000000..1da90e743e6e
--- /dev/null
+++ b/include/trace/events/iomap.h
@@ -0,0 +1,85 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Copyright (c) 2009-2019, Christoph Hellwig
+ * All Rights Reserved.
+ *
+ * NOTE: none of these tracepoints shall be consider a stable kernel ABI
+ * as they can change at any time.
+ */
+#undef TRACE_SYSTEM
+#define TRACE_SYSTEM iomap
+
+#if !defined(_TRACE_IOMAP_H) || defined(TRACE_HEADER_MULTI_READ)
+#define _TRACE_IOMAP_H
+
+#include <linux/tracepoint.h>
+
+DECLARE_EVENT_CLASS(iomap_page_class,
+ TP_PROTO(struct inode *inode, struct page *page, unsigned long off,
+ unsigned int len),
+ TP_ARGS(inode, page, off, len),
+ TP_STRUCT__entry(
+ __field(dev_t, dev)
+ __field(u64, ino)
+ __field(pgoff_t, pgoff)
+ __field(loff_t, size)
+ __field(unsigned long, offset)
+ __field(unsigned int, length)
+ ),
+ TP_fast_assign(
+ __entry->dev = inode->i_sb->s_dev;
+ __entry->ino = inode->i_ino;
+ __entry->pgoff = page_offset(page);
+ __entry->size = i_size_read(inode);
+ __entry->offset = off;
+ __entry->length = len;
+ ),
+ TP_printk("dev %d:%d ino 0x%llx pgoff 0x%lx size 0x%llx offset %lx "
+ "length %x",
+ MAJOR(__entry->dev), MINOR(__entry->dev),
+ __entry->ino,
+ __entry->pgoff,
+ __entry->size,
+ __entry->offset,
+ __entry->length)
+)
+
+#define DEFINE_PAGE_EVENT(name) \
+DEFINE_EVENT(iomap_page_class, name, \
+ TP_PROTO(struct inode *inode, struct page *page, unsigned long off, \
+ unsigned int len), \
+ TP_ARGS(inode, page, off, len))
+DEFINE_PAGE_EVENT(iomap_writepage);
+DEFINE_PAGE_EVENT(iomap_releasepage);
+DEFINE_PAGE_EVENT(iomap_invalidatepage);
+
+DECLARE_EVENT_CLASS(iomap_readpage_class,
+ TP_PROTO(struct inode *inode, int nr_pages),
+ TP_ARGS(inode, nr_pages),
+ TP_STRUCT__entry(
+ __field(dev_t, dev)
+ __field(u64, ino)
+ __field(int, nr_pages)
+ ),
+ TP_fast_assign(
+ __entry->dev = inode->i_sb->s_dev;
+ __entry->ino = inode->i_ino;
+ __entry->nr_pages = nr_pages;
+ ),
+ TP_printk("dev %d:%d ino 0x%llx nr_pages %d",
+ MAJOR(__entry->dev), MINOR(__entry->dev),
+ __entry->ino,
+ __entry->nr_pages)
+)
+
+#define DEFINE_READPAGE_EVENT(name) \
+DEFINE_EVENT(iomap_readpage_class, name, \
+ TP_PROTO(struct inode *inode, int nr_pages), \
+ TP_ARGS(inode, nr_pages))
+DEFINE_READPAGE_EVENT(iomap_readpage);
+DEFINE_READPAGE_EVENT(iomap_readpages);
+
+#endif /* _TRACE_IOMAP_H */
+
+/* This part must be outside protection */
+#include <trace/define_trace.h>
--
2.20.1
^ permalink raw reply related [flat|nested] 28+ messages in thread
* Re: [PATCH 02/13] xfs: remove the unused xfs_count_page_state declaration
2019-06-27 10:48 ` [PATCH 02/13] xfs: remove the unused xfs_count_page_state declaration Christoph Hellwig
@ 2019-06-27 17:50 ` Darrick J. Wong
0 siblings, 0 replies; 28+ messages in thread
From: Darrick J. Wong @ 2019-06-27 17:50 UTC (permalink / raw)
To: Christoph Hellwig
Cc: Damien Le Moal, Andreas Gruenbacher, linux-xfs, linux-fsdevel,
linux-kernel
On Thu, Jun 27, 2019 at 12:48:25PM +0200, Christoph Hellwig wrote:
> Signed-off-by: Christoph Hellwig <hch@lst.de>
Looks ok,
Reviewed-by: Darrick J. Wong <darrick.wong@oracle.com>
--D
> ---
> fs/xfs/xfs_aops.h | 1 -
> 1 file changed, 1 deletion(-)
>
> diff --git a/fs/xfs/xfs_aops.h b/fs/xfs/xfs_aops.h
> index f62b03186c62..45a1ea240cbb 100644
> --- a/fs/xfs/xfs_aops.h
> +++ b/fs/xfs/xfs_aops.h
> @@ -28,7 +28,6 @@ extern const struct address_space_operations xfs_dax_aops;
>
> int xfs_setfilesize(struct xfs_inode *ip, xfs_off_t offset, size_t size);
>
> -extern void xfs_count_page_state(struct page *, int *, int *);
> extern struct block_device *xfs_find_bdev_for_inode(struct inode *);
> extern struct dax_device *xfs_find_daxdev_for_inode(struct inode *);
>
> --
> 2.20.1
>
^ permalink raw reply [flat|nested] 28+ messages in thread
* Re: [PATCH 07/13] xfs: allow merging ioends over append boundaries
2019-06-27 10:48 ` [PATCH 07/13] xfs: allow merging ioends over append boundaries Christoph Hellwig
@ 2019-06-27 18:23 ` Darrick J. Wong
2019-06-27 21:43 ` Luis Chamberlain
2019-06-28 5:51 ` Christoph Hellwig
0 siblings, 2 replies; 28+ messages in thread
From: Darrick J. Wong @ 2019-06-27 18:23 UTC (permalink / raw)
To: Christoph Hellwig
Cc: Damien Le Moal, Andreas Gruenbacher, linux-xfs, linux-fsdevel,
linux-kernel
On Thu, Jun 27, 2019 at 12:48:30PM +0200, Christoph Hellwig wrote:
> There is no real problem merging ioends that go beyond i_size into an
> ioend that doesn't. We just need to move the append transaction to the
> base ioend. Also use the opportunity to use a real error code instead
> of the magic 1 to cancel the transactions, and write a comment
> explaining the scheme.
>
> Signed-off-by: Christoph Hellwig <hch@lst.de>
Reading through this patch, I have a feeling it fixes the crash that
Zorro has been seeing occasionally with generic/475...
Reviewed-by: Darrick J. Wong <darrick.wong@oracle.com>
--D
> ---
> fs/xfs/xfs_aops.c | 28 +++++++++++++++++++++-------
> 1 file changed, 21 insertions(+), 7 deletions(-)
>
> diff --git a/fs/xfs/xfs_aops.c b/fs/xfs/xfs_aops.c
> index 8b3070a40245..4ef8343c3759 100644
> --- a/fs/xfs/xfs_aops.c
> +++ b/fs/xfs/xfs_aops.c
> @@ -314,11 +314,28 @@ xfs_ioend_can_merge(
> return false;
> if (ioend->io_offset + ioend->io_size != next->io_offset)
> return false;
> - if (xfs_ioend_is_append(ioend) != xfs_ioend_is_append(next))
> - 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
> + * has one. If it already has one we can simply cancel the transaction
> + * as it is guaranteed to be clean.
> + */
> +static void
> +xfs_ioend_merge_append_transactions(
> + 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;
> + } else {
> + xfs_setfilesize_ioend(next, -ECANCELED);
> + }
> +}
> +
> /* Try to merge adjacent completions. */
> STATIC void
> xfs_ioend_try_merge(
> @@ -327,7 +344,6 @@ xfs_ioend_try_merge(
> {
> struct xfs_ioend *next_ioend;
> int ioend_error;
> - int error;
>
> if (list_empty(more_ioends))
> return;
> @@ -341,10 +357,8 @@ xfs_ioend_try_merge(
> break;
> list_move_tail(&next_ioend->io_list, &ioend->io_list);
> ioend->io_size += next_ioend->io_size;
> - if (ioend->io_append_trans) {
> - error = xfs_setfilesize_ioend(next_ioend, 1);
> - ASSERT(error == 1);
> - }
> + if (next_ioend->io_append_trans)
> + xfs_ioend_merge_append_transactions(ioend, next_ioend);
> }
> }
>
> --
> 2.20.1
>
^ permalink raw reply [flat|nested] 28+ messages in thread
* Re: [PATCH 04/13] xfs: initialize iomap->flags in xfs_bmbt_to_iomap
2019-06-27 10:48 ` [PATCH 04/13] xfs: initialize iomap->flags in xfs_bmbt_to_iomap Christoph Hellwig
@ 2019-06-27 20:44 ` Darrick J. Wong
0 siblings, 0 replies; 28+ messages in thread
From: Darrick J. Wong @ 2019-06-27 20:44 UTC (permalink / raw)
To: Christoph Hellwig
Cc: Damien Le Moal, Andreas Gruenbacher, linux-xfs, linux-fsdevel,
linux-kernel
On Thu, Jun 27, 2019 at 12:48:27PM +0200, Christoph Hellwig wrote:
> Currently we don't overwrite the flags field in the iomap in
> xfs_bmbt_to_iomap. This works fine with 0-initialized iomaps on stack,
> but is harmful once we want to be able to reuse an iomap in the
> writeback code. Replace the shared paramter with a set of initial
> flags an thus ensures the flags field is always reinitialized.
>
> Signed-off-by: Christoph Hellwig <hch@lst.de>
Looks ok,
Reviewed-by: Darrick J. Wong <darrick.wong@oracle.com>
--D
> ---
> fs/xfs/xfs_iomap.c | 28 +++++++++++++++++-----------
> fs/xfs/xfs_iomap.h | 2 +-
> fs/xfs/xfs_pnfs.c | 2 +-
> 3 files changed, 19 insertions(+), 13 deletions(-)
>
> diff --git a/fs/xfs/xfs_iomap.c b/fs/xfs/xfs_iomap.c
> index 63d323916bba..6b29452bfba0 100644
> --- a/fs/xfs/xfs_iomap.c
> +++ b/fs/xfs/xfs_iomap.c
> @@ -57,7 +57,7 @@ xfs_bmbt_to_iomap(
> struct xfs_inode *ip,
> struct iomap *iomap,
> struct xfs_bmbt_irec *imap,
> - bool shared)
> + u16 flags)
> {
> struct xfs_mount *mp = ip->i_mount;
>
> @@ -82,12 +82,11 @@ xfs_bmbt_to_iomap(
> iomap->length = XFS_FSB_TO_B(mp, imap->br_blockcount);
> iomap->bdev = xfs_find_bdev_for_inode(VFS_I(ip));
> iomap->dax_dev = xfs_find_daxdev_for_inode(VFS_I(ip));
> + iomap->flags = flags;
>
> if (xfs_ipincount(ip) &&
> (ip->i_itemp->ili_fsync_fields & ~XFS_ILOG_TIMESTAMP))
> iomap->flags |= IOMAP_F_DIRTY;
> - if (shared)
> - iomap->flags |= IOMAP_F_SHARED;
> return 0;
> }
>
> @@ -543,6 +542,7 @@ xfs_file_iomap_begin_delay(
> struct xfs_iext_cursor icur, ccur;
> xfs_fsblock_t prealloc_blocks = 0;
> bool eof = false, cow_eof = false, shared = false;
> + u16 iomap_flags = 0;
> int whichfork = XFS_DATA_FORK;
> int error = 0;
>
> @@ -710,7 +710,7 @@ xfs_file_iomap_begin_delay(
> * Flag newly allocated delalloc blocks with IOMAP_F_NEW so we punch
> * them out if the write happens to fail.
> */
> - iomap->flags |= IOMAP_F_NEW;
> + iomap_flags |= IOMAP_F_NEW;
> trace_xfs_iomap_alloc(ip, offset, count, whichfork,
> whichfork == XFS_DATA_FORK ? &imap : &cmap);
> done:
> @@ -718,14 +718,17 @@ xfs_file_iomap_begin_delay(
> if (imap.br_startoff > offset_fsb) {
> xfs_trim_extent(&cmap, offset_fsb,
> imap.br_startoff - offset_fsb);
> - error = xfs_bmbt_to_iomap(ip, iomap, &cmap, true);
> + error = xfs_bmbt_to_iomap(ip, iomap, &cmap,
> + IOMAP_F_SHARED);
> goto out_unlock;
> }
> /* ensure we only report blocks we have a reservation for */
> xfs_trim_extent(&imap, cmap.br_startoff, cmap.br_blockcount);
> shared = true;
> }
> - error = xfs_bmbt_to_iomap(ip, iomap, &imap, shared);
> + if (shared)
> + iomap_flags |= IOMAP_F_SHARED;
> + error = xfs_bmbt_to_iomap(ip, iomap, &imap, iomap_flags);
> out_unlock:
> xfs_iunlock(ip, XFS_ILOCK_EXCL);
> return error;
> @@ -933,6 +936,7 @@ xfs_file_iomap_begin(
> xfs_fileoff_t offset_fsb, end_fsb;
> int nimaps = 1, error = 0;
> bool shared = false;
> + u16 iomap_flags = 0;
> unsigned lockmode;
>
> if (XFS_FORCED_SHUTDOWN(mp))
> @@ -1048,11 +1052,13 @@ xfs_file_iomap_begin(
> if (error)
> return error;
>
> - iomap->flags |= IOMAP_F_NEW;
> + iomap_flags |= IOMAP_F_NEW;
> trace_xfs_iomap_alloc(ip, offset, length, XFS_DATA_FORK, &imap);
>
> out_finish:
> - return xfs_bmbt_to_iomap(ip, iomap, &imap, shared);
> + if (shared)
> + iomap_flags |= IOMAP_F_SHARED;
> + return xfs_bmbt_to_iomap(ip, iomap, &imap, iomap_flags);
>
> out_found:
> ASSERT(nimaps);
> @@ -1196,7 +1202,7 @@ xfs_seek_iomap_begin(
> if (data_fsb < cow_fsb + cmap.br_blockcount)
> end_fsb = min(end_fsb, data_fsb);
> xfs_trim_extent(&cmap, offset_fsb, end_fsb);
> - error = xfs_bmbt_to_iomap(ip, iomap, &cmap, true);
> + error = xfs_bmbt_to_iomap(ip, iomap, &cmap, IOMAP_F_SHARED);
> /*
> * This is a COW extent, so we must probe the page cache
> * because there could be dirty page cache being backed
> @@ -1218,7 +1224,7 @@ xfs_seek_iomap_begin(
> imap.br_state = XFS_EXT_NORM;
> done:
> xfs_trim_extent(&imap, offset_fsb, end_fsb);
> - error = xfs_bmbt_to_iomap(ip, iomap, &imap, false);
> + error = xfs_bmbt_to_iomap(ip, iomap, &imap, 0);
> out_unlock:
> xfs_iunlock(ip, lockmode);
> return error;
> @@ -1264,7 +1270,7 @@ xfs_xattr_iomap_begin(
> if (error)
> return error;
> ASSERT(nimaps);
> - return xfs_bmbt_to_iomap(ip, iomap, &imap, false);
> + return xfs_bmbt_to_iomap(ip, iomap, &imap, 0);
> }
>
> const struct iomap_ops xfs_xattr_iomap_ops = {
> diff --git a/fs/xfs/xfs_iomap.h b/fs/xfs/xfs_iomap.h
> index 5c2f6aa6d78f..71d0ae460c44 100644
> --- a/fs/xfs/xfs_iomap.h
> +++ b/fs/xfs/xfs_iomap.h
> @@ -16,7 +16,7 @@ int xfs_iomap_write_direct(struct xfs_inode *, xfs_off_t, size_t,
> int xfs_iomap_write_unwritten(struct xfs_inode *, xfs_off_t, xfs_off_t, bool);
>
> int xfs_bmbt_to_iomap(struct xfs_inode *, struct iomap *,
> - struct xfs_bmbt_irec *, bool shared);
> + struct xfs_bmbt_irec *, u16);
> xfs_extlen_t xfs_eof_alignment(struct xfs_inode *ip, xfs_extlen_t extsize);
>
> static inline xfs_filblks_t
> diff --git a/fs/xfs/xfs_pnfs.c b/fs/xfs/xfs_pnfs.c
> index 2d95355a8a0a..97cdb57e58bc 100644
> --- a/fs/xfs/xfs_pnfs.c
> +++ b/fs/xfs/xfs_pnfs.c
> @@ -186,7 +186,7 @@ xfs_fs_map_blocks(
> }
> xfs_iunlock(ip, XFS_IOLOCK_EXCL);
>
> - error = xfs_bmbt_to_iomap(ip, iomap, &imap, false);
> + error = xfs_bmbt_to_iomap(ip, iomap, &imap, 0);
> *device_generation = mp->m_generation;
> return error;
> out_unlock:
> --
> 2.20.1
>
^ permalink raw reply [flat|nested] 28+ messages in thread
* Re: [PATCH 01/13] list.h: add list_pop and list_pop_entry helpers
2019-06-27 10:48 ` [PATCH 01/13] list.h: add list_pop and list_pop_entry helpers Christoph Hellwig
@ 2019-06-27 20:48 ` Darrick J. Wong
0 siblings, 0 replies; 28+ messages in thread
From: Darrick J. Wong @ 2019-06-27 20:48 UTC (permalink / raw)
To: Christoph Hellwig
Cc: Damien Le Moal, Andreas Gruenbacher, linux-xfs, linux-fsdevel,
linux-kernel
On Thu, Jun 27, 2019 at 12:48:24PM +0200, Christoph Hellwig wrote:
> We have a very common pattern where we want to delete the first entry
> from a list and return it as the properly typed container structure.
>
> Add two helpers to implement this behavior.
>
> Signed-off-by: Christoph Hellwig <hch@lst.de>
LGTM,
Reviewed-by: Darrick J. Wong <darrick.wong@oracle.com>
--D
> ---
> include/linux/list.h | 33 +++++++++++++++++++++++++++++++++
> 1 file changed, 33 insertions(+)
>
> diff --git a/include/linux/list.h b/include/linux/list.h
> index e951228db4b2..ba6e27d2235a 100644
> --- a/include/linux/list.h
> +++ b/include/linux/list.h
> @@ -500,6 +500,39 @@ static inline void list_splice_tail_init(struct list_head *list,
> pos__ != head__ ? list_entry(pos__, type, member) : NULL; \
> })
>
> +/**
> + * list_pop - delete the first entry from a list and return it
> + * @list: the list to take the element from.
> + *
> + * Return the list entry after @list. If @list is empty return NULL.
> + */
> +static inline struct list_head *list_pop(struct list_head *list)
> +{
> + struct list_head *pos = READ_ONCE(list->next);
> +
> + if (pos == list)
> + return NULL;
> + list_del(pos);
> + return pos;
> +}
> +
> +/**
> + * list_pop_entry - delete the first entry from a list and return the
> + * containing structure
> + * @list: the list to take the element from.
> + * @type: the type of the struct this is embedded in.
> + * @member: the name of the list_head within the struct.
> + *
> + * Return the containing structure for the list entry after @list. If @list
> + * is empty return NULL.
> + */
> +#define list_pop_entry(list, type, member) \
> +({ \
> + struct list_head *pos__ = list_pop(list); \
> + \
> + pos__ ? list_entry(pos__, type, member) : NULL; \
> +})
> +
> /**
> * list_next_entry - get the next element in list
> * @pos: the type * to cursor
> --
> 2.20.1
>
^ permalink raw reply [flat|nested] 28+ messages in thread
* Re: [PATCH 07/13] xfs: allow merging ioends over append boundaries
2019-06-27 18:23 ` Darrick J. Wong
@ 2019-06-27 21:43 ` Luis Chamberlain
2019-06-28 2:52 ` Zorro Lang
2019-06-28 5:51 ` Christoph Hellwig
1 sibling, 1 reply; 28+ messages in thread
From: Luis Chamberlain @ 2019-06-27 21:43 UTC (permalink / raw)
To: Darrick J. Wong, Zorro Lang, Amir Goldstein
Cc: Christoph Hellwig, Damien Le Moal, Andreas Gruenbacher,
linux-xfs, linux-fsdevel, linux-kernel
On Thu, Jun 27, 2019 at 11:23:09AM -0700, Darrick J. Wong wrote:
> On Thu, Jun 27, 2019 at 12:48:30PM +0200, Christoph Hellwig wrote:
> > There is no real problem merging ioends that go beyond i_size into an
> > ioend that doesn't. We just need to move the append transaction to the
> > base ioend. Also use the opportunity to use a real error code instead
> > of the magic 1 to cancel the transactions, and write a comment
> > explaining the scheme.
> >
> > Signed-off-by: Christoph Hellwig <hch@lst.de>
>
> Reading through this patch, I have a feeling it fixes the crash that
> Zorro has been seeing occasionally with generic/475...
>
> Reviewed-by: Darrick J. Wong <darrick.wong@oracle.com>
Zorro, can you confirm? If so it would be great to also refer to
the respective bugzilla entry #203947 [0].
[0] https://bugzilla.kernel.org/show_bug.cgi?id=203947
Luis
^ permalink raw reply [flat|nested] 28+ messages in thread
* Re: [PATCH 06/13] xfs: remove XFS_TRANS_NOFS
2019-06-27 10:48 ` [PATCH 06/13] xfs: remove XFS_TRANS_NOFS Christoph Hellwig
@ 2019-06-27 22:30 ` Darrick J. Wong
2019-06-28 5:37 ` Christoph Hellwig
0 siblings, 1 reply; 28+ messages in thread
From: Darrick J. Wong @ 2019-06-27 22:30 UTC (permalink / raw)
To: Christoph Hellwig
Cc: Damien Le Moal, Andreas Gruenbacher, linux-xfs, linux-fsdevel,
linux-kernel
On Thu, Jun 27, 2019 at 12:48:29PM +0200, Christoph Hellwig wrote:
> Instead of a magic flag for xfs_trans_alloc, just ensure all callers
> that can't relclaim through the file system use memalloc_nofs_save to
> set the per-task nofs flag.
>
> Signed-off-by: Christoph Hellwig <hch@lst.de>
> ---
> fs/xfs/libxfs/xfs_shared.h | 1 -
> fs/xfs/xfs_aops.c | 35 ++++++++++++++++++++++-------------
> fs/xfs/xfs_file.c | 12 +++++++++---
> fs/xfs/xfs_iomap.c | 2 +-
> fs/xfs/xfs_reflink.c | 4 ++--
> fs/xfs/xfs_trans.c | 4 +---
> 6 files changed, 35 insertions(+), 23 deletions(-)
>
> diff --git a/fs/xfs/libxfs/xfs_shared.h b/fs/xfs/libxfs/xfs_shared.h
> index b9094709bc79..c45acbd3add9 100644
> --- a/fs/xfs/libxfs/xfs_shared.h
> +++ b/fs/xfs/libxfs/xfs_shared.h
> @@ -65,7 +65,6 @@ void xfs_log_get_max_trans_res(struct xfs_mount *mp,
> #define XFS_TRANS_DQ_DIRTY 0x10 /* at least one dquot in trx dirty */
> #define XFS_TRANS_RESERVE 0x20 /* OK to use reserved data blocks */
> #define XFS_TRANS_NO_WRITECOUNT 0x40 /* do not elevate SB writecount */
> -#define XFS_TRANS_NOFS 0x80 /* pass KM_NOFS to kmem_alloc */
> /*
> * LOWMODE is used by the allocator to activate the lowspace algorithm - when
> * free space is running low the extent allocator may choose to allocate an
> diff --git a/fs/xfs/xfs_aops.c b/fs/xfs/xfs_aops.c
> index 243548b9d0cc..8b3070a40245 100644
> --- a/fs/xfs/xfs_aops.c
> +++ b/fs/xfs/xfs_aops.c
> @@ -138,8 +138,7 @@ xfs_setfilesize_trans_alloc(
> struct xfs_trans *tp;
> int error;
>
> - error = xfs_trans_alloc(mp, &M_RES(mp)->tr_fsyncts, 0, 0,
> - XFS_TRANS_NOFS, &tp);
> + error = xfs_trans_alloc(mp, &M_RES(mp)->tr_fsyncts, 0, 0, 0, &tp);
> if (error)
> return error;
>
> @@ -240,8 +239,16 @@ xfs_end_ioend(
> struct xfs_inode *ip = XFS_I(ioend->io_inode);
> xfs_off_t offset = ioend->io_offset;
> size_t size = ioend->io_size;
> + unsigned int nofs_flag;
> int error;
>
> + /*
> + * We can do memory allocation here, but aren't in transactional
> + * context. To avoid memory allocation deadlocks set the task-wide
> + * nofs context for the following operations.
I think the wording of this is too indirect. The reason we need to set
NOFS is because we could be doing writeback as part of reclaiming
memory, which means that we cannot recurse back into filesystems to
satisfy the memory allocation needed to create a transaction. The NOFS
part applies to any memory allocation, of course.
If you're fine with the wording below I'll just edit that into the
patch:
/*
* We can allocate memory here while doing writeback on behalf of
* memory reclaim. To avoid memory allocation deadlocks set the
* task-wide nofs context for the following operations.
*/
nofs_flag = memalloc_nofs_save();
> + */
> + nofs_flag = memalloc_nofs_save();
> +
> /*
> * Just clean up the in-memory strutures if the fs has been shut down.
> */
> @@ -282,6 +289,8 @@ xfs_end_ioend(
> list_del_init(&ioend->io_list);
> xfs_destroy_ioend(ioend, error);
> }
> +
> + memalloc_nofs_restore(nofs_flag);
> }
>
> /*
> @@ -641,21 +650,19 @@ xfs_submit_ioend(
> struct xfs_ioend *ioend,
> int status)
> {
> + unsigned int nofs_flag;
> +
> + /*
> + * We can do memory allocation here, but aren't in transactional
> + * context. To avoid memory allocation deadlocks set the task-wide
> + * nofs context for the following operations.
> + */
> + nofs_flag = memalloc_nofs_save();
> +
> /* Convert CoW extents to regular */
> if (!status && ioend->io_fork == XFS_COW_FORK) {
> - /*
> - * Yuk. This can do memory allocation, but is not a
> - * transactional operation so everything is done in GFP_KERNEL
> - * context. That can deadlock, because we hold pages in
> - * writeback state and GFP_KERNEL allocations can block on them.
> - * Hence we must operate in nofs conditions here.
> - */
> - unsigned nofs_flag;
> -
> - nofs_flag = memalloc_nofs_save();
> status = xfs_reflink_convert_cow(XFS_I(ioend->io_inode),
> ioend->io_offset, ioend->io_size);
> - memalloc_nofs_restore(nofs_flag);
> }
>
> /* Reserve log space if we might write beyond the on-disk inode size. */
> @@ -666,6 +673,8 @@ xfs_submit_ioend(
> !ioend->io_append_trans)
> 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;
>
> diff --git a/fs/xfs/xfs_file.c b/fs/xfs/xfs_file.c
> index 916a35cae5e9..f2d806ef8f06 100644
> --- a/fs/xfs/xfs_file.c
> +++ b/fs/xfs/xfs_file.c
> @@ -379,6 +379,7 @@ xfs_dio_write_end_io(
> struct inode *inode = file_inode(iocb->ki_filp);
> struct xfs_inode *ip = XFS_I(inode);
> loff_t offset = iocb->ki_pos;
> + unsigned int nofs_flag;
> int error = 0;
>
> trace_xfs_end_io_direct_write(ip, offset, size);
> @@ -395,10 +396,11 @@ xfs_dio_write_end_io(
> */
> XFS_STATS_ADD(ip->i_mount, xs_write_bytes, size);
>
> + nofs_flag = memalloc_nofs_save();
Hmm, do we need this here? I can't remember if there was a need for
setting NOFS under xfs_reflink_end_cow from a dio completion or if that
was purely the buffered writeback case...
--D
> if (flags & IOMAP_DIO_COW) {
> error = xfs_reflink_end_cow(ip, offset, size);
> if (error)
> - return error;
> + goto out;
> }
>
> /*
> @@ -407,8 +409,10 @@ xfs_dio_write_end_io(
> * earlier allows a racing dio read to find unwritten extents before
> * they are converted.
> */
> - if (flags & IOMAP_DIO_UNWRITTEN)
> - return xfs_iomap_write_unwritten(ip, offset, size, true);
> + if (flags & IOMAP_DIO_UNWRITTEN) {
> + error = xfs_iomap_write_unwritten(ip, offset, size, true);
> + goto out;
> + }
>
> /*
> * We need to update the in-core inode size here so that we don't end up
> @@ -430,6 +434,8 @@ xfs_dio_write_end_io(
> spin_unlock(&ip->i_flags_lock);
> }
>
> +out:
> + memalloc_nofs_restore(nofs_flag);
> return error;
> }
>
> diff --git a/fs/xfs/xfs_iomap.c b/fs/xfs/xfs_iomap.c
> index 6b29452bfba0..461ea023b910 100644
> --- a/fs/xfs/xfs_iomap.c
> +++ b/fs/xfs/xfs_iomap.c
> @@ -782,7 +782,7 @@ xfs_iomap_write_unwritten(
> * complete here and might deadlock on the iolock.
> */
> error = xfs_trans_alloc(mp, &M_RES(mp)->tr_write, resblks, 0,
> - XFS_TRANS_RESERVE | XFS_TRANS_NOFS, &tp);
> + XFS_TRANS_RESERVE, &tp);
> if (error)
> return error;
>
> diff --git a/fs/xfs/xfs_reflink.c b/fs/xfs/xfs_reflink.c
> index 680ae7662a78..0b23c2b29609 100644
> --- a/fs/xfs/xfs_reflink.c
> +++ b/fs/xfs/xfs_reflink.c
> @@ -572,7 +572,7 @@ xfs_reflink_cancel_cow_range(
>
> /* Start a rolling transaction to remove the mappings */
> error = xfs_trans_alloc(ip->i_mount, &M_RES(ip->i_mount)->tr_write,
> - 0, 0, XFS_TRANS_NOFS, &tp);
> + 0, 0, 0, &tp);
> if (error)
> goto out;
>
> @@ -631,7 +631,7 @@ xfs_reflink_end_cow_extent(
>
> resblks = XFS_EXTENTADD_SPACE_RES(mp, XFS_DATA_FORK);
> error = xfs_trans_alloc(mp, &M_RES(mp)->tr_write, resblks, 0,
> - XFS_TRANS_RESERVE | XFS_TRANS_NOFS, &tp);
> + XFS_TRANS_RESERVE, &tp);
> if (error)
> return error;
>
> diff --git a/fs/xfs/xfs_trans.c b/fs/xfs/xfs_trans.c
> index b026f87608ce..2ad3faa12206 100644
> --- a/fs/xfs/xfs_trans.c
> +++ b/fs/xfs/xfs_trans.c
> @@ -264,9 +264,7 @@ xfs_trans_alloc(
> * GFP_NOFS allocation context so that we avoid lockdep false positives
> * by doing GFP_KERNEL allocations inside sb_start_intwrite().
> */
> - tp = kmem_zone_zalloc(xfs_trans_zone,
> - (flags & XFS_TRANS_NOFS) ? KM_NOFS : KM_SLEEP);
> -
> + tp = kmem_zone_zalloc(xfs_trans_zone, KM_SLEEP);
> if (!(flags & XFS_TRANS_NO_WRITECOUNT))
> sb_start_intwrite(mp->m_super);
>
> --
> 2.20.1
>
^ permalink raw reply [flat|nested] 28+ messages in thread
* Re: lift the xfs writepage code into iomap v2
2019-06-27 10:48 lift the xfs writepage code into iomap v2 Christoph Hellwig
` (12 preceding siblings ...)
2019-06-27 10:48 ` [PATCH 13/13] iomap: add tracing for the address space operations Christoph Hellwig
@ 2019-06-28 1:32 ` Darrick J. Wong
2019-06-28 5:42 ` Christoph Hellwig
13 siblings, 1 reply; 28+ messages in thread
From: Darrick J. Wong @ 2019-06-28 1:32 UTC (permalink / raw)
To: Christoph Hellwig
Cc: Damien Le Moal, Andreas Gruenbacher, linux-xfs, linux-fsdevel,
linux-kernel
On Thu, Jun 27, 2019 at 12:48:23PM +0200, Christoph Hellwig wrote:
> Hi all,
>
> this series cleans up the xfs writepage code
Ok. Patches #2 and #3 are trivial so I put them in my internal branch.
By now I'm sure everyone's noticed that I suspect that patch #7 fixes
the generic/475 crash that Eryu reported, so I've added it to my
internal branch for testing.
Patch #8 is a simple cleanup so I put that one in too. If I notice any
problems with either of these two patches then I can always back them
out before the next push to for-next. I'd wanted to make those cleanups
for a while and they're more or less what I would've done.
> and then lifts it to
> fs/iomap.c so that it could be use by other file system. I've been
> wanting to 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.
Sooo many conflicted feelings on this question. :)
I agree with Christoph that sharing /high quality/ code in the kernel
has served the kernel well over the years and I want that to continue.
Sharing the lower part of our writeback code so filesystems can opt out
of writing their own code to map dirty pages to storage extents and
attach them to struct bios is (I think) a good strategy.
However, I don't think sharing crap code in the kernel is serving us
well. I dislike this recent development where we decide to wire up XFS
to some new API, beat on it aggressively, and then spend months sorting
out how to make it work the way people think it does. I do not wish to
see any of the iomap code bit rot to the point that it becomes a
nightmare to someone else.
I think Dave has voiced some valid concerns about our ability to support
this code over the long term once we start sharing it with other fses.
XFS has a longish history of sailing away from generic code so that we
can remove awkward abstractions which aren't working well for us. If
we're going to continue to go our own way with things like file locking
and mapping I wonder how long we'd keep using the iomap ioends before
moving away again. How well will that iomap code avoid bitrot once XFS
does that?
We are already past -rc6, so I think the second part of the series
(patches #10-13) is too late for 5.3. I need more time to think about
how this would work out in the scenario where (a) we take on the extra
work of ensuring that our writeback improvements don't screw things up
for everyone else, or (b) we end up forking away after a while.
To be clear, I don't have a problem with the idea of iomap containing a
common ioend creation library, but I would really like to see what it
looks like to share the code with actual users. I haven't seen any yet,
though at this early stage I am not surprised.
I think what I want to do is to proceed on a provisional basis -- create
a branch off of the next -rc1 (perhaps omitting the part that removes
xfs ioend processing) and let's see where zonedfs et. al. go from there.
How does that sound? Who are the other potential users?
> This new version should have addressed all comments from the review,
> except that I haven't split iomap.c, which is a little too invasive
> with other pending changes to the file. I do however offer to submit
> a split right at the end of the merge window when it is least invasive.
Already working on it, will send it tomorrow or tonight or something.
--D
> Changes since v1:
> - rebased to the latest xfs for-next tree
> - keep the preallocated transactions for size updates
> - rename list_pop to list_pop_entry and related cleanups
> - better document the nofs context handling
> - document that the iomap tracepoints are not a stable API
^ permalink raw reply [flat|nested] 28+ messages in thread
* Re: [PATCH 07/13] xfs: allow merging ioends over append boundaries
2019-06-27 21:43 ` Luis Chamberlain
@ 2019-06-28 2:52 ` Zorro Lang
2019-06-28 3:33 ` Darrick J. Wong
0 siblings, 1 reply; 28+ messages in thread
From: Zorro Lang @ 2019-06-28 2:52 UTC (permalink / raw)
To: Luis Chamberlain
Cc: Darrick J. Wong, Amir Goldstein, Christoph Hellwig,
Damien Le Moal, Andreas Gruenbacher, linux-xfs, linux-fsdevel,
linux-kernel
On Thu, Jun 27, 2019 at 09:43:04PM +0000, Luis Chamberlain wrote:
> On Thu, Jun 27, 2019 at 11:23:09AM -0700, Darrick J. Wong wrote:
> > On Thu, Jun 27, 2019 at 12:48:30PM +0200, Christoph Hellwig wrote:
> > > There is no real problem merging ioends that go beyond i_size into an
> > > ioend that doesn't. We just need to move the append transaction to the
> > > base ioend. Also use the opportunity to use a real error code instead
> > > of the magic 1 to cancel the transactions, and write a comment
> > > explaining the scheme.
> > >
> > > Signed-off-by: Christoph Hellwig <hch@lst.de>
> >
> > Reading through this patch, I have a feeling it fixes the crash that
> > Zorro has been seeing occasionally with generic/475...
> >
> > Reviewed-by: Darrick J. Wong <darrick.wong@oracle.com>
>
> Zorro, can you confirm? If so it would be great to also refer to
> the respective bugzilla entry #203947 [0].
Sure, I'll give it a test. But it's so hard to reproduce, I need long enough
time to prove "the panic's gone".
BTW, should I only merge this single patch to test, or merge your whole patchset
with 13 patches?
Thanks,
Zorro
>
> [0] https://bugzilla.kernel.org/show_bug.cgi?id=203947
>
> Luis
^ permalink raw reply [flat|nested] 28+ messages in thread
* Re: [PATCH 07/13] xfs: allow merging ioends over append boundaries
2019-06-28 2:52 ` Zorro Lang
@ 2019-06-28 3:33 ` Darrick J. Wong
0 siblings, 0 replies; 28+ messages in thread
From: Darrick J. Wong @ 2019-06-28 3:33 UTC (permalink / raw)
To: Zorro Lang
Cc: Luis Chamberlain, Amir Goldstein, Christoph Hellwig,
Damien Le Moal, Andreas Gruenbacher, linux-xfs, linux-fsdevel,
linux-kernel
On Fri, Jun 28, 2019 at 10:52:04AM +0800, Zorro Lang wrote:
> On Thu, Jun 27, 2019 at 09:43:04PM +0000, Luis Chamberlain wrote:
> > On Thu, Jun 27, 2019 at 11:23:09AM -0700, Darrick J. Wong wrote:
> > > On Thu, Jun 27, 2019 at 12:48:30PM +0200, Christoph Hellwig wrote:
> > > > There is no real problem merging ioends that go beyond i_size into an
> > > > ioend that doesn't. We just need to move the append transaction to the
> > > > base ioend. Also use the opportunity to use a real error code instead
> > > > of the magic 1 to cancel the transactions, and write a comment
> > > > explaining the scheme.
> > > >
> > > > Signed-off-by: Christoph Hellwig <hch@lst.de>
> > >
> > > Reading through this patch, I have a feeling it fixes the crash that
> > > Zorro has been seeing occasionally with generic/475...
> > >
> > > Reviewed-by: Darrick J. Wong <darrick.wong@oracle.com>
> >
> > Zorro, can you confirm? If so it would be great to also refer to
> > the respective bugzilla entry #203947 [0].
>
> Sure, I'll give it a test. But it's so hard to reproduce, I need long enough
> time to prove "the panic's gone".
>
> BTW, should I only merge this single patch to test, or merge your whole patchset
> with 13 patches?
Just this one patch.
--D
> Thanks,
> Zorro
>
> >
> > [0] https://bugzilla.kernel.org/show_bug.cgi?id=203947
> >
> > Luis
^ permalink raw reply [flat|nested] 28+ messages in thread
* Re: [PATCH 06/13] xfs: remove XFS_TRANS_NOFS
2019-06-27 22:30 ` Darrick J. Wong
@ 2019-06-28 5:37 ` Christoph Hellwig
2019-06-28 17:41 ` Darrick J. Wong
0 siblings, 1 reply; 28+ messages in thread
From: Christoph Hellwig @ 2019-06-28 5:37 UTC (permalink / raw)
To: Darrick J. Wong
Cc: Christoph Hellwig, Damien Le Moal, Andreas Gruenbacher,
linux-xfs, linux-fsdevel, linux-kernel
On Thu, Jun 27, 2019 at 03:30:30PM -0700, Darrick J. Wong wrote:
> I think the wording of this is too indirect. The reason we need to set
> NOFS is because we could be doing writeback as part of reclaiming
> memory, which means that we cannot recurse back into filesystems to
> satisfy the memory allocation needed to create a transaction. The NOFS
> part applies to any memory allocation, of course.
>
> If you're fine with the wording below I'll just edit that into the
> patch:
>
> /*
> * We can allocate memory here while doing writeback on behalf of
> * memory reclaim. To avoid memory allocation deadlocks set the
> * task-wide nofs context for the following operations.
> */
> nofs_flag = memalloc_nofs_save();
Fine with me.
> > trace_xfs_end_io_direct_write(ip, offset, size);
> > @@ -395,10 +396,11 @@ xfs_dio_write_end_io(
> > */
> > XFS_STATS_ADD(ip->i_mount, xs_write_bytes, size);
> >
> > + nofs_flag = memalloc_nofs_save();
>
> Hmm, do we need this here? I can't remember if there was a need for
> setting NOFS under xfs_reflink_end_cow from a dio completion or if that
> was purely the buffered writeback case...
We certainly had to add it for the unwritten extent conversion, maybe
the corner case just didn't manage to show up for COW yet:
commit 80641dc66a2d6dfb22af4413227a92b8ab84c7bb
Author: Christoph Hellwig <hch@infradead.org>
Date: Mon Oct 19 04:00:03 2009 +0000
xfs: I/O completion handlers must use NOFS allocations
When completing I/O requests we must not allow the memory allocator to
recurse into the filesystem, as we might deadlock on waiting for the
I/O completion otherwise. The only thing currently allocating normal
GFP_KERNEL memory is the allocation of the transaction structure for
the unwritten extent conversion. Add a memflags argument to
_xfs_trans_alloc to allow controlling the allocator behaviour.
Signed-off-by: Christoph Hellwig <hch@lst.de>
Reported-by: Thomas Neumann <tneumann@users.sourceforge.net>
Tested-by: Thomas Neumann <tneumann@users.sourceforge.net>
Reviewed-by: Alex Elder <aelder@sgi.com>
Signed-off-by: Alex Elder <aelder@sgi.com>
diff --git a/fs/xfs/xfs_fsops.c b/fs/xfs/xfs_fsops.c
index 2d0b3e1da9e6..6f83f58c099f 100644
--- a/fs/xfs/xfs_fsops.c
+++ b/fs/xfs/xfs_fsops.c
@@ -611,7 +611,7 @@ xfs_fs_log_dummy(
xfs_inode_t *ip;
int error;
- tp = _xfs_trans_alloc(mp, XFS_TRANS_DUMMY1);
+ tp = _xfs_trans_alloc(mp, XFS_TRANS_DUMMY1, KM_SLEEP);
error = xfs_trans_reserve(tp, 0, XFS_ICHANGE_LOG_RES(mp), 0, 0, 0);
if (error) {
xfs_trans_cancel(tp, 0);
diff --git a/fs/xfs/xfs_iomap.c b/fs/xfs/xfs_iomap.c
index 67ae5555a30a..7294abce6ef2 100644
--- a/fs/xfs/xfs_iomap.c
+++ b/fs/xfs/xfs_iomap.c
@@ -860,8 +860,15 @@ xfs_iomap_write_unwritten(
* set up a transaction to convert the range of extents
* from unwritten to real. Do allocations in a loop until
* we have covered the range passed in.
+ *
+ * Note that we open code the transaction allocation here
+ * to pass KM_NOFS--we can't risk to recursing back into
+ * the filesystem here as we might be asked to write out
+ * the same inode that we complete here and might deadlock
+ * on the iolock.
*/
- tp = xfs_trans_alloc(mp, XFS_TRANS_STRAT_WRITE);
+ xfs_wait_for_freeze(mp, SB_FREEZE_TRANS);
+ tp = _xfs_trans_alloc(mp, XFS_TRANS_STRAT_WRITE, KM_NOFS);
tp->t_flags |= XFS_TRANS_RESERVE;
error = xfs_trans_reserve(tp, resblks,
XFS_WRITE_LOG_RES(mp), 0,
diff --git a/fs/xfs/xfs_mount.c b/fs/xfs/xfs_mount.c
index 8b6c9e807efb..4d509f742bd2 100644
--- a/fs/xfs/xfs_mount.c
+++ b/fs/xfs/xfs_mount.c
@@ -1471,7 +1471,7 @@ xfs_log_sbcount(
if (!xfs_sb_version_haslazysbcount(&mp->m_sb))
return 0;
- tp = _xfs_trans_alloc(mp, XFS_TRANS_SB_COUNT);
+ tp = _xfs_trans_alloc(mp, XFS_TRANS_SB_COUNT, KM_SLEEP);
error = xfs_trans_reserve(tp, 0, mp->m_sb.sb_sectsize + 128, 0, 0,
XFS_DEFAULT_LOG_COUNT);
if (error) {
diff --git a/fs/xfs/xfs_trans.c b/fs/xfs/xfs_trans.c
index 66b849358e62..237badcbac3b 100644
--- a/fs/xfs/xfs_trans.c
+++ b/fs/xfs/xfs_trans.c
@@ -236,19 +236,20 @@ xfs_trans_alloc(
uint type)
{
xfs_wait_for_freeze(mp, SB_FREEZE_TRANS);
- return _xfs_trans_alloc(mp, type);
+ return _xfs_trans_alloc(mp, type, KM_SLEEP);
}
xfs_trans_t *
_xfs_trans_alloc(
xfs_mount_t *mp,
- uint type)
+ uint type,
+ uint memflags)
{
xfs_trans_t *tp;
atomic_inc(&mp->m_active_trans);
- tp = kmem_zone_zalloc(xfs_trans_zone, KM_SLEEP);
+ tp = kmem_zone_zalloc(xfs_trans_zone, memflags);
tp->t_magic = XFS_TRANS_MAGIC;
tp->t_type = type;
tp->t_mountp = mp;
diff --git a/fs/xfs/xfs_trans.h b/fs/xfs/xfs_trans.h
index ed47fc77759c..a0574f593f52 100644
--- a/fs/xfs/xfs_trans.h
+++ b/fs/xfs/xfs_trans.h
@@ -924,7 +924,7 @@ typedef struct xfs_trans {
* XFS transaction mechanism exported interfaces.
*/
xfs_trans_t *xfs_trans_alloc(struct xfs_mount *, uint);
-xfs_trans_t *_xfs_trans_alloc(struct xfs_mount *, uint);
+xfs_trans_t *_xfs_trans_alloc(struct xfs_mount *, uint, uint);
xfs_trans_t *xfs_trans_dup(xfs_trans_t *);
int xfs_trans_reserve(xfs_trans_t *, uint, uint, uint,
uint, uint);
^ permalink raw reply related [flat|nested] 28+ messages in thread
* Re: lift the xfs writepage code into iomap v2
2019-06-28 1:32 ` lift the xfs writepage code into iomap v2 Darrick J. Wong
@ 2019-06-28 5:42 ` Christoph Hellwig
0 siblings, 0 replies; 28+ messages in thread
From: Christoph Hellwig @ 2019-06-28 5:42 UTC (permalink / raw)
To: Darrick J. Wong
Cc: Christoph Hellwig, Damien Le Moal, Andreas Gruenbacher,
linux-xfs, linux-fsdevel, linux-kernel
On Thu, Jun 27, 2019 at 06:32:56PM -0700, Darrick J. Wong wrote:
> I think Dave has voiced some valid concerns about our ability to support
> this code over the long term once we start sharing it with other fses.
> XFS has a longish history of sailing away from generic code so that we
> can remove awkward abstractions which aren't working well for us. If
> we're going to continue to go our own way with things like file locking
> and mapping I wonder how long we'd keep using the iomap ioends before
> moving away again. How well will that iomap code avoid bitrot once XFS
> does that?
As outlied in my mail to Dave I agree with the high level issue.
But I very much thing that the writeback code is and should be generic.
For one it is much more tightly integrated with other iomap code
than with XFS. And second the kernel doesn't have a sane generic
writeback implementation. We have like three different crappy buffer
head ones, and anyone wanting to sanely implement writeback currently
has to write their own, which is a major PITA.
> How does that sound? Who are the other potential users?
The immediate current user is Damiens zonefs, which is just a thin
abstraction on top of zones in zoned block devices. Then my plan has
always been to convert gfs2 over to it, away from buffer heads. With
btrfs now joining iomap land I'd be really excited to move it over,
but we'll see how feasily that is. But with gfs2 done I think we
also are ready to convert anything currently using plain old buffer
heads over, so things like sysvfs, minix, jfs, etc. While that isn't
a priority and will take a while it will help with my grand overall
scheme of killing buffer_heads, at least for the data path.
^ permalink raw reply [flat|nested] 28+ messages in thread
* Re: [PATCH 07/13] xfs: allow merging ioends over append boundaries
2019-06-27 18:23 ` Darrick J. Wong
2019-06-27 21:43 ` Luis Chamberlain
@ 2019-06-28 5:51 ` Christoph Hellwig
2019-06-28 17:05 ` Darrick J. Wong
1 sibling, 1 reply; 28+ messages in thread
From: Christoph Hellwig @ 2019-06-28 5:51 UTC (permalink / raw)
To: Darrick J. Wong
Cc: Christoph Hellwig, Damien Le Moal, Andreas Gruenbacher,
linux-xfs, linux-fsdevel, linux-kernel
On Thu, Jun 27, 2019 at 11:23:09AM -0700, Darrick J. Wong wrote:
> On Thu, Jun 27, 2019 at 12:48:30PM +0200, Christoph Hellwig wrote:
> > There is no real problem merging ioends that go beyond i_size into an
> > ioend that doesn't. We just need to move the append transaction to the
> > base ioend. Also use the opportunity to use a real error code instead
> > of the magic 1 to cancel the transactions, and write a comment
> > explaining the scheme.
> >
> > Signed-off-by: Christoph Hellwig <hch@lst.de>
>
> Reading through this patch, I have a feeling it fixes the crash that
> Zorro has been seeing occasionally with generic/475...
So you think for some reason the disk i_size changes underneath and thus
the xfs_ioend_is_append misfired vs the actual transaction allocations?
I didn't even think of that, but using the different checks sure sounds
dangerous. So yes, we'd either need to backport my patch, or at least
replace the checks in xfs_ioend_can_merge with direct checks of
io_append_trans.
^ permalink raw reply [flat|nested] 28+ messages in thread
* Re: [PATCH 07/13] xfs: allow merging ioends over append boundaries
2019-06-28 5:51 ` Christoph Hellwig
@ 2019-06-28 17:05 ` Darrick J. Wong
0 siblings, 0 replies; 28+ messages in thread
From: Darrick J. Wong @ 2019-06-28 17:05 UTC (permalink / raw)
To: Christoph Hellwig
Cc: Damien Le Moal, Andreas Gruenbacher, linux-xfs, linux-fsdevel,
linux-kernel
On Fri, Jun 28, 2019 at 07:51:43AM +0200, Christoph Hellwig wrote:
> On Thu, Jun 27, 2019 at 11:23:09AM -0700, Darrick J. Wong wrote:
> > On Thu, Jun 27, 2019 at 12:48:30PM +0200, Christoph Hellwig wrote:
> > > There is no real problem merging ioends that go beyond i_size into an
> > > ioend that doesn't. We just need to move the append transaction to the
> > > base ioend. Also use the opportunity to use a real error code instead
> > > of the magic 1 to cancel the transactions, and write a comment
> > > explaining the scheme.
> > >
> > > Signed-off-by: Christoph Hellwig <hch@lst.de>
> >
> > Reading through this patch, I have a feeling it fixes the crash that
> > Zorro has been seeing occasionally with generic/475...
>
> So you think for some reason the disk i_size changes underneath and thus
> the xfs_ioend_is_append misfired vs the actual transaction allocations?
> I didn't even think of that, but using the different checks sure sounds
> dangerous. So yes, we'd either need to backport my patch, or at least
> replace the checks in xfs_ioend_can_merge with direct checks of
> io_append_trans.
That's my working theory, yes.
1. Dirty pages 0 and 2 of an empty file.
2. Writeback gets scheduled for pages 0 and 2, creating ioends A and C.
Both ioends describe writes past the on-disk isize so we allocate
transactions.
3. ioend C completes immediately, sets the ondisk isize to (3 * PAGESIZE).
4. Dirty page 1 of the file and immediately schedule writeback for it,
creating ioend B. ioend B describes a write within the on-disk isize so
we do not allocate setfilesize transaction.
5. ioend A and B complete and are sorted into the per-inode ioend
completion list. xfs_ioend_try_merge looks at ioend A, sees that ioend
can be merged with ioend B (same type, same cow status, same current
setfilesize status (which does not reflect the setfilesize status when A
was created)) and therefore decides to merge them.
6. A has a setfilesize transaction so _try_merge calls
xfs_setfilesize_ioend(ioend B, -1) to cancel ioend B's transaction, but
as we saw in (4), ioend B has no transaction and crashes.
--D
^ permalink raw reply [flat|nested] 28+ messages in thread
* Re: [PATCH 06/13] xfs: remove XFS_TRANS_NOFS
2019-06-28 5:37 ` Christoph Hellwig
@ 2019-06-28 17:41 ` Darrick J. Wong
0 siblings, 0 replies; 28+ messages in thread
From: Darrick J. Wong @ 2019-06-28 17:41 UTC (permalink / raw)
To: Christoph Hellwig
Cc: Damien Le Moal, Andreas Gruenbacher, linux-xfs, linux-fsdevel,
linux-kernel
On Fri, Jun 28, 2019 at 07:37:17AM +0200, Christoph Hellwig wrote:
> On Thu, Jun 27, 2019 at 03:30:30PM -0700, Darrick J. Wong wrote:
> > I think the wording of this is too indirect. The reason we need to set
> > NOFS is because we could be doing writeback as part of reclaiming
> > memory, which means that we cannot recurse back into filesystems to
> > satisfy the memory allocation needed to create a transaction. The NOFS
> > part applies to any memory allocation, of course.
> >
> > If you're fine with the wording below I'll just edit that into the
> > patch:
> >
> > /*
> > * We can allocate memory here while doing writeback on behalf of
> > * memory reclaim. To avoid memory allocation deadlocks set the
> > * task-wide nofs context for the following operations.
> > */
> > nofs_flag = memalloc_nofs_save();
>
> Fine with me.
>
> > > trace_xfs_end_io_direct_write(ip, offset, size);
> > > @@ -395,10 +396,11 @@ xfs_dio_write_end_io(
> > > */
> > > XFS_STATS_ADD(ip->i_mount, xs_write_bytes, size);
> > >
> > > + nofs_flag = memalloc_nofs_save();
> >
> > Hmm, do we need this here? I can't remember if there was a need for
> > setting NOFS under xfs_reflink_end_cow from a dio completion or if that
> > was purely the buffered writeback case...
>
> We certainly had to add it for the unwritten extent conversion, maybe
> the corner case just didn't manage to show up for COW yet:
AFAICT the referenced patch solved the problem of writeback ioend
completion deadlocking with memory reclaim by changing the transaction
allocation call in the xfs_iomap_write_unwritten function, which is
called by writeback ioend completion.
However, the directio endio code also calls xfs_iomap_write_unwritten.
I can't tell if NOFS is actually needed in that context, or if we've
just been operating like that for a decade because that's the method
that was chosen to solve the deadlock.
I think this boils down to -- does writeback induced by memory reclaim
ever block on directio?
I don't think it does, but as a counterpoint xfs has been like this for
10 years and there don't seem to be many complaints about directio endio
pushing memory reclaim too hard...
--D
>
> commit 80641dc66a2d6dfb22af4413227a92b8ab84c7bb
> Author: Christoph Hellwig <hch@infradead.org>
> Date: Mon Oct 19 04:00:03 2009 +0000
>
> xfs: I/O completion handlers must use NOFS allocations
>
> When completing I/O requests we must not allow the memory allocator to
> recurse into the filesystem, as we might deadlock on waiting for the
> I/O completion otherwise. The only thing currently allocating normal
> GFP_KERNEL memory is the allocation of the transaction structure for
> the unwritten extent conversion. Add a memflags argument to
> _xfs_trans_alloc to allow controlling the allocator behaviour.
>
> Signed-off-by: Christoph Hellwig <hch@lst.de>
> Reported-by: Thomas Neumann <tneumann@users.sourceforge.net>
> Tested-by: Thomas Neumann <tneumann@users.sourceforge.net>
> Reviewed-by: Alex Elder <aelder@sgi.com>
> Signed-off-by: Alex Elder <aelder@sgi.com>
>
> diff --git a/fs/xfs/xfs_fsops.c b/fs/xfs/xfs_fsops.c
> index 2d0b3e1da9e6..6f83f58c099f 100644
> --- a/fs/xfs/xfs_fsops.c
> +++ b/fs/xfs/xfs_fsops.c
> @@ -611,7 +611,7 @@ xfs_fs_log_dummy(
> xfs_inode_t *ip;
> int error;
>
> - tp = _xfs_trans_alloc(mp, XFS_TRANS_DUMMY1);
> + tp = _xfs_trans_alloc(mp, XFS_TRANS_DUMMY1, KM_SLEEP);
> error = xfs_trans_reserve(tp, 0, XFS_ICHANGE_LOG_RES(mp), 0, 0, 0);
> if (error) {
> xfs_trans_cancel(tp, 0);
> diff --git a/fs/xfs/xfs_iomap.c b/fs/xfs/xfs_iomap.c
> index 67ae5555a30a..7294abce6ef2 100644
> --- a/fs/xfs/xfs_iomap.c
> +++ b/fs/xfs/xfs_iomap.c
> @@ -860,8 +860,15 @@ xfs_iomap_write_unwritten(
> * set up a transaction to convert the range of extents
> * from unwritten to real. Do allocations in a loop until
> * we have covered the range passed in.
> + *
> + * Note that we open code the transaction allocation here
> + * to pass KM_NOFS--we can't risk to recursing back into
> + * the filesystem here as we might be asked to write out
> + * the same inode that we complete here and might deadlock
> + * on the iolock.
> */
> - tp = xfs_trans_alloc(mp, XFS_TRANS_STRAT_WRITE);
> + xfs_wait_for_freeze(mp, SB_FREEZE_TRANS);
> + tp = _xfs_trans_alloc(mp, XFS_TRANS_STRAT_WRITE, KM_NOFS);
> tp->t_flags |= XFS_TRANS_RESERVE;
> error = xfs_trans_reserve(tp, resblks,
> XFS_WRITE_LOG_RES(mp), 0,
> diff --git a/fs/xfs/xfs_mount.c b/fs/xfs/xfs_mount.c
> index 8b6c9e807efb..4d509f742bd2 100644
> --- a/fs/xfs/xfs_mount.c
> +++ b/fs/xfs/xfs_mount.c
> @@ -1471,7 +1471,7 @@ xfs_log_sbcount(
> if (!xfs_sb_version_haslazysbcount(&mp->m_sb))
> return 0;
>
> - tp = _xfs_trans_alloc(mp, XFS_TRANS_SB_COUNT);
> + tp = _xfs_trans_alloc(mp, XFS_TRANS_SB_COUNT, KM_SLEEP);
> error = xfs_trans_reserve(tp, 0, mp->m_sb.sb_sectsize + 128, 0, 0,
> XFS_DEFAULT_LOG_COUNT);
> if (error) {
> diff --git a/fs/xfs/xfs_trans.c b/fs/xfs/xfs_trans.c
> index 66b849358e62..237badcbac3b 100644
> --- a/fs/xfs/xfs_trans.c
> +++ b/fs/xfs/xfs_trans.c
> @@ -236,19 +236,20 @@ xfs_trans_alloc(
> uint type)
> {
> xfs_wait_for_freeze(mp, SB_FREEZE_TRANS);
> - return _xfs_trans_alloc(mp, type);
> + return _xfs_trans_alloc(mp, type, KM_SLEEP);
> }
>
> xfs_trans_t *
> _xfs_trans_alloc(
> xfs_mount_t *mp,
> - uint type)
> + uint type,
> + uint memflags)
> {
> xfs_trans_t *tp;
>
> atomic_inc(&mp->m_active_trans);
>
> - tp = kmem_zone_zalloc(xfs_trans_zone, KM_SLEEP);
> + tp = kmem_zone_zalloc(xfs_trans_zone, memflags);
> tp->t_magic = XFS_TRANS_MAGIC;
> tp->t_type = type;
> tp->t_mountp = mp;
> diff --git a/fs/xfs/xfs_trans.h b/fs/xfs/xfs_trans.h
> index ed47fc77759c..a0574f593f52 100644
> --- a/fs/xfs/xfs_trans.h
> +++ b/fs/xfs/xfs_trans.h
> @@ -924,7 +924,7 @@ typedef struct xfs_trans {
> * XFS transaction mechanism exported interfaces.
> */
> xfs_trans_t *xfs_trans_alloc(struct xfs_mount *, uint);
> -xfs_trans_t *_xfs_trans_alloc(struct xfs_mount *, uint);
> +xfs_trans_t *_xfs_trans_alloc(struct xfs_mount *, uint, uint);
> xfs_trans_t *xfs_trans_dup(xfs_trans_t *);
> int xfs_trans_reserve(xfs_trans_t *, uint, uint, uint,
> uint, uint);
^ permalink raw reply [flat|nested] 28+ messages in thread
end of thread, other threads:[~2019-06-28 17:42 UTC | newest]
Thread overview: 28+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2019-06-27 10:48 lift the xfs writepage code into iomap v2 Christoph Hellwig
2019-06-27 10:48 ` [PATCH 01/13] list.h: add list_pop and list_pop_entry helpers Christoph Hellwig
2019-06-27 20:48 ` Darrick J. Wong
2019-06-27 10:48 ` [PATCH 02/13] xfs: remove the unused xfs_count_page_state declaration Christoph Hellwig
2019-06-27 17:50 ` Darrick J. Wong
2019-06-27 10:48 ` [PATCH 03/13] xfs: fix a comment typo in xfs_submit_ioend Christoph Hellwig
2019-06-27 10:48 ` [PATCH 04/13] xfs: initialize iomap->flags in xfs_bmbt_to_iomap Christoph Hellwig
2019-06-27 20:44 ` Darrick J. Wong
2019-06-27 10:48 ` [PATCH 05/13] xfs: use a struct iomap in xfs_writepage_ctx Christoph Hellwig
2019-06-27 10:48 ` [PATCH 06/13] xfs: remove XFS_TRANS_NOFS Christoph Hellwig
2019-06-27 22:30 ` Darrick J. Wong
2019-06-28 5:37 ` Christoph Hellwig
2019-06-28 17:41 ` Darrick J. Wong
2019-06-27 10:48 ` [PATCH 07/13] xfs: allow merging ioends over append boundaries Christoph Hellwig
2019-06-27 18:23 ` Darrick J. Wong
2019-06-27 21:43 ` Luis Chamberlain
2019-06-28 2:52 ` Zorro Lang
2019-06-28 3:33 ` Darrick J. Wong
2019-06-28 5:51 ` Christoph Hellwig
2019-06-28 17:05 ` Darrick J. Wong
2019-06-27 10:48 ` [PATCH 08/13] xfs: simplify xfs_ioend_can_merge Christoph Hellwig
2019-06-27 10:48 ` [PATCH 09/13] xfs: refactor the ioend merging code Christoph Hellwig
2019-06-27 10:48 ` [PATCH 10/13] xfs: turn io_append_trans into an io_private void pointer Christoph Hellwig
2019-06-27 10:48 ` [PATCH 11/13] xfs: remove the fork fields in the writepage_ctx and ioend Christoph Hellwig
2019-06-27 10:48 ` [PATCH 12/13] iomap: move the xfs writeback code to iomap.c Christoph Hellwig
2019-06-27 10:48 ` [PATCH 13/13] iomap: add tracing for the address space operations Christoph Hellwig
2019-06-28 1:32 ` lift the xfs writepage code into iomap v2 Darrick J. Wong
2019-06-28 5:42 ` Christoph Hellwig
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).