From 4a32b9e928b80001dbda7b9576a96b7cb4a26850 Mon Sep 17 00:00:00 2001 From: Dave Chinner Date: Tue, 10 May 2016 17:16:06 +1000 Subject: [PATCH] xfsprogs: use common code for multi-disk detection Both xfs_repair and mkfs.xfs need to agree on what is a "multidisk: configuration - mkfs for determining the AG count of the filesystem, repair for determining how to automatically parallelise it's execution. This requires a bunch of common defines that both mkfs and reapir need to share. In fact, most of the defines in xfs_mkfs.h could be shared with other programs (i.e. all the defaults mkfs uses) and so it is simplest to move xfs_mkfs.h to the shared include directory and add the new defines to it directly. Signed-off-by: Dave Chinner Signed-off-by: Jan Tulak Reviewed-by: Eric Sandeen Signed-off-by: Dave Chinner --- include/Makefile | 5 +- mkfs/xfs_mkfs.h => include/xfs_multidisk.h | 15 ++++-- mkfs/Makefile | 2 +- mkfs/maxtrres.c | 2 +- mkfs/proto.c | 2 +- mkfs/xfs_mkfs.c | 57 ++++++++++++---------- repair/xfs_repair.c | 44 ++++++++++++++++- 7 files changed, 91 insertions(+), 36 deletions(-) rename mkfs/xfs_mkfs.h => include/xfs_multidisk.h (88%) diff --git a/include/Makefile b/include/Makefile index 6148756e4..5fb443aa4 100644 --- a/include/Makefile +++ b/include/Makefile @@ -33,13 +33,16 @@ LIBHFILES = libxfs.h \ xfs_log_recover.h \ xfs_metadump.h \ xfs_mount.h \ + xfs_quota_defs.h \ + xfs_sb.h \ + xfs_shared.h \ xfs_trace.h \ xfs_trans.h \ command.h \ input.h \ path.h \ project.h \ - platform_defs.h \ + platform_defs.h HFILES = handle.h \ jdm.h \ diff --git a/mkfs/xfs_mkfs.h b/include/xfs_multidisk.h similarity index 88% rename from mkfs/xfs_mkfs.h rename to include/xfs_multidisk.h index 128068e8b..4b99992f8 100644 --- a/mkfs/xfs_mkfs.h +++ b/include/xfs_multidisk.h @@ -15,8 +15,8 @@ * along with this program; if not, write the Free Software Foundation, * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */ -#ifndef __XFS_MKFS_H__ -#define __XFS_MKFS_H__ +#ifndef __XFS_MULTIDISK_H__ +#define __XFS_MULTIDISK_H__ #define XFS_DFL_SB_VERSION_BITS \ (XFS_SB_VERSION_NLINKBIT | \ @@ -70,6 +70,15 @@ #define XFS_MAX_AGNUMBER ((xfs_agnumber_t)(NULLAGNUMBER - 1)) +/* + * These values define what we consider a "multi-disk" filesystem. That is, a + * filesystem that is likely to be made up of multiple devices, and hence have + * some level of parallelism available to it at the IO level. + */ +#define XFS_MULTIDISK_AGLOG 5 /* 32 AGs */ +#define XFS_NOMULTIDISK_AGLOG 2 /* 4 AGs */ +#define XFS_MULTIDISK_AGCOUNT (1 << XFS_MULTIDISK_AGLOG) + /* xfs_mkfs.c */ extern int isdigits (char *str); @@ -86,4 +95,4 @@ extern int max_trans_res (int crcs_enabled, int dirversion, int sectorlog, int blocklog, int inodelog, int dirblocklog, int logversion, int log_sunit, int finobt); -#endif /* __XFS_MKFS_H__ */ +#endif /* __XFS_MULTIDISK_H__ */ diff --git a/mkfs/Makefile b/mkfs/Makefile index 570ab0749..63ba4eca1 100644 --- a/mkfs/Makefile +++ b/mkfs/Makefile @@ -7,7 +7,7 @@ include $(TOPDIR)/include/builddefs LTCOMMAND = mkfs.xfs -HFILES = xfs_mkfs.h +HFILES = CFILES = maxtrres.c proto.c xfs_mkfs.c LLDLIBS += $(LIBBLKID) $(LIBXFS) $(LIBUUID) $(LIBRT) $(LIBPTHREAD) diff --git a/mkfs/maxtrres.c b/mkfs/maxtrres.c index b97d020a6..f48a0f748 100644 --- a/mkfs/maxtrres.c +++ b/mkfs/maxtrres.c @@ -25,7 +25,7 @@ */ #include "libxfs.h" -#include "xfs_mkfs.h" +#include "xfs_multidisk.h" int max_trans_res( diff --git a/mkfs/proto.c b/mkfs/proto.c index d99e96589..f3327d1b5 100644 --- a/mkfs/proto.c +++ b/mkfs/proto.c @@ -18,7 +18,7 @@ #include "libxfs.h" #include -#include "xfs_mkfs.h" +#include "xfs_multidisk.h" /* * Prototypes for internal functions. diff --git a/mkfs/xfs_mkfs.c b/mkfs/xfs_mkfs.c index 4c3a80262..5527b872c 100644 --- a/mkfs/xfs_mkfs.c +++ b/mkfs/xfs_mkfs.c @@ -21,7 +21,7 @@ #ifdef ENABLE_BLKID # include #endif /* ENABLE_BLKID */ -#include "xfs_mkfs.h" +#include "xfs_multidisk.h" /* * Device topology information. @@ -664,43 +664,46 @@ calc_default_ag_geometry( } /* - * For the remainder we choose an AG size based on the - * number of data blocks available, trying to keep the - * number of AGs relatively small (especially compared - * to the original algorithm). AG count is calculated - * based on the preferred AG size, not vice-versa - the - * count can be increased by growfs, so prefer to use - * smaller counts at mkfs time. - * - * For a single underlying storage device between 128MB - * and 4TB in size, just use 4 AGs, otherwise scale up - * smoothly between min/max AG sizes. + * For a single underlying storage device over 4TB in size + * use the maximum AG size. Between 128MB and 4TB, just use + * 4 AGs and scale up smoothly between min/max AG sizes. */ - - if (!multidisk && dblocks >= MEGABYTES(128, blocklog)) { + if (!multidisk) { if (dblocks >= TERABYTES(4, blocklog)) { blocks = XFS_AG_MAX_BLOCKS(blocklog); goto done; + } else if (dblocks >= MEGABYTES(128, blocklog)) { + shift = XFS_NOMULTIDISK_AGLOG; + goto calc_blocks; } - shift = 2; - } else if (dblocks > GIGABYTES(512, blocklog)) - shift = 5; - else if (dblocks > GIGABYTES(8, blocklog)) - shift = 4; - else if (dblocks >= MEGABYTES(128, blocklog)) - shift = 3; - else if (dblocks >= MEGABYTES(64, blocklog)) - shift = 2; - else if (dblocks >= MEGABYTES(32, blocklog)) - shift = 1; - else - shift = 0; + } + + /* + * For the multidisk configs we choose an AG count based on the number + * of data blocks available, trying to keep the number of AGs higher + * than the single disk configurations. This makes the assumption that + * larger filesystems have more parallelism available to them. + */ + shift = XFS_MULTIDISK_AGLOG; + if (dblocks <= GIGABYTES(512, blocklog)) + shift--; + if (dblocks <= GIGABYTES(8, blocklog)) + shift--; + if (dblocks < MEGABYTES(128, blocklog)) + shift--; + if (dblocks < MEGABYTES(64, blocklog)) + shift--; + if (dblocks < MEGABYTES(32, blocklog)) + shift--; + /* * If dblocks is not evenly divisible by the number of * desired AGs, round "blocks" up so we don't lose the * last bit of the filesystem. The same principle applies * to the AG count, so we don't lose the last AG! */ +calc_blocks: + ASSERT(shift >= 0 && shift <= XFS_MULTIDISK_AGLOG); blocks = dblocks >> shift; if (dblocks & xfs_mask32lo(shift)) { if (blocks < XFS_AG_MAX_BLOCKS(blocklog)) diff --git a/repair/xfs_repair.c b/repair/xfs_repair.c index 5d5f3aa85..9d91f2df5 100644 --- a/repair/xfs_repair.c +++ b/repair/xfs_repair.c @@ -19,6 +19,7 @@ #include "libxfs.h" #include "libxlog.h" #include +#include "xfs_multidisk.h" #include "avl.h" #include "avl64.h" #include "globals.h" @@ -589,6 +590,33 @@ format_log_max_lsn( XLOG_FMT, new_cycle, true); } +/* + * mkfs increases the AG count for "multidisk" configurations, we want + * to target these for an increase in thread count. Hence check the superlock + * geometry information to determine if mkfs considered this a multidisk + * configuration. + */ +static bool +is_multidisk_filesystem( + struct xfs_mount *mp) +{ + struct xfs_sb *sbp = &mp->m_sb; + + /* High agcount filesystems are always considered "multidisk" */ + if (sbp->sb_agcount >= XFS_MULTIDISK_AGCOUNT) + return true; + + /* + * If it doesn't have a sunit/swidth, mkfs didn't consider it a + * multi-disk array, so we don't either. + */ + if (!sbp->sb_unit) + return false; + + ASSERT(sbp->sb_width); + return true; +} + int main(int argc, char **argv) { @@ -729,9 +757,21 @@ main(int argc, char **argv) * threads/CPU as this is enough threads to saturate a CPU on fast * devices, yet few enough that it will saturate but won't overload slow * devices. + * + * Multidisk filesystems can handle more IO parallelism so we should try + * to process multiple AGs at a time in such a configuration to try to + * saturate the underlying storage and speed the repair process. Only do + * this if prefetching is enabled. */ - if (!ag_stride && glob_agcount >= 16 && do_prefetch) - ag_stride = 15; + if (!ag_stride && do_prefetch && is_multidisk_filesystem(mp)) { + /* + * For small agcount multidisk systems, just double the + * parallelism. For larger AG count filesystems (32 and above) + * use more parallelism, and linearly increase the parallelism + * with the number of AGs. + */ + ag_stride = min(glob_agcount, XFS_MULTIDISK_AGCOUNT / 2) - 1; + } if (ag_stride) { int max_threads = platform_nproc() * 8; -- 2.39.2