[RFC PATCH] fiemap cow fork flag

[RFC PATCH] fiemap cow fork flag

[Brian Foster]

Hi all,

This is just something I slapped together when poking around and learning the
reflink cow fork stuff. E.g., I find it useful to see exactly what's going on
in certain situations, verify the background reclaim works, etc. I'm not sure
it's worthy of a generic fiemap flag since I believe the cow fork is a fairly
XFS-specific mechanism, it's limited to extra blocks that haven't been written,
and probably dumps information obtainable via other means (tracepoints). I'm
throwing it up on the list anyways for reference and/or archival purposes, if
nothing else. Thanks!

Brian

Brian Foster (1):
  xfs: fiemap support for cow fork

 fs/xfs/xfs_iomap.c          | 45 +++++++++++++++++++++++++++++++++++++++++++++
 fs/xfs/xfs_iomap.h          |  1 +
 fs/xfs/xfs_iops.c           |  4 ++++
 include/uapi/linux/fiemap.h |  1 +
 4 files changed, 51 insertions(+)

-- 
2.7.4

[RFC PATCH] xfs: fiemap support for cow fork

[Brian Foster]

Reflink support for XFS incorporates the addition of a copy-on-write
inode fork to track newly allocated extents to be used to replace shared
blocks on write. While these extents are tracked by the cow fork
temporarily in principle, fragmentation avoidance mechanisms like the
cowextsize hint allow for the allocation of additional blocks outside of
the range of the write, in anticipation of future writes. In summary,
this means that blocks in the cow fork can linger for some time until
written to and remapped to the data fork or reaped by the background cow
fork reclaimer.

Define and wiree up a fiemap flag to query the cow fork extent list of
an inode. Note that fiemap triggers writeback, which means all cow fork
extents that are the target of I/O are remapped to the data fork as part
of the query. As a result, the cow fork fiemap request returns only the
blocks that have been allocated and not yet written to or reclaimed.

Signed-off-by: Brian Foster <bfoster@redhat.com>
---
 fs/xfs/xfs_iomap.c          | 45 +++++++++++++++++++++++++++++++++++++++++++++
 fs/xfs/xfs_iomap.h          |  1 +
 fs/xfs/xfs_iops.c           |  4 ++++
 include/uapi/linux/fiemap.h |  1 +
 4 files changed, 51 insertions(+)

diff --git a/fs/xfs/xfs_iomap.c b/fs/xfs/xfs_iomap.c
index d907eb9..f2d1219 100644
--- a/fs/xfs/xfs_iomap.c
+++ b/fs/xfs/xfs_iomap.c
@@ -1144,3 +1144,48 @@ xfs_xattr_iomap_begin(
 struct iomap_ops xfs_xattr_iomap_ops = {
 	.iomap_begin		= xfs_xattr_iomap_begin,
 };
+
+static int
+xfs_cow_iomap_begin(
+	struct inode		*inode,
+	loff_t			offset,
+	loff_t			length,
+	unsigned		flags,
+	struct iomap		*iomap)
+{
+	struct xfs_inode	*ip = XFS_I(inode);
+	struct xfs_mount	*mp = ip->i_mount;
+	xfs_fileoff_t		offset_fsb = XFS_B_TO_FSBT(mp, offset);
+	xfs_fileoff_t		end_fsb = XFS_B_TO_FSB(mp, offset + length);
+	struct xfs_bmbt_irec	imap;
+	int			error = 0;
+	int			nimaps = 1;
+	unsigned		lockmode;
+
+	if (XFS_FORCED_SHUTDOWN(mp))
+		return -EIO;
+
+	lockmode = xfs_ilock_data_map_shared(ip);
+
+	if (!xfs_is_reflink_inode(ip)) {
+		error = -ENOENT;
+		goto out_unlock;
+	}
+
+	error = xfs_bmapi_read(ip, offset_fsb, end_fsb - offset_fsb, &imap,
+			       &nimaps, XFS_BMAPI_ENTIRE | XFS_BMAPI_COWFORK);
+
+out_unlock:
+	xfs_iunlock(ip, lockmode);
+
+	if (!error) {
+		ASSERT(nimaps);
+		xfs_bmbt_to_iomap(ip, iomap, &imap);
+	}
+
+	return error;
+}
+
+struct iomap_ops xfs_cow_iomap_ops = {
+	.iomap_begin		= xfs_cow_iomap_begin,
+};
diff --git a/fs/xfs/xfs_iomap.h b/fs/xfs/xfs_iomap.h
index 6d45cf0..69b62e4 100644
--- a/fs/xfs/xfs_iomap.h
+++ b/fs/xfs/xfs_iomap.h
@@ -35,5 +35,6 @@ xfs_extlen_t xfs_eof_alignment(struct xfs_inode *ip, xfs_extlen_t extsize);
 
 extern struct iomap_ops xfs_iomap_ops;
 extern struct iomap_ops xfs_xattr_iomap_ops;
+extern struct iomap_ops xfs_cow_iomap_ops;
 
 #endif /* __XFS_IOMAP_H__*/
diff --git a/fs/xfs/xfs_iops.c b/fs/xfs/xfs_iops.c
index 405a65c..517eeed 100644
--- a/fs/xfs/xfs_iops.c
+++ b/fs/xfs/xfs_iops.c
@@ -1043,6 +1043,10 @@ xfs_vn_fiemap(
 		fieinfo->fi_flags &= ~FIEMAP_FLAG_XATTR;
 		error = iomap_fiemap(inode, fieinfo, start, length,
 				&xfs_xattr_iomap_ops);
+	} else if (fieinfo->fi_flags & FIEMAP_FLAG_COW) {
+		fieinfo->fi_flags &= ~FIEMAP_FLAG_COW;
+		error = iomap_fiemap(inode, fieinfo, start, length,
+				&xfs_cow_iomap_ops);
 	} else {
 		error = iomap_fiemap(inode, fieinfo, start, length,
 				&xfs_iomap_ops);
diff --git a/include/uapi/linux/fiemap.h b/include/uapi/linux/fiemap.h
index 0c51d61..7014b4c 100644
--- a/include/uapi/linux/fiemap.h
+++ b/include/uapi/linux/fiemap.h
@@ -41,6 +41,7 @@ struct fiemap {
 #define FIEMAP_FLAG_SYNC	0x00000001 /* sync file data before map */
 #define FIEMAP_FLAG_XATTR	0x00000002 /* map extended attribute tree */
 #define FIEMAP_FLAG_CACHE	0x00000004 /* request caching of the extents */
+#define FIEMAP_FLAG_COW		0x00000010 /* map cow fork extents */
 
 #define FIEMAP_FLAGS_COMPAT	(FIEMAP_FLAG_SYNC | FIEMAP_FLAG_XATTR)
 
-- 
2.7.4

[PATCH] xfs_io: use fiemap -c param to query cow fork

[Brian Foster]

Signed-off-by: Brian Foster <bfoster@redhat.com>
---
 io/fiemap.c | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/io/fiemap.c b/io/fiemap.c
index f89da06..9114af1 100644
--- a/io/fiemap.c
+++ b/io/fiemap.c
@@ -206,6 +206,10 @@ calc_print_format(
 	}
 }
 
+#ifndef FIEMAP_FLAG_COW
+#define FIEMAP_FLAG_COW		0x00000010
+#endif
+
 int
 fiemap_f(
 	int		argc,
@@ -231,11 +235,14 @@ fiemap_f(
 	__u64		last_logical = 0;
 	struct stat	st;
 
-	while ((c = getopt(argc, argv, "aln:v")) != EOF) {
+	while ((c = getopt(argc, argv, "acln:v")) != EOF) {
 		switch (c) {
 		case 'a':
 			fiemap_flags |= FIEMAP_FLAG_XATTR;
 			break;
+		case 'c':
+			fiemap_flags |= FIEMAP_FLAG_COW;
+			break;
 		case 'l':
 			lflag = 1;
 			break;
-- 
2.7.4