diff --git a/SOURCES/xfsprogs-5.4.0-mkfs-Break-block-discard-into-chunks-of-2-GB.patch b/SOURCES/xfsprogs-5.4.0-mkfs-Break-block-discard-into-chunks-of-2-GB.patch new file mode 100644 index 0000000..56d959a --- /dev/null +++ b/SOURCES/xfsprogs-5.4.0-mkfs-Break-block-discard-into-chunks-of-2-GB.patch @@ -0,0 +1,109 @@ +From 7e8a6edb4d1ba0079152eb477abbbc1dfb1ebb7e Mon Sep 17 00:00:00 2001 +From: Pavel Reichl +Date: Fri, 13 Dec 2019 16:21:26 -0500 +Subject: [PATCH] mkfs: Break block discard into chunks of 2 GB + +Some users are not happy about the BLKDISCARD taking too long and at the +same time not being informed about that - so they think that the command +actually hung. + +This commit changes code so that progress reporting is possible and also +typing the ^C will cancel the ongoing BLKDISCARD. + +Signed-off-by: Pavel Reichl +Reviewed-by: Darrick J. Wong +Reviewed-by: Dave Chinner +Signed-off-by: Eric Sandeen +--- + mkfs/xfs_mkfs.c | 50 ++++++++++++++++++++++++++++++++++++------------- + 1 file changed, 37 insertions(+), 13 deletions(-) + +diff --git a/mkfs/xfs_mkfs.c b/mkfs/xfs_mkfs.c +index 18338a61..4bfdebf6 100644 +--- a/mkfs/xfs_mkfs.c ++++ b/mkfs/xfs_mkfs.c +@@ -1240,17 +1240,40 @@ done: + } + + static void +-discard_blocks(dev_t dev, uint64_t nsectors) ++discard_blocks(dev_t dev, uint64_t nsectors, int quiet) + { +- int fd; ++ int fd; ++ uint64_t offset = 0; ++ /* Discard the device 2G at a time */ ++ const uint64_t step = 2ULL << 30; ++ const uint64_t count = BBTOB(nsectors); + +- /* +- * We intentionally ignore errors from the discard ioctl. It is +- * not necessary for the mkfs functionality but just an optimization. +- */ + fd = libxfs_device_to_fd(dev); +- if (fd > 0) +- platform_discard_blocks(fd, 0, nsectors << 9); ++ if (fd <= 0) ++ return; ++ if (!quiet) { ++ printf("Discarding blocks..."); ++ fflush(stdout); ++ } ++ ++ /* The block discarding happens in smaller batches so it can be ++ * interrupted prematurely ++ */ ++ while (offset < count) { ++ uint64_t tmp_step = min(step, count - offset); ++ ++ /* ++ * We intentionally ignore errors from the discard ioctl. It is ++ * not necessary for the mkfs functionality but just an ++ * optimization. However we should stop on error. ++ */ ++ if (platform_discard_blocks(fd, offset, tmp_step)) ++ return; ++ ++ offset += tmp_step; ++ } ++ if (!quiet) ++ printf("Done.\n"); + } + + static __attribute__((noreturn)) void +@@ -2507,18 +2530,19 @@ open_devices( + + static void + discard_devices( +- struct libxfs_xinit *xi) ++ struct libxfs_xinit *xi, ++ int quiet) + { + /* + * This function has to be called after libxfs has been initialized. + */ + + if (!xi->disfile) +- discard_blocks(xi->ddev, xi->dsize); ++ discard_blocks(xi->ddev, xi->dsize, quiet); + if (xi->rtdev && !xi->risfile) +- discard_blocks(xi->rtdev, xi->rtsize); ++ discard_blocks(xi->rtdev, xi->rtsize, quiet); + if (xi->logdev && xi->logdev != xi->ddev && !xi->lisfile) +- discard_blocks(xi->logdev, xi->logBBsize); ++ discard_blocks(xi->logdev, xi->logBBsize, quiet); + } + + static void +@@ -3749,7 +3773,7 @@ main( + * All values have been validated, discard the old device layout. + */ + if (discard && !dry_run) +- discard_devices(&xi); ++ discard_devices(&xi, quiet); + + /* + * we need the libxfs buffer cache from here on in. +-- +2.17.0 + diff --git a/SOURCES/xfsprogs-5.4.0-mkfs-tidy-up-discard-notifications.patch b/SOURCES/xfsprogs-5.4.0-mkfs-tidy-up-discard-notifications.patch new file mode 100644 index 0000000..97c6402 --- /dev/null +++ b/SOURCES/xfsprogs-5.4.0-mkfs-tidy-up-discard-notifications.patch @@ -0,0 +1,56 @@ +From 2383d7c5cf20efcff75cb29ca3e02cfbe1bf2209 Mon Sep 17 00:00:00 2001 +From: Eric Sandeen +Date: Tue, 17 Dec 2019 16:52:39 -0500 +Subject: [PATCH] mkfs: tidy up discard notifications + +Only notify user of discard operations if the first one succeeds, +and be sure to print a trailing newline if we stop early. + +Signed-off-by: Eric Sandeen +Reviewed-by: Darrick J. Wong +Signed-off-by: Eric Sandeen +--- + mkfs/xfs_mkfs.c | 16 ++++++++++------ + 1 file changed, 10 insertions(+), 6 deletions(-) + +diff --git a/mkfs/xfs_mkfs.c b/mkfs/xfs_mkfs.c +index 4bfdebf6..606f79da 100644 +--- a/mkfs/xfs_mkfs.c ++++ b/mkfs/xfs_mkfs.c +@@ -1251,10 +1251,6 @@ discard_blocks(dev_t dev, uint64_t nsectors, int quiet) + fd = libxfs_device_to_fd(dev); + if (fd <= 0) + return; +- if (!quiet) { +- printf("Discarding blocks..."); +- fflush(stdout); +- } + + /* The block discarding happens in smaller batches so it can be + * interrupted prematurely +@@ -1267,12 +1263,20 @@ discard_blocks(dev_t dev, uint64_t nsectors, int quiet) + * not necessary for the mkfs functionality but just an + * optimization. However we should stop on error. + */ +- if (platform_discard_blocks(fd, offset, tmp_step)) ++ if (platform_discard_blocks(fd, offset, tmp_step) == 0) { ++ if (offset == 0 && !quiet) { ++ printf("Discarding blocks..."); ++ fflush(stdout); ++ } ++ } else { ++ if (offset > 0 && !quiet) ++ printf("\n"); + return; ++ } + + offset += tmp_step; + } +- if (!quiet) ++ if (offset > 0 && !quiet) + printf("Done.\n"); + } + +-- +2.17.0 + diff --git a/SOURCES/xfsprogs-5.5.0-libxfs-use-FALLOC_FL_ZERO_RANGE-in-libxfs_device_zer.patch b/SOURCES/xfsprogs-5.5.0-libxfs-use-FALLOC_FL_ZERO_RANGE-in-libxfs_device_zer.patch new file mode 100644 index 0000000..a7b613f --- /dev/null +++ b/SOURCES/xfsprogs-5.5.0-libxfs-use-FALLOC_FL_ZERO_RANGE-in-libxfs_device_zer.patch @@ -0,0 +1,112 @@ +From 9d6023a856a1c4f84415dff59b0d5459cc8768db Mon Sep 17 00:00:00 2001 +From: Eric Sandeen +Date: Thu, 27 Feb 2020 15:05:48 -0500 +Subject: [PATCH] libxfs: use FALLOC_FL_ZERO_RANGE in libxfs_device_zero + +I had a request from someone who cared about mkfs speed over +a slower network block device to look into using faster zeroing +methods, particularly for the log, during mkfs. + +Using FALLOC_FL_ZERO_RANGE is faster in this case than writing +a bunch of zeros across a wire. + +Signed-off-by: Eric Sandeen +Reviewed-by: Christoph Hellwig +Signed-off-by: Eric Sandeen +--- + include/builddefs.in | 3 +++ + include/linux.h | 22 ++++++++++++++++++++++ + libxfs/rdwr.c | 15 +++++++++++---- + 3 files changed, 36 insertions(+), 4 deletions(-) + +diff --git a/include/builddefs.in b/include/builddefs.in +index 4700b52..1dd27f7 100644 +--- a/include/builddefs.in ++++ b/include/builddefs.in +@@ -144,6 +144,9 @@ endif + ifeq ($(HAVE_GETFSMAP),yes) + PCFLAGS+= -DHAVE_GETFSMAP + endif ++ifeq ($(HAVE_FALLOCATE),yes) ++PCFLAGS += -DHAVE_FALLOCATE ++endif + + LIBICU_LIBS = @libicu_LIBS@ + LIBICU_CFLAGS = @libicu_CFLAGS@ +diff --git a/include/linux.h b/include/linux.h +index 8f3c32b..57726bb 100644 +--- a/include/linux.h ++++ b/include/linux.h +@@ -20,6 +20,10 @@ + #include + #include + #include ++#include ++#if defined(HAVE_FALLOCATE) ++#include ++#endif + #ifdef OVERRIDE_SYSTEM_FSXATTR + # define fsxattr sys_fsxattr + #endif +@@ -164,6 +168,24 @@ static inline void platform_mntent_close(struct mntent_cursor * cursor) + endmntent(cursor->mtabp); + } + ++#if defined(FALLOC_FL_ZERO_RANGE) ++static inline int ++platform_zero_range( ++ int fd, ++ xfs_off_t start, ++ size_t len) ++{ ++ int ret; ++ ++ ret = fallocate(fd, FALLOC_FL_ZERO_RANGE, start, len); ++ if (!ret) ++ return 0; ++ return -errno; ++} ++#else ++#define platform_zero_range(fd, s, l) (-EOPNOTSUPP) ++#endif ++ + /* + * Check whether we have to define FS_IOC_FS[GS]ETXATTR ourselves. These + * are a copy of the definitions moved to linux/uapi/fs.h in the 4.5 kernel, +diff --git a/libxfs/rdwr.c b/libxfs/rdwr.c +index 0d9d720..e2d9d79 100644 +--- a/libxfs/rdwr.c ++++ b/libxfs/rdwr.c +@@ -61,8 +61,18 @@ libxfs_device_zero(struct xfs_buftarg *btp, xfs_daddr_t start, uint len) + { + xfs_off_t start_offset, end_offset, offset; + ssize_t zsize, bytes; ++ size_t len_bytes; + char *z; +- int fd; ++ int error, fd; ++ ++ fd = libxfs_device_to_fd(btp->dev); ++ start_offset = LIBXFS_BBTOOFF64(start); ++ ++ /* try to use special zeroing methods, fall back to writes if needed */ ++ len_bytes = LIBXFS_BBTOOFF64(len); ++ error = platform_zero_range(fd, start_offset, len_bytes); ++ if (!error) ++ return 0; + + zsize = min(BDSTRAT_SIZE, BBTOB(len)); + if ((z = memalign(libxfs_device_alignment(), zsize)) == NULL) { +@@ -73,9 +83,6 @@ libxfs_device_zero(struct xfs_buftarg *btp, xfs_daddr_t start, uint len) + } + memset(z, 0, zsize); + +- fd = libxfs_device_to_fd(btp->dev); +- start_offset = LIBXFS_BBTOOFF64(start); +- + if ((lseek(fd, start_offset, SEEK_SET)) < 0) { + fprintf(stderr, _("%s: %s seek to offset %llu failed: %s\n"), + progname, __FUNCTION__, +-- +2.9.5 + diff --git a/SPECS/xfsprogs.spec b/SPECS/xfsprogs.spec index 22dfba7..1af6b15 100644 --- a/SPECS/xfsprogs.spec +++ b/SPECS/xfsprogs.spec @@ -1,7 +1,7 @@ Summary: Utilities for managing the XFS filesystem Name: xfsprogs Version: 5.0.0 -Release: 2%{?dist} +Release: 4%{?dist} License: GPL+ and LGPLv2+ Group: System Environment/Base URL: https://xfs.wiki.kernel.org @@ -22,6 +22,9 @@ Patch1: xfsprogs-5.1.0-mkfs-validate-start-and-end-of-aligned-logs.patch Patch2: xfsprogs-5.1.0-mkfs-don-t-use-xfs_verify_fsbno-before-m_sb-is-fully.patch Patch3: xfsprogs-5.1.0-xfsprogs-Fix-uninitialized-cfg-lsunit.patch Patch4: xfsprogs-5.3.0-xfs_growfs-allow-mounted-device-node-as-argument.patch +Patch5: xfsprogs-5.5.0-libxfs-use-FALLOC_FL_ZERO_RANGE-in-libxfs_device_zer.patch +Patch6: xfsprogs-5.4.0-mkfs-Break-block-discard-into-chunks-of-2-GB.patch +Patch7: xfsprogs-5.4.0-mkfs-tidy-up-discard-notifications.patch %description A set of commands to use the XFS filesystem, including mkfs.xfs. @@ -57,6 +60,9 @@ also want to install xfsprogs. %patch2 -p1 %patch3 -p1 %patch4 -p1 +%patch5 -p1 +%patch6 -p1 +%patch7 -p1 %build export tagname=CC @@ -116,6 +122,12 @@ rm -rf $RPM_BUILD_ROOT/%{_mandir}/man8/xfs_scrub* %{_libdir}/*.so %changelog +* Wed Jun 03 2020 Eric Sandeen 5.0.0-4 +- mkfs.xfs: inform user about discard, and make interruptable (#1836414) + +* Mon Apr 20 2020 Eric Sandeen 5.0.0-3 +- mkfs.xfs: use faster log zeroing on supported devices (#1755046) + * Sat Dec 14 2019 Eric Sandeen 5.0.0-2 - mkfs.xfs: validate log stripe unit alignment (#1632596) - xfs_growfs: allow mounted device node as argument (#1765217)