filefrag: Lustre changes to filefrag FIEMAP handling

Add support for multiple-device filesystems by defining a new
fe_device field in the fiemap_extent structure.  This allows
printing the filesystem-relative or linux block device number
associated with each extent of a file.  If a single filesystem
extent is mirrored to multiple block devices, the fe_device
field can be used to disambiguate the multiple copies.

If the "-l" (device-logical) option is given to filefrag, then
all extents for a particular device of a file are returned
before returning extents for the next device.  This makes it
easier to see if extent allocation within a single device is
contiguous, instead of returning all of the blocks of a file
interleaved in file-logical-offset order.

Signed-off-by: Andreas Dilger <andreas.dilger@intel.com>

diff --git a/lib/ext2fs/fiemap.h b/lib/ext2fs/fiemap.h
index 0d1072a..fc022c0 100644 (file)
--- a/lib/ext2fs/fiemap.h
+++ b/lib/ext2fs/fiemap.h
@@ -19,7 +19,8 @@ struct fiemap_extent {
        __u64 fe_length;   /* length in bytes for this extent */
        __u64 fe_reserved64[2];
        __u32 fe_flags;    /* FIEMAP_EXTENT_* flags for this extent */
-       __u32 fe_reserved[3];
+       __u32 fe_device;   /* device number (fs-specific if FIEMAP_EXTENT_NET)*/
+       __u32 fe_reserved[2];
 };
 
 struct fiemap {
@@ -49,6 +50,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_DEVICE_ORDER 0x40000000 /* return device ordered mapping */
 
 #define FIEMAP_FLAGS_COMPAT    (FIEMAP_FLAG_SYNC | FIEMAP_FLAG_XATTR)
 
@@ -74,4 +76,7 @@ struct fiemap {
 #define FIEMAP_EXTENT_SHARED           0x00002000 /* Space shared with other
                                                    * files. */
 
+/* Network filesystem flags - use a high bit, don't conflict with upstream */
+#define FIEMAP_EXTENT_NET              0x80000000 /* Data stored remotely. */
+
 #endif /* _LINUX_FIEMAP_H */

diff --git a/misc/filefrag.8.in b/misc/filefrag.8.in
index 4b89e72..69e9953 100644 (file)
--- a/misc/filefrag.8.in
+++ b/misc/filefrag.8.in
@@ -8,7 +8,7 @@ filefrag \- report on file fragmentation
 .BI \-b blocksize
 ]
 [
-.B \-BeksvxX
+.B \-BeklsvxX
 ]
 [
 .I files...
@@ -46,6 +46,9 @@ Print output in extent format, even for block-mapped files.
 .B \-k
 Use 1024\-byte blocksize for output (identical to '\-b 1024').
 .TP
+.B \-l
+Extents are displayed in device-logical offset order.
+.TP
 .B \-s
 Sync the file before requesting the mapping.
 .TP

diff --git a/misc/filefrag.c b/misc/filefrag.c
index 032535f..52fb65d 100644 (file)
--- a/misc/filefrag.c
+++ b/misc/filefrag.c
@@ -56,14 +56,16 @@ int verbose = 0;
 unsigned int blocksize;        /* Use specified blocksize (default 1kB) */
 int sync_file = 0;     /* fsync file before getting the mapping */
 int xattr_map = 0;     /* get xattr mapping */
-int force_bmap;        /* force use of FIBMAP instead of FIEMAP */
+int force_bmap;                /* force use of FIBMAP instead of FIEMAP */
 int force_extent;      /* print output in extent format always */
+int device_offset;     /* extents report device-relative offsets */
 int logical_width = 8;
 int physical_width = 10;
 const char *ext_fmt = "%4d: %*llu..%*llu: %*llu..%*llu: %6llu: %s\n";
 const char *hex_fmt = "%4d: %*llx..%*llx: %*llx..%*llx: %6llx: %s\n";
 
-#define FILEFRAG_FIEMAP_FLAGS_COMPAT (FIEMAP_FLAG_SYNC | FIEMAP_FLAG_XATTR)
+#define FILEFRAG_FIEMAP_FLAGS_COMPAT (FIEMAP_FLAG_SYNC | FIEMAP_FLAG_XATTR |\
+                                     FIEMAP_FLAG_DEVICE_ORDER)
 
 #define FIBMAP         _IO(0x00, 1)    /* bmap access */
 #define FIGETBSZ       _IO(0x00, 2)    /* get the block size used for bmap */
@@ -122,10 +124,10 @@ static void print_extent_header(void)
 {
        printf(" ext: %*s %*s length: %*s flags:\n",
               logical_width * 2 + 3,
-              "logical_offset:",
+              device_offset ? "device_logical:" : "logical_offset:",
               physical_width * 2 + 3, "physical_offset:",
-              physical_width + 1,
-              "expected:");
+              device_offset ? 5 : physical_width + 1,
+              device_offset ? " dev:" : "expected:");
 }
 
 static void print_flag(__u32 *flags, __u32 mask, char *buf, const char *name)
@@ -161,11 +163,11 @@ static void print_extent_info(struct fiemap_extent *fm_extent, int cur_ex,
                physical_blk = fm_extent->fe_physical >> blk_shift;
        }
 
-       if (expected)
-               sprintf(flags, ext_fmt == hex_fmt ? "%*llx: " : "%*llu: ",
+       if (device_offset)
+               sprintf(flags, "%04x: ", fm_extent->fe_device);
+       else if (expected)
+               sprintf(flags, ext_fmt == hex_fmt ? "%*llx:" : "%*llu: ",
                        physical_width, expected >> blk_shift);
-       else
-               sprintf(flags, "%.*s  ", physical_width, "                   ");
 
        fe_flags = fm_extent->fe_flags;
        print_flag(&fe_flags, FIEMAP_EXTENT_LAST, flags, "last,");
@@ -179,6 +181,8 @@ static void print_extent_info(struct fiemap_extent *fm_extent, int cur_ex,
        print_flag(&fe_flags, FIEMAP_EXTENT_UNWRITTEN, flags, "unwritten,");
        print_flag(&fe_flags, FIEMAP_EXTENT_MERGED, flags, "merged,");
        print_flag(&fe_flags, FIEMAP_EXTENT_SHARED, flags, "shared,");
+       print_flag(&fe_flags, FIEMAP_EXTENT_NET, flags, "net,");
+
        /* print any unknown flags as hex values */
        for (mask = 1; fe_flags != 0 && mask != 0; mask <<= 1) {
                char hex[sizeof(mask) * 2 + 4]; /* 2 chars/byte + 0x, + NUL */
@@ -219,6 +223,7 @@ static int filefrag_fiemap(int fd, int blk_shift, int *num_extents,
        unsigned int i;
        int fiemap_header_printed = 0;
        int tot_extents = 0, n = 0;
+       int previous_device = 0;
        int last = 0;
        int rc;
 
@@ -231,6 +236,12 @@ static int filefrag_fiemap(int fd, int blk_shift, int *num_extents,
        if (xattr_map)
                flags |= FIEMAP_FLAG_XATTR;
 
+       if (device_offset) {
+               flags |= FIEMAP_FLAG_DEVICE_ORDER;
+               memset(fm_ext, 0, sizeof(struct fiemap_extent));
+       }
+
+retry_wo_device_order:
        do {
                fiemap->fm_length = ~0ULL;
                fiemap->fm_flags = flags;
@@ -245,6 +256,10 @@ static int filefrag_fiemap(int fd, int blk_shift, int *num_extents,
                                                "flags %x\n",
                                       fiemap->fm_flags);
                                fiemap_incompat_printed = 1;
+                       } else if (rc == EBADR && (fiemap->fm_flags &
+                                                  FIEMAP_FLAG_DEVICE_ORDER)) {
+                               flags &= ~FIEMAP_FLAG_DEVICE_ORDER;
+                               goto retry_wo_device_order;
                        }
                        return rc;
                }
@@ -259,6 +274,9 @@ static int filefrag_fiemap(int fd, int blk_shift, int *num_extents,
                }
 
                for (i = 0; i < fiemap->fm_mapped_extents; i++) {
+                       if (previous_device != fm_ext[i].fe_device)
+                               previous_device = fm_ext[i].fe_device;
+
                        expected_dense = fm_last.fe_physical +
                                         fm_last.fe_length;
                        expected = fm_last.fe_physical +
@@ -281,8 +299,20 @@ static int filefrag_fiemap(int fd, int blk_shift, int *num_extents,
                        n++;
                }
 
-               fiemap->fm_start = (fm_ext[i - 1].fe_logical +
-                                   fm_ext[i - 1].fe_length);
+               /* For DEVICE_ORDER mappings, if EXTENT_LAST not yet found then
+                * fm_start needs to be the same as it was for earlier ioctl.
+                * The first extent is used to pass the end offset and device
+                * of the last FIEMAP call.  Otherwise, we ask for extents
+                * starting from where the last mapping ended. */
+               if (flags & FIEMAP_FLAG_DEVICE_ORDER) {
+                       fm_ext[0].fe_logical =  fm_ext[i - 1].fe_logical +
+                                               fm_ext[i - 1].fe_length;
+                       fm_ext[0].fe_device =   fm_ext[i - 1].fe_device;
+                       fiemap->fm_start =      0;
+               } else {
+                       fiemap->fm_start =      fm_ext[i - 1].fe_logical +
+                                               fm_ext[i - 1].fe_length;
+               }
        } while (last == 0);
 
        *num_extents = tot_extents;
@@ -306,6 +336,7 @@ static int filefrag_fibmap(int fd, int blk_shift, int *num_extents,
        memset(&fm_ext, 0, sizeof(fm_ext));
        memset(&fm_last, 0, sizeof(fm_last));
        if (force_extent) {
+               fm_ext.fe_device = st->st_dev;
                fm_ext.fe_flags = FIEMAP_EXTENT_MERGED;
        }
 
@@ -440,6 +471,13 @@ static int frag_report(const char *filename)
                        is_ext2 = 1;
        }
 
+       /* Check if filesystem is Lustre.  Always print in extent format
+        * with 1kB blocks, using the device-relative logical offsets. */
+       if (fsinfo.f_type == LUSTRE_SUPER_MAGIC) {
+               device_offset = 1;
+               blocksize = blocksize ?: 1024;
+       }
+
        if (is_ext2) {
                long cylgroups = div_ceil(fsinfo.f_blocks, blksize * 8);
 
@@ -527,10 +565,11 @@ int main(int argc, char**argv)
        char **cpp;
        int rc = 0, c;
 
-       while ((c = getopt(argc, argv, "Bb::eksvxX")) != EOF) {
+       while ((c = getopt(argc, argv, "Bb::eklsvxX")) != EOF) {
                switch (c) {
                case 'B':
                        force_bmap++;
+                       force_extent = 0;
                        break;
                case 'b':
                        if (optarg) {
@@ -589,6 +628,9 @@ int main(int argc, char**argv)
                case 'k':
                        blocksize = 1024;
                        break;
+               case 'l':
+                       device_offset++;
+                       break;
                case 's':
                        sync_file++;
                        break;