Home Home > GIT Browse > openSUSE-15.1
summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorNikolay Borisov <nborisov@suse.com>2019-08-15 09:57:52 +0300
committerNikolay Borisov <nborisov@suse.com>2019-08-15 09:58:03 +0300
commit8ab35cb53a5c52e64569e69ec696c81d4ddac914 (patch)
tree0da445f8f6b12e3a4731c77047e69b29b383774f
parent2e71e21ad9950ece89b926bc8da57d41d4286416 (diff)
xfs: refactor inode chunk alloc/free tx reservation
(bsc#1145235).
-rw-r--r--patches.suse/xfs-refactor-inode-chunk-alloc-free-tx-reservation.patch169
-rw-r--r--series.conf1
2 files changed, 170 insertions, 0 deletions
diff --git a/patches.suse/xfs-refactor-inode-chunk-alloc-free-tx-reservation.patch b/patches.suse/xfs-refactor-inode-chunk-alloc-free-tx-reservation.patch
new file mode 100644
index 0000000000..36a8507176
--- /dev/null
+++ b/patches.suse/xfs-refactor-inode-chunk-alloc-free-tx-reservation.patch
@@ -0,0 +1,169 @@
+From: Brian Foster <bfoster@redhat.com>
+Date: Mon, 8 Jan 2018 10:41:38 -0800
+Subject: xfs: refactor inode chunk alloc/free tx reservation
+Git-commit: 57af33e451b73f56feb428f5856cdf6e4e0c60cd
+Patch-mainline: v4.16-rc1
+References: bsc#1145235
+
+The reservation for the various forms of inode allocation is
+scattered across several different functions. This includes two
+variants of chunk allocation (v5 icreate transactions vs. older
+create transactions) and the inode free transaction.
+
+To clean up some of this code and clarify the purpose of specific
+allocfree reservations, continue the pattern of defining helper
+functions for smaller operational units of broader transactions.
+Refactor the reservation into an inode chunk alloc/free helper that
+considers the various conditions based on filesystem format.
+
+An inode chunk free involves an extent free and buffer
+invalidations. The latter requires reservation for log headers only.
+An inode chunk allocation modifies the free space btrees and logs
+the chunk on v4 supers. v5 supers initialize the inode chunk using
+ordered buffers and so do not log the chunk.
+
+As a side effect of this refactoring, add one more allocfree res to
+the ifree transaction. Technically this does not serve a specific
+purpose because inode chunks are freed via deferred operations and
+thus occur after a transaction roll. tr_ifree has a bit of a history
+of tx overruns caused by too many agfl fixups during sustained file
+deletion workloads, so add this extra reservation as a form of
+padding nonetheless.
+
+Signed-off-by: Brian Foster <bfoster@redhat.com>
+Reviewed-by: Dave Chinner <dchinner@redhat.com>
+Reviewed-by: Darrick J. Wong <darrick.wong@oracle.com>
+Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
+Acked-by: Nikolay Borisov <nborisov@suse.com>
+---
+ fs/xfs/libxfs/xfs_trans_resv.c | 64 ++++++++++++++++++++++++++++++++----------
+ 1 file changed, 49 insertions(+), 15 deletions(-)
+
+diff --git a/fs/xfs/libxfs/xfs_trans_resv.c b/fs/xfs/libxfs/xfs_trans_resv.c
+index 19f3a226a357..75259a1346eb 100644
+--- a/fs/xfs/libxfs/xfs_trans_resv.c
++++ b/fs/xfs/libxfs/xfs_trans_resv.c
+@@ -34,6 +34,9 @@
+ #include "xfs_trans_space.h"
+ #include "xfs_trace.h"
+
++#define _ALLOC true
++#define _FREE false
++
+ /*
+ * A buffer has a format structure overhead in the log in addition
+ * to the data, so we need to take this into account when reserving
+@@ -171,6 +174,41 @@ xfs_calc_finobt_res(
+ return xfs_calc_inobt_res(mp);
+ }
+
++/*
++ * Calculate the reservation required to allocate or free an inode chunk. This
++ * includes:
++ *
++ * the allocation btrees: 2 trees * (max depth - 1) * block size
++ * the inode chunk: m_ialloc_blks * N
++ *
++ * The size N of the inode chunk reservation depends on whether it is for
++ * allocation or free and which type of create transaction is in use. An inode
++ * chunk free always invalidates the buffers and only requires reservation for
++ * headers (N == 0). An inode chunk allocation requires a chunk sized
++ * reservation on v4 and older superblocks to initialize the chunk. No chunk
++ * reservation is required for allocation on v5 supers, which use ordered
++ * buffers to initialize.
++ */
++STATIC uint
++xfs_calc_inode_chunk_res(
++ struct xfs_mount *mp,
++ bool alloc)
++{
++ uint res, size = 0;
++
++ res = xfs_calc_buf_res(xfs_allocfree_log_count(mp, 1),
++ XFS_FSB_TO_B(mp, 1));
++ if (alloc) {
++ /* icreate tx uses ordered buffers */
++ if (xfs_sb_version_hascrc(&mp->m_sb))
++ return res;
++ size = XFS_FSB_TO_B(mp, 1);
++ }
++
++ res += xfs_calc_buf_res(mp->m_ialloc_blks, size);
++ return res;
++}
++
+ /*
+ * Various log reservation values.
+ *
+@@ -379,8 +417,7 @@ xfs_calc_create_resv_modify(
+ * For create we can allocate some inodes giving:
+ * the agi and agf of the ag getting the new inodes: 2 * sectorsize
+ * the superblock for the nlink flag: sector size
+- * the inode blocks allocated: mp->m_ialloc_blks * blocksize
+- * the allocation btrees: 2 trees * (max depth - 1) * block size
++ * the inode chunk (allocation/init)
+ * the inode btree (record insertion)
+ */
+ STATIC uint
+@@ -389,9 +426,7 @@ xfs_calc_create_resv_alloc(
+ {
+ return xfs_calc_buf_res(2, mp->m_sb.sb_sectsize) +
+ mp->m_sb.sb_sectsize +
+- xfs_calc_buf_res(mp->m_ialloc_blks, XFS_FSB_TO_B(mp, 1)) +
+- xfs_calc_buf_res(xfs_allocfree_log_count(mp, 1),
+- XFS_FSB_TO_B(mp, 1)) +
++ xfs_calc_inode_chunk_res(mp, _ALLOC) +
+ xfs_calc_inobt_res(mp);
+ }
+
+@@ -408,7 +443,7 @@ __xfs_calc_create_reservation(
+ * For icreate we can allocate some inodes giving:
+ * the agi and agf of the ag getting the new inodes: 2 * sectorsize
+ * the superblock for the nlink flag: sector size
+- * the allocation btrees: 2 trees * (max depth - 1) * block size
++ * the inode chunk (allocation, no init)
+ * the inobt (record insertion)
+ * the finobt (record insertion)
+ */
+@@ -418,8 +453,7 @@ xfs_calc_icreate_resv_alloc(
+ {
+ return xfs_calc_buf_res(2, mp->m_sb.sb_sectsize) +
+ mp->m_sb.sb_sectsize +
+- xfs_calc_buf_res(xfs_allocfree_log_count(mp, 1),
+- XFS_FSB_TO_B(mp, 1)) +
++ xfs_calc_inode_chunk_res(mp, _ALLOC) +
+ xfs_calc_inobt_res(mp) +
+ xfs_calc_finobt_res(mp);
+ }
+@@ -485,15 +519,15 @@ xfs_calc_symlink_reservation(
+ * the inode being freed: inode size
+ * the super block free inode counter, AGF and AGFL: sector size
+ * the on disk inode (agi unlinked list removal)
+- * the inode chunk is marked stale (headers only)
++ * the inode chunk (invalidated, headers only)
+ * the inode btree
+ * the finobt (record insertion, removal or modification)
+ *
+- * Note that the allocfree res. for the inode chunk itself is not included
+- * because the extent free occurs after a transaction roll. We could take the
+- * maximum of the pre/post roll operations, but the pre-roll reservation already
+- * includes at least one allocfree res. for the inobt and is thus guaranteed to
+- * be larger.
++ * Note that the inode chunk res. includes an allocfree res. for freeing of the
++ * inode chunk. This is technically extraneous because the inode chunk free is
++ * deferred (it occurs after a transaction roll). Include the extra reservation
++ * anyways since we've had reports of ifree transaction overruns due to too many
++ * agfl fixups during inode chunk frees.
+ */
+ STATIC uint
+ xfs_calc_ifree_reservation(
+@@ -503,7 +537,7 @@ xfs_calc_ifree_reservation(
+ xfs_calc_inode_res(mp, 1) +
+ xfs_calc_buf_res(3, mp->m_sb.sb_sectsize) +
+ xfs_calc_iunlink_remove_reservation(mp) +
+- xfs_calc_buf_res(mp->m_ialloc_blks, 0) +
++ xfs_calc_inode_chunk_res(mp, _FREE) +
+ xfs_calc_inobt_res(mp) +
+ xfs_calc_finobt_res(mp);
+ }
+
diff --git a/series.conf b/series.conf
index 7b80adb3d6..a4fcba33c8 100644
--- a/series.conf
+++ b/series.conf
@@ -11984,6 +11984,7 @@
patches.suse/xfs-fix-up-agi-unlinked-list-reservations.patch
patches.suse/xfs-truncate-transaction-does-not-modify-the-inobt.patch
patches.suse/xfs-include-an-allocfree-res-for-inobt-modifications.patch
+ patches.suse/xfs-refactor-inode-chunk-alloc-free-tx-reservation.patch
patches.fixes/0004-iomap-report-collisions-between-directio-and-buffere.patch
patches.fixes/xfs-call-xfs_qm_dqattach-before-performing-reflink-o.patch
patches.fixes/xfs-preserve-i_rdev-when-recycling-a-reclaimable-inode.patch