| lists.openwall.net | lists / announce owl-users owl-dev john-users john-dev passwdqc-users yescrypt popa3d-users / oss-security kernel-hardening musl sabotage tlsify passwords / crypt-dev xvendor / Bugtraq Full-Disclosure linux-kernel linux-netdev linux-ext4 linux-hardening linux-cve-announce PHC | |
|
Open Source and information security mailing list archives
| ||
|
Message-Id: <20250408104209.1852036-12-john.g.garry@oracle.com>
Date: Tue, 8 Apr 2025 10:42:08 +0000
From: John Garry <john.g.garry@...cle.com>
To: brauner@...nel.org, djwong@...nel.org, hch@....de, viro@...iv.linux.org.uk,
jack@...e.cz, cem@...nel.org
Cc: linux-fsdevel@...r.kernel.org, dchinner@...hat.com,
linux-xfs@...r.kernel.org, linux-kernel@...r.kernel.org,
ojaswin@...ux.ibm.com, ritesh.list@...il.com,
martin.petersen@...cle.com, linux-ext4@...r.kernel.org,
linux-block@...r.kernel.org, catherine.hoang@...cle.com,
John Garry <john.g.garry@...cle.com>
Subject: [PATCH v6 11/12] xfs: add xfs_compute_atomic_write_unit_max()
Now that CoW-based atomic writes are supported, update the max size of an
atomic write for the data device.
The limit of a CoW-based atomic write will be the limit of the number of
logitems which can fit into a single transaction.
In addition, the max atomic write size needs to be aligned to the agsize.
Limit the size of atomic writes to the greatest power-of-two factor of the
agsize so that allocations for an atomic write will always be aligned
compatibly with the alignment requirements of the storage.
rtvol is not commonly used, so it is not very important to support large
atomic writes there initially.
Furthermore, adding large atomic writes for rtvol would be complicated due
to alignment already offered by rtextsize and also the limitation of
reflink support only be possible for rtextsize is a power-of-2.
Function xfs_atomic_write_logitems() is added to find the limit the number
of log items which can fit in a single transaction.
Darrick Wong contributed the changes in xfs_atomic_write_logitems()
originally, but may now be outdated by [0].
[0] https://lore.kernel.org/linux-xfs/20250406172227.GC6307@frogsfrogsfrogs/
Signed-off-by: John Garry <john.g.garry@...cle.com>
---
fs/xfs/xfs_mount.c | 36 ++++++++++++++++++++++++++++++++++++
fs/xfs/xfs_mount.h | 5 +++++
fs/xfs/xfs_super.c | 22 ++++++++++++++++++++++
fs/xfs/xfs_super.h | 1 +
4 files changed, 64 insertions(+)
diff --git a/fs/xfs/xfs_mount.c b/fs/xfs/xfs_mount.c
index 00b53f479ece..27a737202637 100644
--- a/fs/xfs/xfs_mount.c
+++ b/fs/xfs/xfs_mount.c
@@ -666,6 +666,37 @@ xfs_agbtree_compute_maxlevels(
mp->m_agbtree_maxlevels = max(levels, mp->m_refc_maxlevels);
}
+static inline void
+xfs_compute_atomic_write_unit_max(
+ struct xfs_mount *mp)
+{
+ xfs_agblock_t agsize = mp->m_sb.sb_agblocks;
+ unsigned int max_extents_logitems;
+ unsigned int max_agsize;
+
+ if (!xfs_has_reflink(mp)) {
+ mp->m_atomic_write_unit_max = 1;
+ return;
+ }
+
+ /*
+ * Find limit according to logitems.
+ */
+ max_extents_logitems = xfs_atomic_write_logitems(mp);
+
+ /*
+ * Also limit the size of atomic writes to the greatest power-of-two
+ * factor of the agsize so that allocations for an atomic write will
+ * always be aligned compatibly with the alignment requirements of the
+ * storage.
+ * The greatest power-of-two is the value according to the lowest bit
+ * set.
+ */
+ max_agsize = 1 << (ffs(agsize) - 1);
+
+ mp->m_atomic_write_unit_max = min(max_extents_logitems, max_agsize);
+}
+
/* Compute maximum possible height for realtime btree types for this fs. */
static inline void
xfs_rtbtree_compute_maxlevels(
@@ -842,6 +873,11 @@ xfs_mountfs(
*/
xfs_trans_init(mp);
+ /*
+ * Pre-calculate atomic write unit max.
+ */
+ xfs_compute_atomic_write_unit_max(mp);
+
/*
* Allocate and initialize the per-ag data.
*/
diff --git a/fs/xfs/xfs_mount.h b/fs/xfs/xfs_mount.h
index 799b84220ebb..4462bffbf0ff 100644
--- a/fs/xfs/xfs_mount.h
+++ b/fs/xfs/xfs_mount.h
@@ -230,6 +230,11 @@ typedef struct xfs_mount {
bool m_update_sb; /* sb needs update in mount */
unsigned int m_max_open_zones;
+ /*
+ * data device max atomic write.
+ */
+ xfs_extlen_t m_atomic_write_unit_max;
+
/*
* Bitsets of per-fs metadata that have been checked and/or are sick.
* Callers must hold m_sb_lock to access these two fields.
diff --git a/fs/xfs/xfs_super.c b/fs/xfs/xfs_super.c
index b2dd0c0bf509..42b2b7540507 100644
--- a/fs/xfs/xfs_super.c
+++ b/fs/xfs/xfs_super.c
@@ -615,6 +615,28 @@ xfs_init_mount_workqueues(
return -ENOMEM;
}
+unsigned int
+xfs_atomic_write_logitems(
+ struct xfs_mount *mp)
+{
+ unsigned int efi = xfs_efi_item_overhead(1);
+ unsigned int rui = xfs_rui_item_overhead(1);
+ unsigned int cui = xfs_cui_item_overhead(1);
+ unsigned int bui = xfs_bui_item_overhead(1);
+ unsigned int logres = M_RES(mp)->tr_write.tr_logres;
+
+ /*
+ * Maximum overhead to complete an atomic write ioend in software:
+ * remove data fork extent + remove cow fork extent +
+ * map extent into data fork
+ */
+ unsigned int atomic_logitems =
+ (bui + cui + rui + efi) + (cui + rui) + (bui + rui);
+
+ /* atomic write limits are always a power-of-2 */
+ return rounddown_pow_of_two(logres / (2 * atomic_logitems));
+}
+
STATIC void
xfs_destroy_mount_workqueues(
struct xfs_mount *mp)
diff --git a/fs/xfs/xfs_super.h b/fs/xfs/xfs_super.h
index c0e85c1e42f2..e0f82be9093a 100644
--- a/fs/xfs/xfs_super.h
+++ b/fs/xfs/xfs_super.h
@@ -100,5 +100,6 @@ extern struct workqueue_struct *xfs_discard_wq;
#define XFS_M(sb) ((struct xfs_mount *)((sb)->s_fs_info))
struct dentry *xfs_debugfs_mkdir(const char *name, struct dentry *parent);
+unsigned int xfs_atomic_write_logitems(struct xfs_mount *mp);
#endif /* __XFS_SUPER_H__ */
--
2.31.1
Powered by blists - more mailing lists