GFS2: Add function gfs2_get_iomap

Hi,

This patch replaces the GFS2 fiemap implementation that used vfs function __generic_block_fiemap with a new implementation that uses the new iomap-based fiemap interface. This allows GFS2's fiemap to skip holes. The time to do filefrag on a file with a 1 petabyte hole is reduced from several days or weeks, to milliseconds. Note that there are Kconfig changes that affect everyone.

Signed-off-by Bob Peterson <[email protected]>

---

fs/Kconfig +1 -1

index 2bc7ad7..d601aeb 100644
@@ -11,7 +11,7 @@ config DCACHE_WORD_ACCESS
  if BLOCK
 
  config FS_IOMAP
-	bool
+	bool "File System IOMAP Support"
 
  source "fs/ext2/Kconfig"
  source "fs/ext4/Kconfig"

fs/gfs2/Kconfig +1 -0

index 90c6a8f..f8fa955 100644
@@ -25,6 +25,7 @@ config GFS2_FS
  config GFS2_FS_LOCKING_DLM
  	bool "GFS2 DLM locking"
  	depends on (GFS2_FS!=n) && NET && INET && (IPV6 || IPV6=n) && \
+		FS_IOMAP && \
  		CONFIGFS_FS && SYSFS && (DLM=y || DLM=GFS2_FS)
  	help
  	  Multiple node locking module for GFS2

fs/gfs2/bmap.c +59 -0

index 6e2bec1..685f1ed 100644
@@ -588,6 +588,155 @@ static int gfs2_bmap_alloc(struct inode *inode, const sector_t lblock,
  }
 
  /**
+ * hole_size - figure out the size of a hole
+ * @ip: The inode
+ * @lblock: The logical starting block number
+ * @mp: The metapath
+ *
+ * Returns: The hole size in bytes
+ *
+ */
+static u64 hole_size(struct inode *inode, sector_t lblock, struct metapath *mp)
+{
+	struct gfs2_inode *ip = GFS2_I(inode);
+	struct gfs2_sbd *sdp = GFS2_SB(inode);
+	struct metapath mp_eof;
+	unsigned int end_of_metadata = ip->i_height - 1;
+	u64 factor = 1;
+	int hgt = end_of_metadata;
+	u64 holesz = 0, holestep;
+	const __be64 *first, *end, *ptr;
+	const struct buffer_head *bh;
+	u64 isize = i_size_read(inode);
+	int zeroptrs;
+	bool done = false;
+
+	/* Get another metapath, to the very last byte */
+	find_metapath(sdp, (isize - 1) >> inode->i_blkbits, &mp_eof,
+		      ip->i_height);
+	for (hgt = end_of_metadata; hgt >= 0 && !done; hgt--) {
+		bh = mp->mp_bh[hgt];
+		if (bh) {
+			zeroptrs = 0;
+			first = metapointer(hgt, mp);
+			end = (const __be64 *)(bh->b_data + bh->b_size);
+
+			for (ptr = first; ptr < end; ptr++) {
+				if (*ptr) {
+					done = true;
+					break;
+				} else {
+					zeroptrs++;
+				}
+			}
+		} else {
+			zeroptrs = sdp->sd_inptrs;
+		}
+		holestep = min(factor * zeroptrs,
+			       isize - (lblock + (zeroptrs * holesz)));
+		holesz += holestep;
+		if (lblock + holesz >= isize)
+			return holesz << inode->i_blkbits;
+
+		factor *= sdp->sd_inptrs;
+		if (hgt && (mp->mp_list[hgt - 1] < mp_eof.mp_list[hgt - 1]))
+			(mp->mp_list[hgt - 1])++;
+	}
+	return holesz << inode->i_blkbits;
+}
+
+/**
+ * gfs2_get_iomap - Map blocks from an inode to disk blocks

fs/gfs2/inode.c +22 -1

index e4da0ec..0d705ef 100644
@@ -17,7 +17,7 @@
  #include <linux/posix_acl.h>
  #include <linux/gfs2_ondisk.h>
  #include <linux/crc32.h>
-#include <linux/fiemap.h>
+#include <linux/iomap.h>
  #include <linux/security.h>
  #include <asm/uaccess.h>
 

@@ -1990,28 +1990,65 @@ static int gfs2_getattr(struct vfsmount *mnt, struct dentry *dentry,
  	return 0;
  }
 
+static int gfs2_iomap_fiemap_begin(struct inode *inode, loff_t offset,
+				   loff_t length, unsigned flags,
+				   struct iomap *iomap)
+{
+	struct gfs2_inode *ip = GFS2_I(inode);
+	struct gfs2_holder *gh;
+	int ret;
+
+	gh = kzalloc(sizeof(struct gfs2_holder), GFP_NOFS);
+	if (!gh)
+		return -ENOMEM;
+
+	ret = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, 0, gh);
+	if (ret) {
+		kfree(gh);
+		return ret;
+	}
+	ret = gfs2_get_iomap(inode, offset, length, iomap);
+	if (ret)
+		gfs2_glock_dq_uninit(gh);
+	return ret;

----- Original Message -----

| > +int gfs2_get_iomap(struct inode *inode, loff_t pos, ssize_t length,
| > +		   struct iomap *iomap)
| This function should be merged with gfs2_block_map() I think, so that
| gfs2_block_map just becomes a wrapper (which will eventually go away)
| for this function. Otherwise we will have two parallel but slightly
| different implementations of block mapping to maintain.

Yes, I guess that's worth doing. I did this and included the revised patch below.

| Is there a better way to pass the gh from the begin function to the end
| function? I'm sure that will work, but it is the kind of thing that
| might trip up the unwary in the future,

Yeah, I would have passed the gh another way, but Christoph didn't leave a good way in the iomap interface or other bits to do it. At least not that I can see. It might be worth changing the interface to add that flexibility for other file systems that might want to do this as well. It would be easy enough to add a (void *)private pointer or something that can be passed around. Christoph and Steve: Would you prefer I plumb something before I do the GFS2 bits?

For now, here's a replacement patch which still does it the only way possible.

Bob Peterson
Red Hat File Systems
---
This patch replaces the GFS2 fiemap implementation that used vfs function __generic_block_fiemap with a new implementation that uses the new iomap-based fiemap interface. This allows GFS2's fiemap to skip holes. The time to do filefrag on a file with a 1 petabyte hole is reduced from several days or weeks, to milliseconds. Note that there are Kconfig changes that affect everyone.

Signed-off-by Bob Peterson <[email protected]>

---

fs/gfs2/Kconfig +1 -0

index 90c6a8f..f8fa955 100644
@@ -25,6 +25,7 @@ config GFS2_FS
  config GFS2_FS_LOCKING_DLM
  	bool "GFS2 DLM locking"
  	depends on (GFS2_FS!=n) && NET && INET && (IPV6 || IPV6=n) && \
+		FS_IOMAP && \
  		CONFIGFS_FS && SYSFS && (DLM=y || DLM=GFS2_FS)
  	help
  	  Multiple node locking module for GFS2

fs/gfs2/bmap.c +60 -0

index 6e2bec1..839f2a6 100644
@@ -588,6 +588,66 @@ static int gfs2_bmap_alloc(struct inode *inode, const sector_t lblock,
  }
 
  /**
+ * hole_size - figure out the size of a hole
+ * @ip: The inode
+ * @lblock: The logical starting block number
+ * @mp: The metapath
+ *
+ * Returns: The hole size in bytes
+ *
+ */
+static u64 hole_size(struct inode *inode, sector_t lblock, struct metapath *mp)
+{
+	struct gfs2_inode *ip = GFS2_I(inode);
+	struct gfs2_sbd *sdp = GFS2_SB(inode);
+	struct metapath mp_eof;
+	unsigned int end_of_metadata = ip->i_height - 1;
+	u64 factor = 1;
+	int hgt = end_of_metadata;
+	u64 holesz = 0, holestep;
+	const __be64 *first, *end, *ptr;
+	const struct buffer_head *bh;
+	u64 isize = i_size_read(inode);
+	int zeroptrs;
+	bool done = false;
+
+	/* Get another metapath, to the very last byte */
+	find_metapath(sdp, (isize - 1) >> inode->i_blkbits, &mp_eof,
+		      ip->i_height);
+	for (hgt = end_of_metadata; hgt >= 0 && !done; hgt--) {
+		bh = mp->mp_bh[hgt];
+		if (bh) {
+			zeroptrs = 0;
+			first = metapointer(hgt, mp);
+			end = (const __be64 *)(bh->b_data + bh->b_size);
+
+			for (ptr = first; ptr < end; ptr++) {
+				if (*ptr) {
+					done = true;
+					break;
+				} else {
+					zeroptrs++;
+				}
+			}
+		} else {
+			zeroptrs = sdp->sd_inptrs;
+		}
+		holestep = min(factor * zeroptrs,
+			       isize - (lblock + (zeroptrs * holesz)));
+		holesz += holestep;
+		if (lblock + holesz >= isize)
+			return holesz << inode->i_blkbits;
+
+		factor *= sdp->sd_inptrs;
+		if (hgt && (mp->mp_list[hgt - 1] < mp_eof.mp_list[hgt - 1]))
+			(mp->mp_list[hgt - 1])++;
+	}
+	return holesz << inode->i_blkbits;
+}
+
+enum gfs2_map_type { maptype_iomap = 1, maptype_bhmap = 2, };
+
+/**
   * gfs2_block_map - Map a block from an inode to a disk block
   * @inode: The inode
   * @lblock: The logical block number

| Is there a better way to pass the gh from the begin function to the end
| function? I'm sure that will work, but it is the kind of thing that
| might trip up the unwary in the future,

Yeah, I would have passed the gh another way, but Christoph didn't leave a good way in the iomap interface or other bits to do it. At least not that I can see. It might be worth changing the interface to add that flexibility for other file systems that might want to do this as well. It would be easy enough to add a (void *)private pointer or something that can be passed around. Christoph and Steve: Would you prefer I plumb something before I do the GFS2 bits?