large atomic writes for xfs
Subsystems (6)
v9 cover large atomic writes for xfs
Currently atomic write support for xfs is limited to writing a single block as we have no way to guarantee alignment and that the write covers a single extent.
This series introduces a method to issue atomic writes via a software-based method.
The software-based method is used as a fallback for when attempting to issue an atomic write over misaligned or multiple extents.
For xfs, this support is based on reflink CoW support.
The basic idea of this CoW method is to alloc a range in the CoW fork, write the data, and atomically update the mapping.
Initial mysql performance testing has shown this method to perform ok. However, there we are only using 16K atomic writes (and 4K block size), so typically - and thankfully - this software fallback method won't be used often.
For other FSes which want large atomics writes and don't support CoW, I think that they can follow the example in [0].
Catherine is currently working on further xfstests for this feature, which we hope to share soon.
Based on f0447f80aec8 (xfs/next-rc, xfs/for-next) xfs: remove duplicate Zoned Filesystems sections in admin-guide
[0] https://lore.kernel.org/linux-xfs/[email protected]/
Differences to v8:
- Darrick reworked patch for mount option
- Darrick reworked patch to ignore HW
- Minor changes and cleanups from Darrick
- Rework some commit messages (Christoph)
- Pick up RB tags from Christoph (thanks!)
Differences to v7:
- Add patch for mp hw awu max and min
- Fixed for awu max mount option (Darrick)
Differences to v6:
- log item sizes updates (Darrick)
- rtvol support (Darrick)
- mount option for atomic writes (Darrick)
- Add RB tags from Darrick and Christoph (Thanks!)
Darrick J. Wong (4):
xfs: add helpers to compute log item overhead
xfs: add helpers to compute transaction reservation for finishing
intent items
xfs: ignore HW which cannot atomic write a single block
xfs: allow sysadmins to specify a maximum atomic write limit at mount
time
John Garry (11):
fs: add atomic write unit max opt to statx
xfs: rename xfs_inode_can_atomicwrite() ->
xfs_inode_can_hw_atomic_write()
xfs: allow block allocator to take an alignment hint
xfs: refactor xfs_reflink_end_cow_extent()
xfs: refine atomic write size check in xfs_file_write_iter()
xfs: add xfs_atomic_write_cow_iomap_begin()
xfs: add large atomic writes checks in xfs_direct_write_iomap_begin()
xfs: commit CoW-based atomic writes atomically
xfs: add xfs_file_dio_write_atomic()
xfs: add xfs_compute_atomic_write_unit_max()
xfs: update atomic write limits
Documentation/admin-guide/xfs.rst | 11 + block/bdev.c | 3 +- fs/ext4/inode.c | 2 +- fs/stat.c | 6 +- fs/xfs/libxfs/xfs_bmap.c | 5 + fs/xfs/libxfs/xfs_bmap.h | 6 +- fs/xfs/libxfs/xfs_log_rlimit.c | 4 + fs/xfs/libxfs/xfs_trans_resv.c | 343 +++++++++++++++++++++++++++--- fs/xfs/libxfs/xfs_trans_resv.h | 25 +++ fs/xfs/xfs_bmap_item.c | 10 + fs/xfs/xfs_bmap_item.h | 3 + fs/xfs/xfs_buf.c | 41 +++- fs/xfs/xfs_buf.h | 3 +- fs/xfs/xfs_buf_item.c | 19 ++ fs/xfs/xfs_buf_item.h | 3 + fs/xfs/xfs_extfree_item.c | 10 + fs/xfs/xfs_extfree_item.h | 3 + fs/xfs/xfs_file.c | 87 +++++++- fs/xfs/xfs_inode.h | 14 +- fs/xfs/xfs_iomap.c | 190 ++++++++++++++++- fs/xfs/xfs_iomap.h | 1 + fs/xfs/xfs_iops.c | 76 ++++++- fs/xfs/xfs_iops.h | 3 + fs/xfs/xfs_log_cil.c | 4 +- fs/xfs/xfs_log_priv.h | 13 ++ fs/xfs/xfs_mount.c | 166 +++++++++++++++ fs/xfs/xfs_mount.h | 17 ++ fs/xfs/xfs_refcount_item.c | 10 + fs/xfs/xfs_refcount_item.h | 3 + fs/xfs/xfs_reflink.c | 146 ++++++++++--- fs/xfs/xfs_reflink.h | 6 + fs/xfs/xfs_rmap_item.c | 10 + fs/xfs/xfs_rmap_item.h | 3 + fs/xfs/xfs_super.c | 58 ++++- fs/xfs/xfs_trace.h | 115 ++++++++++ include/linux/fs.h | 3 +- include/linux/stat.h | 1 + include/uapi/linux/stat.h | 8 +- 38 files changed, 1322 insertions(+), 109 deletions(-)
Signature · 1 line
2.31.1
PATCH v9 1/15 fs: add atomic write unit max opt to statx
XFS will be able to support large atomic writes (atomic write > 1x block) in future. This will be achieved by using different operating methods, depending on the size of the write.
Specifically a new method of operation based in FS atomic extent remapping will be supported in addition to the current HW offload-based method.
The FS method will generally be appreciably slower performing than the HW-offload method. However the FS method will be typically able to contribute to achieving a larger atomic write unit max limit.
XFS will support a hybrid mode, where HW offload method will be used when possible, i.e. HW offload is used when the length of the write is supported, and for other times FS-based atomic writes will be used.
As such, there is an atomic write length at which the user may experience appreciably slower performance.
Advertise this limit in a new statx field, stx_atomic_write_unit_max_opt.
When zero, it means that there is no such performance boundary.
Masks STATX{_ATTR}_WRITE_ATOMIC can be used to get this new field. This is ok for older kernels which don't support this new field, as they would report 0 in this field (from zeroing in cp_statx()) already. Furthermore those older kernels don't support large atomic writes - apart from block fops, but there would be consistent performance there for atomic writes in range [unit min, unit max].
--- block/bdev.c | 3 ++- fs/ext4/inode.c | 2 +- fs/stat.c | 6 +++++- fs/xfs/xfs_iops.c | 2 +- include/linux/fs.h | 3 ++- include/linux/stat.h | 1 + include/uapi/linux/stat.h | 8 ++++++-- 7 files changed, 18 insertions(+), 7 deletions(-)
block/bdev.c +2 -1
@@ -1301,7 +1301,8 @@ void bdev_statx(struct path *path, struct kstat *stat,generic_fill_statx_atomic_writes (stat,queue_atomic_write_unit_min_bytes (bd_queue), -queue_atomic_write_unit_max_bytes (bd_queue)); +queue_atomic_write_unit_max_bytes (bd_queue), +0 ); } stat->blksize =bdev_io_min (bdev);
fs/ext4/inode.c +1 -1
@@ -5692,7 +5692,7 @@ int ext4_getattr(struct mnt_idmap *idmap, const struct path *path, awu_max = sbi->s_awu_max; } -generic_fill_statx_atomic_writes (stat, awu_min, awu_max); +generic_fill_statx_atomic_writes (stat, awu_min, awu_max,0 ); } flags = ei->i_flags &EXT4_FL_USER_VISIBLE ;
fs/stat.c +5 -1
@@ -136,13 +136,15 @@ EXPORT_SYMBOL(generic_fill_statx_attr);* @stat: Where to fill in the attribute flags * @unit_min: Minimum supported atomic write length in bytes * @unit_max: Maximum supported atomic write length in bytes +* @unit_max_opt: Optimised maximum supported atomic write length in bytes * * Fill in the STATX{_ATTR}_WRITE_ATOMIC flags in the kstat structure from * atomic write unit_min and unit_max values. */ void generic_fill_statx_atomic_writes (struct kstat *stat,unsigned int unit_min, -unsigned int unit_max) +unsigned int unit_max, +unsigned int unit_max_opt) {/* Confirm that the request type is known */ stat->result_mask |=STATX_WRITE_ATOMIC ;
@@ -153,6 +155,7 @@ void generic_fill_statx_atomic_writes(struct kstat *stat,if (unit_min) { stat->atomic_write_unit_min = unit_min; stat->atomic_write_unit_max = unit_max; + stat->atomic_write_unit_max_opt = unit_max_opt;/* Initially only allow 1x segment */ stat->atomic_write_segments_max =1 ;
@@ -732,6 +735,7 @@ cp_statx(const struct kstat *stat, struct statx __user *buffer) tmp.stx_atomic_write_unit_min = stat->atomic_write_unit_min; tmp.stx_atomic_write_unit_max = stat->atomic_write_unit_max; tmp.stx_atomic_write_segments_max = stat->atomic_write_segments_max; + tmp.stx_atomic_write_unit_max_opt = stat->atomic_write_unit_max_opt;return copy_to_user (buffer, &tmp,sizeof (tmp)) ? -EFAULT :0 ; }
fs/xfs/xfs_iops.c +1 -1
@@ -610,7 +610,7 @@ xfs_report_atomic_write(if (xfs_inode_can_atomicwrite (ip)) unit_min = unit_max = ip->i_mount->m_sb.sb_blocksize; -generic_fill_statx_atomic_writes (stat, unit_min, unit_max); +generic_fill_statx_atomic_writes (stat, unit_min, unit_max,0 ); }STATIC int
include/linux/fs.h +2 -1
@@ -3475,7 +3475,8 @@ void generic_fillattr(struct mnt_idmap *, u32, struct inode *, struct kstat *);void generic_fill_statx_attr (struct inode *inode,struct kstat *stat);void generic_fill_statx_atomic_writes (struct kstat *stat,unsigned int unit_min, -unsigned int unit_max); +unsigned int unit_max, +unsigned int unit_max_opt);extern int vfs_getattr_nosec (const struct path *,struct kstat *,u32 ,unsigned int );extern int vfs_getattr (const struct path *,struct kstat *,u32 ,unsigned int );void __inode_add_bytes (struct inode *inode,loff_t bytes);
include/linux/stat.h +1 -0
@@ -57,6 +57,7 @@ struct kstat {u32 dio_read_offset_align;u32 atomic_write_unit_min;u32 atomic_write_unit_max; +u32 atomic_write_unit_max_opt;u32 atomic_write_segments_max; };
include/uapi/linux/stat.h +6 -2
@@ -182,8 +182,12 @@ struct statx {/* File offset alignment for direct I/O reads */ __u32 stx_dio_read_offset_align; -/* 0xb8 */ -__u64 __spare3[9 ];/* Spare space for future expansion */ +/* Optimised max atomic write unit in bytes */ +__u32 stx_atomic_write_unit_max_opt; +__u32 __spare2[1 ]; + +/* 0xc0 */ +__u64 __spare3[8 ];/* Spare space for future expansion */ /* 0x100 */ };
Signature · 1 line
2.31.1
PATCH v9 2/15 xfs: add helpers to compute log item overhead
In reply to John GarryFrom: "Darrick J. Wong" <[email protected]>
Add selected helpers to estimate the transaction reservation required to write various log intent and buffer items to the log. These helpers will be used by the online repair code for more precise estimations of how much work can be done in a single transaction.
--- fs/xfs/xfs_bmap_item.c | 10 ++++++++++ fs/xfs/xfs_bmap_item.h | 3 +++ fs/xfs/xfs_buf_item.c | 19 +++++++++++++++++++ fs/xfs/xfs_buf_item.h | 3 +++ fs/xfs/xfs_extfree_item.c | 10 ++++++++++ fs/xfs/xfs_extfree_item.h | 3 +++ fs/xfs/xfs_log_cil.c | 4 +--- fs/xfs/xfs_log_priv.h | 13 +++++++++++++ fs/xfs/xfs_refcount_item.c | 10 ++++++++++ fs/xfs/xfs_refcount_item.h | 3 +++ fs/xfs/xfs_rmap_item.c | 10 ++++++++++ fs/xfs/xfs_rmap_item.h | 3 +++ 12 files changed, 88 insertions(+), 3 deletions(-)
fs/xfs/xfs_bmap_item.c +10 -0
@@ -77,6 +77,11 @@ xfs_bui_item_size( *nbytes +=xfs_bui_log_format_sizeof (buip->bui_format.bui_nextents); } +unsigned int xfs_bui_log_space (unsigned int nr) +{ +return xlog_item_space (1 ,xfs_bui_log_format_sizeof (nr)); +} +/* * This is called to fill in the vector of log iovecs for the * given bui log item. We use only 1 iovec, and we point that
@@ -168,6 +173,11 @@ xfs_bud_item_size( *nbytes +=sizeof (struct xfs_bud_log_format ); } +unsigned int xfs_bud_log_space (void ) +{ +return xlog_item_space (1 ,sizeof (struct xfs_bud_log_format )); +} +/* * This is called to fill in the vector of log iovecs for the * given bud log item. We use only 1 iovec, and we point that
fs/xfs/xfs_bmap_item.h +3 -0
@@ -72,4 +72,7 @@ struct xfs_bmap_intent;void xfs_bmap_defer_add (struct xfs_trans *tp,struct xfs_bmap_intent *bi); +unsigned int xfs_bui_log_space (unsigned int nr); +unsigned int xfs_bud_log_space (void ); +#endif /* __XFS_BMAP_ITEM_H__ */
fs/xfs/xfs_buf_item.c +19 -0
@@ -103,6 +103,25 @@ xfs_buf_item_size_segment(return ; } +/* +* Compute the worst case log item overhead for an invalidated buffer with the +* given map count and block size. +*/ +unsigned int +xfs_buf_inval_log_space ( +unsigned int map_count, +unsigned int blocksize) +{ +unsigned int chunks =DIV_ROUND_UP (blocksize,XFS_BLF_CHUNK ); +unsigned int bitmap_size =DIV_ROUND_UP (chunks,NBWORD ); +unsigned int ret = + offsetof(struct xfs_buf_log_format , blf_data_map) + + (bitmap_size * sizeof_field(struct xfs_buf_log_format, + blf_data_map[0 ])); + +return ret * map_count; +} +/* * Return the number of log iovecs and space needed to log the given buf log * item.
fs/xfs/xfs_buf_item.h +3 -0
@@ -64,6 +64,9 @@ static inline void xfs_buf_dquot_iodone(struct xfs_buf *bp)void xfs_buf_iodone (struct xfs_buf *);bool xfs_buf_log_check_iovec (struct xfs_log_iovec *iovec); +unsigned int xfs_buf_inval_log_space (unsigned int map_count, +unsigned int blocksize); +extern struct kmem_cache *xfs_buf_item_cache;#endif /* __XFS_BUF_ITEM_H__ */
fs/xfs/xfs_extfree_item.c +10 -0
@@ -83,6 +83,11 @@ xfs_efi_item_size( *nbytes +=xfs_efi_log_format_sizeof (efip->efi_format.efi_nextents); } +unsigned int xfs_efi_log_space (unsigned int nr) +{ +return xlog_item_space (1 ,xfs_efi_log_format_sizeof (nr)); +} +/* * This is called to fill in the vector of log iovecs for the * given efi log item. We use only 1 iovec, and we point that
@@ -254,6 +259,11 @@ xfs_efd_item_size( *nbytes +=xfs_efd_log_format_sizeof (efdp->efd_format.efd_nextents); } +unsigned int xfs_efd_log_space (unsigned int nr) +{ +return xlog_item_space (1 ,xfs_efd_log_format_sizeof (nr)); +} +/* * This is called to fill in the vector of log iovecs for the * given efd log item. We use only 1 iovec, and we point that
fs/xfs/xfs_extfree_item.h +3 -0
@@ -94,4 +94,7 @@ void xfs_extent_free_defer_add(struct xfs_trans *tp,struct xfs_extent_free_item *xefi, struct xfs_defer_pending **dfpp); +unsigned int xfs_efi_log_space (unsigned int nr); +unsigned int xfs_efd_log_space (unsigned int nr); +#endif /* __XFS_EXTFREE_ITEM_H__ */
fs/xfs/xfs_log_cil.c +1 -3
@@ -309,9 +309,7 @@ xlog_cil_alloc_shadow_bufs(* Then round nbytes up to 64-bit alignment so that the initial * buffer alignment is easy to calculate and verify. */ - nbytes += niovecs * - (sizeof (uint64_t ) +sizeof (struct xlog_op_header )); - nbytes =round_up (nbytes,sizeof (uint64_t )); + nbytes =xlog_item_space (niovecs, nbytes);/* * The data buffer needs to start 64-bit aligned, so round up
fs/xfs/xfs_log_priv.h +13 -0
@@ -698,4 +698,17 @@ xlog_kvmalloc( return p; } +/* +* Given a count of iovecs and space for a log item, compute the space we need +* in the log to store that data plus the log headers. +*/ +static inline unsigned int +xlog_item_space ( +unsigned int niovecs, +unsigned int nbytes) +{ + nbytes += niovecs * (sizeof (uint64_t ) +sizeof (struct xlog_op_header )); +return round_up (nbytes,sizeof (uint64_t )); +} +#endif /* __XFS_LOG_PRIV_H__ */
fs/xfs/xfs_refcount_item.c +10 -0
@@ -78,6 +78,11 @@ xfs_cui_item_size( *nbytes +=xfs_cui_log_format_sizeof (cuip->cui_format.cui_nextents); } +unsigned int xfs_cui_log_space (unsigned int nr) +{ +return xlog_item_space (1 ,xfs_cui_log_format_sizeof (nr)); +} +/* * This is called to fill in the vector of log iovecs for the * given cui log item. We use only 1 iovec, and we point that
@@ -179,6 +184,11 @@ xfs_cud_item_size( *nbytes +=sizeof (struct xfs_cud_log_format ); } +unsigned int xfs_cud_log_space (void ) +{ +return xlog_item_space (1 ,sizeof (struct xfs_cud_log_format )); +} +/* * This is called to fill in the vector of log iovecs for the * given cud log item. We use only 1 iovec, and we point that
fs/xfs/xfs_refcount_item.h +3 -0
@@ -76,4 +76,7 @@ struct xfs_refcount_intent;void xfs_refcount_defer_add (struct xfs_trans *tp,struct xfs_refcount_intent *ri); +unsigned int xfs_cui_log_space (unsigned int nr); +unsigned int xfs_cud_log_space (void ); +#endif /* __XFS_REFCOUNT_ITEM_H__ */
fs/xfs/xfs_rmap_item.c +10 -0
@@ -77,6 +77,11 @@ xfs_rui_item_size( *nbytes +=xfs_rui_log_format_sizeof (ruip->rui_format.rui_nextents); } +unsigned int xfs_rui_log_space (unsigned int nr) +{ +return xlog_item_space (1 ,xfs_rui_log_format_sizeof (nr)); +} +/* * This is called to fill in the vector of log iovecs for the * given rui log item. We use only 1 iovec, and we point that
@@ -180,6 +185,11 @@ xfs_rud_item_size( *nbytes +=sizeof (struct xfs_rud_log_format ); } +unsigned int xfs_rud_log_space (void ) +{ +return xlog_item_space (1 ,sizeof (struct xfs_rud_log_format )); +} +/* * This is called to fill in the vector of log iovecs for the * given rud log item. We use only 1 iovec, and we point that
fs/xfs/xfs_rmap_item.h +3 -0
@@ -75,4 +75,7 @@ struct xfs_rmap_intent;void xfs_rmap_defer_add (struct xfs_trans *tp,struct xfs_rmap_intent *ri); +unsigned int xfs_rui_log_space (unsigned int nr); +unsigned int xfs_rud_log_space (void ); +#endif /* __XFS_RMAP_ITEM_H__ */
Signature · 1 line
2.31.1
PATCH v9 3/15 xfs: add helpers to compute transaction reservation for finishing intent items
In reply to John GarryFrom: "Darrick J. Wong" <[email protected]>
In the transaction reservation code, hoist the logic that computes the reservation needed to finish one log intent item into separate helper functions. These will be used in subsequent patches to estimate the number of blocks that an online repair can commit to reaping in the same transaction as the change committing the new data structure.
--- fs/xfs/libxfs/xfs_trans_resv.c | 165 ++++++++++++++++++++++++++------- fs/xfs/libxfs/xfs_trans_resv.h | 18 ++++ 2 files changed, 152 insertions(+), 31 deletions(-)
fs/xfs/libxfs/xfs_trans_resv.c +134 -31
@@ -263,6 +263,42 @@ xfs_rtalloc_block_count(* register overflow from temporaries in the calculations. */ +/* +* Finishing a data device refcount updates (t1): +* the agfs of the ags containing the blocks: nr_ops * sector size +* the refcount btrees: nr_ops * 1 trees * (2 * max depth - 1) * block size +*/ +inline unsigned int +xfs_calc_finish_cui_reservation ( +struct xfs_mount *mp, +unsigned int nr_ops) +{ +if (!xfs_has_reflink (mp)) +return 0 ; + +return xfs_calc_buf_res (nr_ops, mp->m_sb.sb_sectsize) + +xfs_calc_buf_res (xfs_refcountbt_block_count (mp, nr_ops), + mp->m_sb.sb_blocksize); +} + +/* +* Realtime refcount updates (t2); +* the rt refcount inode +* the rtrefcount btrees: nr_ops * 1 trees * (2 * max depth - 1) * block size +*/ +inline unsigned int +xfs_calc_finish_rt_cui_reservation ( +struct xfs_mount *mp, +unsigned int nr_ops) +{ +if (!xfs_has_rtreflink (mp)) +return 0 ; + +return xfs_calc_inode_res (mp,1 ) + +xfs_calc_buf_res (xfs_rtrefcountbt_block_count (mp, nr_ops), + mp->m_sb.sb_blocksize); +} +/* * Compute the log reservation required to handle the refcount update * transaction. Refcount updates are always done via deferred log items.
@@ -280,19 +316,10 @@ xfs_calc_refcountbt_reservation( struct xfs_mount *mp, unsigned int nr_ops) { -unsigned int blksz =XFS_FSB_TO_B (mp,1 ); -unsigned int t1, t2 =0 ; +unsigned int t1, t2; -if (!xfs_has_reflink (mp)) -return 0 ; - - t1 =xfs_calc_buf_res (nr_ops, mp->m_sb.sb_sectsize) + -xfs_calc_buf_res (xfs_refcountbt_block_count (mp, nr_ops), blksz); - -if (xfs_has_realtime (mp)) - t2 =xfs_calc_inode_res (mp,1 ) + -xfs_calc_buf_res (xfs_rtrefcountbt_block_count (mp, nr_ops), - blksz); + t1 =xfs_calc_finish_cui_reservation (mp, nr_ops); + t2 =xfs_calc_finish_rt_cui_reservation (mp, nr_ops);return max (t1, t2); }
@@ -379,6 +406,96 @@ xfs_calc_write_reservation_minlogsize(return xfs_calc_write_reservation (mp, true); } +/* +* Finishing an EFI can free the blocks and bmap blocks (t2): +* the agf for each of the ags: nr * sector size +* the agfl for each of the ags: nr * sector size +* the super block to reflect the freed blocks: sector size +* worst case split in allocation btrees per extent assuming nr extents: +* nr exts * 2 trees * (2 * max depth - 1) * block size +*/ +inline unsigned int +xfs_calc_finish_efi_reservation ( +struct xfs_mount *mp, +unsigned int nr) +{ +return xfs_calc_buf_res ((2 * nr) +1 , mp->m_sb.sb_sectsize) + +xfs_calc_buf_res (xfs_allocfree_block_count (mp, nr), + mp->m_sb.sb_blocksize); +} + +/* +* Or, if it's a realtime file (t3): +* the agf for each of the ags: 2 * sector size +* the agfl for each of the ags: 2 * sector size +* the super block to reflect the freed blocks: sector size +* the realtime bitmap: +* 2 exts * ((XFS_BMBT_MAX_EXTLEN / rtextsize) / NBBY) bytes +* the realtime summary: 2 exts * 1 block +* worst case split in allocation btrees per extent assuming 2 extents: +* 2 exts * 2 trees * (2 * max depth - 1) * block size +*/ +inline unsigned int +xfs_calc_finish_rt_efi_reservation ( +struct xfs_mount *mp, +unsigned int nr) +{ +if (!xfs_has_realtime (mp)) +return 0 ; + +return xfs_calc_buf_res ((2 * nr) +1 , mp->m_sb.sb_sectsize) + +xfs_calc_buf_res (xfs_rtalloc_block_count (mp, nr), + mp->m_sb.sb_blocksize) + +xfs_calc_buf_res (xfs_allocfree_block_count (mp, nr), + mp->m_sb.sb_blocksize); +} + +/* +* Finishing an RUI is the same as an EFI. We can split the rmap btree twice +* on each end of the record, and that can cause the AGFL to be refilled or +* emptied out. +*/ +inline unsigned int +xfs_calc_finish_rui_reservation ( +struct xfs_mount *mp, +unsigned int nr) +{ +if (!xfs_has_rmapbt (mp)) +return 0 ; +return xfs_calc_finish_efi_reservation (mp, nr); +} + +/* +* Finishing an RUI is the same as an EFI. We can split the rmap btree twice +* on each end of the record, and that can cause the AGFL to be refilled or +* emptied out. +*/ +inline unsigned int +xfs_calc_finish_rt_rui_reservation ( +struct xfs_mount *mp, +unsigned int nr) +{ +if (!xfs_has_rtrmapbt (mp)) +return 0 ; +return xfs_calc_finish_rt_efi_reservation (mp, nr); +} + +/* +* In finishing a BUI, we can modify: +* the inode being truncated: inode size +* dquots +* the inode's bmap btree: (max depth + 1) * block size +*/ +inline unsigned int +xfs_calc_finish_bui_reservation ( +struct xfs_mount *mp, +unsigned int nr) +{ +return xfs_calc_inode_res (mp,1 ) +XFS_DQUOT_LOGRES + +xfs_calc_buf_res (XFS_BM_MAXLEVELS (mp,XFS_DATA_FORK ) +1 , + mp->m_sb.sb_blocksize); +} +/* * In truncating a file we free up to two extents at once. We can modify (t1): * the inode being truncated: inode size
@@ -411,16 +528,8 @@ xfs_calc_itruncate_reservation( t1 =xfs_calc_inode_res (mp,1 ) +xfs_calc_buf_res (XFS_BM_MAXLEVELS (mp,XFS_DATA_FORK ) +1 , blksz); - t2 =xfs_calc_buf_res (9 , mp->m_sb.sb_sectsize) + -xfs_calc_buf_res (xfs_allocfree_block_count (mp,4 ), blksz); - -if (xfs_has_realtime (mp)) { - t3 =xfs_calc_buf_res (5 , mp->m_sb.sb_sectsize) + -xfs_calc_buf_res (xfs_rtalloc_block_count (mp,2 ), blksz) + -xfs_calc_buf_res (xfs_allocfree_block_count (mp,2 ), blksz); - }else { - t3 =0 ; - } + t2 =xfs_calc_finish_efi_reservation (mp,4 ); + t3 =xfs_calc_finish_rt_efi_reservation (mp,2 );/* * In the early days of reflink, we included enough reservation to log
@@ -501,9 +610,7 @@ xfs_calc_rename_reservation(xfs_calc_buf_res (2 *XFS_DIROP_LOG_COUNT (mp),XFS_FSB_TO_B (mp,1 )); - t2 =xfs_calc_buf_res (7 , mp->m_sb.sb_sectsize) + -xfs_calc_buf_res (xfs_allocfree_block_count (mp,3 ), -XFS_FSB_TO_B (mp,1 )); + t2 =xfs_calc_finish_efi_reservation (mp,3 );if (xfs_has_parent (mp)) {unsigned int rename_overhead, exchange_overhead;
@@ -611,9 +718,7 @@ xfs_calc_link_reservation( overhead +=xfs_calc_iunlink_remove_reservation (mp); t1 =xfs_calc_inode_res (mp,2 ) +xfs_calc_buf_res (XFS_DIROP_LOG_COUNT (mp),XFS_FSB_TO_B (mp,1 )); - t2 =xfs_calc_buf_res (3 , mp->m_sb.sb_sectsize) + -xfs_calc_buf_res (xfs_allocfree_block_count (mp,1 ), -XFS_FSB_TO_B (mp,1 )); + t2 =xfs_calc_finish_efi_reservation (mp,1 );if (xfs_has_parent (mp)) { t3 = resp->tr_attrsetm.tr_logres;
@@ -676,9 +781,7 @@ xfs_calc_remove_reservation( t1 =xfs_calc_inode_res (mp,2 ) +xfs_calc_buf_res (XFS_DIROP_LOG_COUNT (mp),XFS_FSB_TO_B (mp,1 )); - t2 =xfs_calc_buf_res (4 , mp->m_sb.sb_sectsize) + -xfs_calc_buf_res (xfs_allocfree_block_count (mp,2 ), -XFS_FSB_TO_B (mp,1 )); + t2 =xfs_calc_finish_efi_reservation (mp,2 );if (xfs_has_parent (mp)) { t3 = resp->tr_attrrm.tr_logres;
fs/xfs/libxfs/xfs_trans_resv.h +18 -0
@@ -98,6 +98,24 @@ struct xfs_trans_resv {void xfs_trans_resv_calc (struct xfs_mount *mp,struct xfs_trans_resv *resp);uint xfs_allocfree_block_count (struct xfs_mount *mp,uint num_ops); +unsigned int xfs_calc_finish_bui_reservation (struct xfs_mount *mp, +unsigned int nr_ops); + +unsigned int xfs_calc_finish_efi_reservation (struct xfs_mount *mp, +unsigned int nr_ops); +unsigned int xfs_calc_finish_rt_efi_reservation (struct xfs_mount *mp, +unsigned int nr_ops); + +unsigned int xfs_calc_finish_rui_reservation (struct xfs_mount *mp, +unsigned int nr_ops); +unsigned int xfs_calc_finish_rt_rui_reservation (struct xfs_mount *mp, +unsigned int nr_ops); + +unsigned int xfs_calc_finish_cui_reservation (struct xfs_mount *mp, +unsigned int nr_ops); +unsigned int xfs_calc_finish_rt_cui_reservation (struct xfs_mount *mp, +unsigned int nr_ops); +unsigned int xfs_calc_itruncate_reservation_minlogsize (struct xfs_mount *mp);unsigned int xfs_calc_write_reservation_minlogsize (struct xfs_mount *mp);unsigned int xfs_calc_qm_dqalloc_reservation_minlogsize (struct xfs_mount *mp);
Signature · 1 line
2.31.1
PATCH v9 4/15 xfs: rename xfs_inode_can_atomicwrite() -> xfs_inode_can_hw_atomic_write()
In reply to John GarryIn future we will want to be able to check if specifically HW offload-based atomic writes are possible, so rename xfs_inode_can_atomicwrite() -> xfs_inode_can_hw_atomicwrite().
--- fs/xfs/xfs_file.c | 2 +- fs/xfs/xfs_inode.h | 2 +- fs/xfs/xfs_iops.c | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-)
fs/xfs/xfs_file.c +1 -1
@@ -1488,7 +1488,7 @@ xfs_file_open(if (xfs_is_shutdown (XFS_M (inode->i_sb)))return -EIO ; file->f_mode |=FMODE_NOWAIT |FMODE_CAN_ODIRECT ; -if (xfs_inode_can_atomicwrite (XFS_I (inode))) +if (xfs_inode_can_hw_atomic_write (XFS_I (inode))) file->f_mode |=FMODE_CAN_ATOMIC_WRITE ;return generic_file_open (inode, file); }
fs/xfs/xfs_inode.h +1 -1
@@ -357,7 +357,7 @@ static inline bool xfs_inode_has_bigrtalloc(const struct xfs_inode *ip) (ip)->i_mount->m_rtdev_targp : (ip)->i_mount->m_ddev_targp)static inline bool -xfs_inode_can_atomicwrite ( +xfs_inode_can_hw_atomic_write (struct xfs_inode *ip) {struct xfs_mount *mp = ip->i_mount;
fs/xfs/xfs_iops.c +1 -1
@@ -608,7 +608,7 @@ xfs_report_atomic_write( {unsigned int unit_min =0 , unit_max =0 ; -if (xfs_inode_can_atomicwrite (ip)) +if (xfs_inode_can_hw_atomic_write (ip)) unit_min = unit_max = ip->i_mount->m_sb.sb_blocksize;generic_fill_statx_atomic_writes (stat, unit_min, unit_max,0 ); }
Signature · 1 line
2.31.1
PATCH v9 5/15 xfs: ignore HW which cannot atomic write a single block
In reply to John GarryFrom: "Darrick J. Wong" <[email protected]>
Currently only HW which can write at least 1x block is supported.
For supporting atomic writes > 1x block, a CoW-based method will also be used and this will not be resticted to using HW which can write >= 1x block.
However for deciding if HW-based atomic writes can be used, we need to start adding checks for write length < HW min, which complicates the code. Indeed, a statx field similar to unit_max_opt should also be added for this minimum, which is undesirable.
HW which can only write > 1x blocks would be uncommon and quite weird, so let's just not support it.
--- fs/xfs/xfs_buf.c | 41 ++++++++++++++++++++++++++++++++++------- fs/xfs/xfs_buf.h | 3 ++- fs/xfs/xfs_inode.h | 14 ++------------ fs/xfs/xfs_mount.c | 7 +++++++ 4 files changed, 45 insertions(+), 20 deletions(-)
fs/xfs/xfs_buf.c +34 -7
@@ -1772,6 +1772,40 @@ xfs_init_buftarg(return -ENOMEM ; } +/* +* Configure this buffer target for hardware-assisted atomic writes if the +* underlying block device supports is congruent with the filesystem geometry. +*/ +void +xfs_buftarg_config_atomic_writes ( +struct xfs_buftarg *btp) +{ +struct xfs_mount *mp = btp->bt_mount; +unsigned int min_bytes, max_bytes; + +ASSERT (btp->bt_bdev !=NULL ); + +if (!bdev_can_atomic_write (btp->bt_bdev)) +return ; + + min_bytes =bdev_atomic_write_unit_min_bytes (btp->bt_bdev); + max_bytes =bdev_atomic_write_unit_max_bytes (btp->bt_bdev); + +/* +* Ignore atomic write geometry that is nonsense or doesn't even cover +* a single fsblock. +*/ +if (min_bytes > max_bytes || + min_bytes > mp->m_sb.sb_blocksize || + max_bytes < mp->m_sb.sb_blocksize) { + min_bytes =0 ; + max_bytes =0 ; + } + + btp->bt_bdev_awu_min = min_bytes; + btp->bt_bdev_awu_max = max_bytes; +} +struct xfs_buftarg * xfs_alloc_buftarg( struct xfs_mount *mp,
@@ -1792,13 +1826,6 @@ xfs_alloc_buftarg( btp->bt_daxdev =fs_dax_get_by_bdev (btp->bt_bdev, &btp->bt_dax_part_off, mp, ops); -if (bdev_can_atomic_write (btp->bt_bdev)) { - btp->bt_bdev_awu_min =bdev_atomic_write_unit_min_bytes ( - btp->bt_bdev); - btp->bt_bdev_awu_max =bdev_atomic_write_unit_max_bytes ( - btp->bt_bdev); - } -/* * When allocating the buftargs we have not yet read the super block and * thus don't know the file system sector size yet.
fs/xfs/xfs_buf.h +2 -1
@@ -112,7 +112,7 @@ struct xfs_buftarg {struct percpu_counter bt_readahead_count;struct ratelimit_state bt_ioerror_rl; -/* Atomic write unit values */ +/* Atomic write unit values, bytes */ unsigned int bt_bdev_awu_min;unsigned int bt_bdev_awu_max;
@@ -375,6 +375,7 @@ extern void xfs_free_buftarg(struct xfs_buftarg *);extern void xfs_buftarg_wait (struct xfs_buftarg *);extern void xfs_buftarg_drain (struct xfs_buftarg *);extern int xfs_setsize_buftarg (struct xfs_buftarg *,unsigned int ); +void xfs_buftarg_config_atomic_writes (struct xfs_buftarg *btp);#define xfs_getsize_buftarg (buftarg) block_size((buftarg)->bt_bdev)#define xfs_readonly_buftarg (buftarg) bdev_read_only((buftarg)->bt_bdev)
fs/xfs/xfs_inode.h +2 -12
@@ -356,19 +356,9 @@ static inline bool xfs_inode_has_bigrtalloc(const struct xfs_inode *ip) (XFS_IS_REALTIME_INODE (ip) ? \ (ip)->i_mount->m_rtdev_targp : (ip)->i_mount->m_ddev_targp) -static inline bool -xfs_inode_can_hw_atomic_write ( -struct xfs_inode *ip) +static inline bool xfs_inode_can_hw_atomic_write (const struct xfs_inode *ip) { -struct xfs_mount *mp = ip->i_mount; -struct xfs_buftarg *target =xfs_inode_buftarg (ip); - -if (mp->m_sb.sb_blocksize < target->bt_bdev_awu_min) -return false; -if (mp->m_sb.sb_blocksize > target->bt_bdev_awu_max) -return false; - -return true; +return xfs_inode_buftarg (ip)->bt_bdev_awu_max >0 ; }/*
fs/xfs/xfs_mount.c +7 -0
@@ -1082,6 +1082,13 @@ xfs_mountfs(xfs_zone_gc_start (mp); } +/* Configure hardware atomic write geometry */ +xfs_buftarg_config_atomic_writes (mp->m_ddev_targp); +if (mp->m_logdev_targp && mp->m_logdev_targp != mp->m_ddev_targp) +xfs_buftarg_config_atomic_writes (mp->m_logdev_targp); +if (mp->m_rtdev_targp && mp->m_rtdev_targp != mp->m_ddev_targp) +xfs_buftarg_config_atomic_writes (mp->m_rtdev_targp); +return 0 ; out_agresv:
Signature · 1 line
2.31.1
Re: [PATCH v9 05/15] xfs: ignore HW which cannot atomic write a single block
fs/xfs/xfs_mount.c xfs_mountfs( · line 1090
Quoted 6 lines · John Garry
fs/xfs/xfs_mount.c +6
-0+/* Configure hardware atomic write geometry */ +xfs_buftarg_config_atomic_writes (mp->m_ddev_targp); +if (mp->m_logdev_targp && mp->m_logdev_targp != mp->m_ddev_targp) +xfs_buftarg_config_atomic_writes (mp->m_logdev_targp); +if (mp->m_rtdev_targp && mp->m_rtdev_targp != mp->m_ddev_targp) +xfs_buftarg_config_atomic_writes (mp->m_rtdev_targp);
So this can't be merged into xfs_setsize_buftarg as suggeted last round instead of needing yet another per-device call into the buftarg code?
Re: [PATCH v9 05/15] xfs: ignore HW which cannot atomic write a single block
Quoted 10 lines · Christoph Hellwig
fs/xfs/xfs_mount.c xfs_mountfs( · line 1090
Quoted 6 lines · John Garry
fs/xfs/xfs_mount.c +6
-0+/* Configure hardware atomic write geometry */ +xfs_buftarg_config_atomic_writes (mp->m_ddev_targp); +if (mp->m_logdev_targp && mp->m_logdev_targp != mp->m_ddev_targp) +xfs_buftarg_config_atomic_writes (mp->m_logdev_targp); +if (mp->m_rtdev_targp && mp->m_rtdev_targp != mp->m_ddev_targp) +xfs_buftarg_config_atomic_writes (mp->m_rtdev_targp);So this can't be merged into
xfs_setsize_buftargas suggeted last round instead of needing yet another per-device call into the buftarg code?
Oh, heh, I forgot that xfs_setsize_buftarg is called a second time by xfs_setup_devices at the end of fill_super. xfs_setup_devices is a better place to call xfs_buftarg_config_atomic_writes.
I don't like the idea of merging the hw atomic write detection into xfs_setsize_buftarg itself because (a) it gets called for the data device before we've read the fs blocksize so the validation is meaningless and (b) that makes xfs_setsize_buftarg's purpose less cohesive.
--D
Re: [PATCH v9 05/15] xfs: ignore HW which cannot atomic write a single block
Quoted 5 lines · Darrick J. Wong
Quoted 2 lines
So this can't be merged into
xfs_setsize_buftargas suggeted last round instead of needing yet another per-device call into the buftarg code?Oh, heh, I forgot that
xfs_setsize_buftargis called a second time byxfs_setup_devicesat the end offill_super.
That's actually the real call. The first is just a dummy to have bt_meta_sectorsize/bt_meta_sectormask initialized because if we didn't do that some assert in the block layer triggered. We should probably remove that call and open code the two assignments..
Quoted 5 lines
I don't like the idea of merging the hw atomic write detection into
xfs_setsize_buftargitself because (a) it gets called for the data device before we've read the fs blocksize so the validation is meaningless and (b) that makes xfs_setsize_buftarg's purpose less cohesive.
As explained last round this came up I'd of course rename it if we did that. But I can do that later.
Re: [PATCH v9 05/15] xfs: ignore HW which cannot atomic write a single block
Quoted 12 lines · Christoph Hellwig
Quoted 5 lines · Darrick J. Wong
Quoted 2 lines
So this can't be merged into
xfs_setsize_buftargas suggeted last round instead of needing yet another per-device call into the buftarg code?Oh, heh, I forgot that
xfs_setsize_buftargis called a second time byxfs_setup_devicesat the end offill_super.That's actually the real call. The first is just a dummy to have bt_meta_sectorsize/bt_meta_sectormask initialized because if we didn't do that some assert in the block layer triggered. We should probably remove that call and open code the two assignments..
Quoted 8 lines
Quoted 5 lines
I don't like the idea of merging the hw atomic write detection into
xfs_setsize_buftargitself because (a) it gets called for the data device before we've read the fs blocksize so the validation is meaningless and (b) that makes xfs_setsize_buftarg's purpose less cohesive.As explained last round this came up I'd of course rename it if we did that. But I can do that later.
<nod> Would you be willing to review this patch as it is now and either you or me can just tack a new cleanup patch on the end? I tried writing a patch to clean this up, but ran into questions:
At first I thought that the xfs_setsize_buftarg call in xfs_alloc_buftarg could be replaced by open-coding the bt_meta_sector* assignment, checking that bdev_validate_blocksize is ok, and dropping the sync_blockdev.
Once we get to xfs_setup_devices, we can call xfs_setsize_buftarg on the three buftargs, and xfs_setsize_buftarg will configure the atomic writes geometry.
But then as I was reading the patch, it occurred to me that at least for the data device, we actually /do/ want that sync_blockdev call so that any dirty pagecache for the superblock actually get written to disk. Maybe that can go at the end of xfs_open_devices? But would it be preferable to sync all the devices prior to trying to read the primary sb? I don't think there's a need, but maybe someone else has a different viewpoint?
--D
Re: [PATCH v9 05/15] xfs: ignore HW which cannot atomic write a single block
Quoted 35 lines · Darrick J. Wong
Quoted 12 lines · Christoph Hellwig
Quoted 5 lines · Darrick J. Wong
Quoted 2 lines
So this can't be merged into
xfs_setsize_buftargas suggeted last round instead of needing yet another per-device call into the buftarg code?Oh, heh, I forgot that
xfs_setsize_buftargis called a second time byxfs_setup_devicesat the end offill_super.That's actually the real call. The first is just a dummy to have bt_meta_sectorsize/bt_meta_sectormask initialized because if we didn't do that some assert in the block layer triggered. We should probably remove that call and open code the two assignments..
Quoted 8 lines
Quoted 5 lines
I don't like the idea of merging the hw atomic write detection into
xfs_setsize_buftargitself because (a) it gets called for the data device before we've read the fs blocksize so the validation is meaningless and (b) that makes xfs_setsize_buftarg's purpose less cohesive.As explained last round this came up I'd of course rename it if we did that. But I can do that later.
<nod> Would you be willing to review this patch as it is now and either you or me can just tack a new cleanup patch on the end? I tried writing a patch to clean this up, but ran into questions:
At first I thought that the
xfs_setsize_buftargcall inxfs_alloc_buftargcould be replaced by open-coding the bt_meta_sector* assignment, checking thatbdev_validate_blocksizeis ok, and dropping thesync_blockdev.Once we get to
xfs_setup_devices, we can callxfs_setsize_buftargon the three buftargs, andxfs_setsize_buftargwill configure the atomic writes geometry.
Quoted 7 lines
But then as I was reading the patch, it occurred to me that at least for the data device, we actually /do/ want that
sync_blockdevcall so that any dirty pagecache for the superblock actually get written to disk. Maybe that can go at the end ofxfs_open_devices? But would it be preferable to sync all the devices prior to trying to read the primary sb? I don't think there's a need, but maybe someone else has a different viewpoint?
Eh, since John posted a V10 I'll just tack my new patches on the end of that so everyone can look at them.
--D
PATCH 5/15 xfs: ignore HW which cannot atomic write a single block
In reply to John GarryFrom: Darrick J. Wong <[email protected]>
Currently only HW which can write at least 1x block is supported.
For supporting atomic writes > 1x block, a CoW-based method will also be used and this will not be resticted to using HW which can write >= 1x block.
However for deciding if HW-based atomic writes can be used, we need to start adding checks for write length < HW min, which complicates the code. Indeed, a statx field similar to unit_max_opt should also be added for this minimum, which is undesirable.
HW which can only write > 1x blocks would be uncommon and quite weird, so let's just not support it.
---
v9.1: move the atomic hw geometry calls to xfs_setup_devices
--- fs/xfs/xfs_buf.h | 3 ++- fs/xfs/xfs_inode.h | 14 ++------------ fs/xfs/xfs_buf.c | 41 ++++++++++++++++++++++++++++++++++------- fs/xfs/xfs_super.c | 6 +++++- 4 files changed, 43 insertions(+), 21 deletions(-)
fs/xfs/xfs_buf.h +2 -1
@@ -112,7 +112,7 @@ struct xfs_buftarg {struct percpu_counter bt_readahead_count;struct ratelimit_state bt_ioerror_rl; -/* Atomic write unit values */ +/* Atomic write unit values, bytes */ unsigned int bt_bdev_awu_min;unsigned int bt_bdev_awu_max;
@@ -375,6 +375,7 @@ extern void xfs_free_buftarg(struct xfs_buftarg *);extern void xfs_buftarg_wait (struct xfs_buftarg *);extern void xfs_buftarg_drain (struct xfs_buftarg *);extern int xfs_setsize_buftarg (struct xfs_buftarg *,unsigned int ); +void xfs_buftarg_config_atomic_writes (struct xfs_buftarg *btp);#define xfs_getsize_buftarg (buftarg) block_size((buftarg)->bt_bdev)#define xfs_readonly_buftarg (buftarg) bdev_read_only((buftarg)->bt_bdev)
fs/xfs/xfs_inode.h +2 -12
@@ -356,19 +356,9 @@ static inline bool xfs_inode_has_bigrtalloc(const struct xfs_inode *ip) (XFS_IS_REALTIME_INODE (ip) ? \ (ip)->i_mount->m_rtdev_targp : (ip)->i_mount->m_ddev_targp) -static inline bool -xfs_inode_can_hw_atomic_write ( -struct xfs_inode *ip) +static inline bool xfs_inode_can_hw_atomic_write (const struct xfs_inode *ip) { -struct xfs_mount *mp = ip->i_mount; -struct xfs_buftarg *target =xfs_inode_buftarg (ip); - -if (mp->m_sb.sb_blocksize < target->bt_bdev_awu_min) -return false; -if (mp->m_sb.sb_blocksize > target->bt_bdev_awu_max) -return false; - -return true; +return xfs_inode_buftarg (ip)->bt_bdev_awu_max >0 ; }/*
fs/xfs/xfs_buf.c +34 -7
53 lines not on this page · raw message
fs/xfs/xfs_super.c +5 -1
@@ -520,7 +520,8 @@ xfs_open_devices( }/* -* Setup xfs_mount buffer target pointers based on superblock +* Setup xfs_mount buffer target pointers based on superblock, and configure +* the atomic write capabilities now that we've validated the blocksize. */ STATIC int xfs_setup_devices(
@@ -531,6 +532,7 @@ xfs_setup_devices( error =xfs_setsize_buftarg (mp->m_ddev_targp, mp->m_sb.sb_sectsize);if (error)return error; +xfs_buftarg_config_atomic_writes (mp->m_ddev_targp);if (mp->m_logdev_targp && mp->m_logdev_targp != mp->m_ddev_targp) {unsigned int log_sector_size =BBSIZE ;
@@ -541,6 +543,7 @@ xfs_setup_devices( log_sector_size);if (error)return error; +xfs_buftarg_config_atomic_writes (mp->m_logdev_targp); }if (mp->m_sb.sb_rtstart) {
@@ -555,6 +558,7 @@ xfs_setup_devices( mp->m_sb.sb_sectsize);if (error)return error; +xfs_buftarg_config_atomic_writes (mp->m_rtdev_targp); }return 0 ;
PATCH v9 6/15 xfs: allow block allocator to take an alignment hint
In reply to John GarryAdd a BMAPI flag to provide a hint to the block allocator to align extents according to the extszhint.
This will be useful for atomic writes to ensure that we are not being allocated extents which are not suitable (for atomic writes).
--- fs/xfs/libxfs/xfs_bmap.c | 5 +++++ fs/xfs/libxfs/xfs_bmap.h | 6 +++++- 2 files changed, 10 insertions(+), 1 deletion(-)
fs/xfs/libxfs/xfs_bmap.c +5 -0
@@ -3312,6 +3312,11 @@ xfs_bmap_compute_alignments( align =xfs_get_cowextsz_hint (ap->ip); else if (ap->datatype & XFS_ALLOC_USERDATA) align =xfs_get_extsz_hint (ap->ip); + +/* Try to align start block to any minimum allocation alignment */ +if (align >1 && (ap->flags &XFS_BMAPI_EXTSZALIGN )) + args->alignment = align; +if (align) { if (xfs_bmap_extsize_align(mp, &ap->got, &ap->prev, align, 0, ap->eof, 0, ap->conv, &ap->offset,
fs/xfs/libxfs/xfs_bmap.h +5 -1
@@ -87,6 +87,9 @@ struct xfs_bmalloca {/* Do not update the rmap btree. Used for reconstructing bmbt from rmapbt. */ #define XFS_BMAPI_NORMAP (1u << 10) +/* Try to align allocations to the extent size hint */ +#define XFS_BMAPI_EXTSZALIGN (1u << 11) +#define XFS_BMAPI_FLAGS \ { XFS_BMAPI_ENTIRE, "ENTIRE" }, \ { XFS_BMAPI_METADATA, "METADATA" }, \
@@ -98,7 +101,8 @@ struct xfs_bmalloca { { XFS_BMAPI_REMAP, "REMAP" }, \ { XFS_BMAPI_COWFORK, "COWFORK" }, \ { XFS_BMAPI_NODISCARD, "NODISCARD" }, \ - { XFS_BMAPI_NORMAP, "NORMAP" } + { XFS_BMAPI_NORMAP, "NORMAP" },\ + { XFS_BMAPI_EXTSZALIGN, "EXTSZALIGN" } static inline int xfs_bmapi_aflag(int w)
Signature · 1 line
2.31.1
PATCH v9 7/15 xfs: refactor xfs_reflink_end_cow_extent()
In reply to John GarryRefactor xfs_reflink_end_cow_extent() into separate parts which process the CoW range and commit the transaction.
This refactoring will be used in future for when it is required to commit a range of extents as a single transaction, similar to how it was done pre-commit d6f215f359637.
--- fs/xfs/xfs_reflink.c | 72 ++++++++++++++++++++++++++------------------ 1 file changed, 42 insertions(+), 30 deletions(-)
fs/xfs/xfs_reflink.c +42 -30
@@ -786,35 +786,19 @@ xfs_reflink_update_quota(* requirements as low as possible. */ STATIC int -xfs_reflink_end_cow_extent ( +xfs_reflink_end_cow_extent_locked ( +struct xfs_trans *tp,struct xfs_inode *ip,xfs_fileoff_t *offset_fsb,xfs_fileoff_t end_fsb) {struct xfs_iext_cursor icur;struct xfs_bmbt_irec got, del, data; -struct xfs_mount *mp = ip->i_mount; -struct xfs_trans *tp;struct xfs_ifork *ifp =xfs_ifork_ptr (ip,XFS_COW_FORK ); -unsigned int resblks;int nmaps;bool isrt =XFS_IS_REALTIME_INODE (ip);int error; - resblks =XFS_EXTENTADD_SPACE_RES (mp,XFS_DATA_FORK ); - error =xfs_trans_alloc (mp, &M_RES (mp)->tr_write, resblks,0 , -XFS_TRANS_RESERVE , &tp); -if (error) -return error; - -/* -* Lock the inode. We have to ijoin without automatic unlock because -* the lead transaction is the refcountbt record deletion; the data -* fork update follows as a deferred log item. -*/ -xfs_ilock (ip,XFS_ILOCK_EXCL ); -xfs_trans_ijoin (tp, ip,0 ); -/* * In case of racing, overlapping AIO writes no COW extents might be * left by the time I/O completes for the loser of the race. In that
@@ -823,7 +807,7 @@ xfs_reflink_end_cow_extent(if (!xfs_iext_lookup_extent (ip, ifp, *offset_fsb, &icur, &got) || got.br_startoff >= end_fsb) { *offset_fsb = end_fsb; - goto out_cancel; +return 0 ; }/*
@@ -837,7 +821,7 @@ xfs_reflink_end_cow_extent(if (!xfs_iext_next_extent (ifp, &icur, &got) || got.br_startoff >= end_fsb) { *offset_fsb = end_fsb; - goto out_cancel; +return 0 ; } } del = got;
@@ -846,14 +830,14 @@ xfs_reflink_end_cow_extent( error =xfs_iext_count_extend (tp, ip,XFS_DATA_FORK ,XFS_IEXT_REFLINK_END_COW_CNT );if (error) - goto out_cancel; +return error;/* Grab the corresponding mapping in the data fork. */ nmaps =1 ; error =xfs_bmapi_read (ip, del.br_startoff, del.br_blockcount, &data, &nmaps,0 );if (error) - goto out_cancel; +return error;/* We can only remap the smaller of the two extent sizes. */ data.br_blockcount =min (data.br_blockcount, del.br_blockcount);
@@ -882,7 +866,7 @@ xfs_reflink_end_cow_extent( error =xfs_bunmapi (NULL , ip, data.br_startoff, data.br_blockcount,0 ,1 , &done);if (error) - goto out_cancel; +return error;ASSERT (done); }
@@ -899,17 +883,45 @@ xfs_reflink_end_cow_extent(/* Remove the mapping from the CoW fork. */ xfs_bmap_del_extent_cow (ip, &icur, &got, &del); - error =xfs_trans_commit (tp); -xfs_iunlock (ip,XFS_ILOCK_EXCL ); -if (error) -return error; -/* Update the caller about how much progress we made. */ *offset_fsb = del.br_startoff + del.br_blockcount;return 0 ; +} -out_cancel: -xfs_trans_cancel (tp); +/* +* Remap part of the CoW fork into the data fork. +* +* We aim to remap the range starting at @offset_fsb and ending at @end_fsb +* into the data fork; this function will remap what it can (at the end of the +* range) and update @end_fsb appropriately. Each remap gets its own +* transaction because we can end up merging and splitting bmbt blocks for +* every remap operation and we'd like to keep the block reservation +* requirements as low as possible. +*/ +STATIC int +xfs_reflink_end_cow_extent ( +struct xfs_inode *ip, +xfs_fileoff_t *offset_fsb, +xfs_fileoff_t end_fsb) +{ +struct xfs_mount *mp = ip->i_mount; +struct xfs_trans *tp; +unsigned int resblks; +int error; + + resblks =XFS_EXTENTADD_SPACE_RES (mp,XFS_DATA_FORK ); + error =xfs_trans_alloc (mp, &M_RES (mp)->tr_write, resblks,0 , +XFS_TRANS_RESERVE , &tp); +if (error) +return error; +xfs_ilock (ip,XFS_ILOCK_EXCL ); +xfs_trans_ijoin (tp, ip,0 ); + + error =xfs_reflink_end_cow_extent_locked (tp, ip, offset_fsb, end_fsb); +if (error) +xfs_trans_cancel (tp); +else + error =xfs_trans_commit (tp);xfs_iunlock (ip,XFS_ILOCK_EXCL );return error; }
Signature · 1 line
2.31.1
PATCH v9 8/15 xfs: refine atomic write size check in xfs_file_write_iter()
In reply to John GarryCurrently the size of atomic write allowed is fixed at the blocksize.
To start to lift this restriction, partly refactor xfs_report_atomic_write() to into helpers - xfs_get_atomic_write_{min, max}() - and use those helpers to find the per-inode atomic write limits and check according to that.
Also add xfs_get_atomic_write_max_opt() to return the optimal limit, and just return 0 since large atomics aren't supported yet.
--- fs/xfs/xfs_file.c | 12 +++++------- fs/xfs/xfs_iops.c | 36 +++++++++++++++++++++++++++++++----- fs/xfs/xfs_iops.h | 3 +++ 3 files changed, 39 insertions(+), 12 deletions(-)
fs/xfs/xfs_file.c +5 -7
@@ -1032,14 +1032,12 @@ xfs_file_write_iter(return xfs_file_dax_write (iocb, from);if (iocb->ki_flags &IOCB_ATOMIC ) { -/* -* Currently only atomic writing of a single FS block is -* supported. It would be possible to atomic write smaller than -* a FS block, but there is no requirement to support this. -* Note that iomap also does not support this yet. -*/ -if (ocount != ip->i_mount->m_sb.sb_blocksize) +if (ocount <xfs_get_atomic_write_min (ip))return -EINVAL ; + +if (ocount >xfs_get_atomic_write_max (ip)) +return -EINVAL ; + ret =generic_atomic_write_valid (iocb, from);if (ret)return ret;
fs/xfs/xfs_iops.c +31 -5
@@ -601,16 +601,42 @@ xfs_report_dioalign( stat->dio_offset_align = stat->dio_read_offset_align; } +unsigned int +xfs_get_atomic_write_min ( +struct xfs_inode *ip) +{ +if (!xfs_inode_can_hw_atomic_write (ip)) +return 0 ; + +return ip->i_mount->m_sb.sb_blocksize; +} + +unsigned int +xfs_get_atomic_write_max ( +struct xfs_inode *ip) +{ +if (!xfs_inode_can_hw_atomic_write (ip)) +return 0 ; + +return ip->i_mount->m_sb.sb_blocksize; +} + +unsigned int +xfs_get_atomic_write_max_opt ( +struct xfs_inode *ip) +{ +return 0 ; +} +static void xfs_report_atomic_write (struct xfs_inode *ip,struct kstat *stat) { -unsigned int unit_min =0 , unit_max =0 ; - -if (xfs_inode_can_hw_atomic_write (ip)) - unit_min = unit_max = ip->i_mount->m_sb.sb_blocksize; -generic_fill_statx_atomic_writes (stat, unit_min, unit_max,0 ); +generic_fill_statx_atomic_writes (stat, +xfs_get_atomic_write_min (ip), +xfs_get_atomic_write_max (ip), +xfs_get_atomic_write_max_opt (ip)); }STATIC int
fs/xfs/xfs_iops.h +3 -0
@@ -19,5 +19,8 @@ int xfs_inode_init_security(struct inode *inode, struct inode *dir,extern void xfs_setup_inode (struct xfs_inode *ip);extern void xfs_setup_iops (struct xfs_inode *ip);extern void xfs_diflags_to_iflags (struct xfs_inode *ip,bool init); +unsigned int xfs_get_atomic_write_min (struct xfs_inode *ip); +unsigned int xfs_get_atomic_write_max (struct xfs_inode *ip); +unsigned int xfs_get_atomic_write_max_opt (struct xfs_inode *ip);#endif /* __XFS_IOPS_H__ */
Signature · 1 line
2.31.1
PATCH v9 9/15 xfs: add xfs_atomic_write_cow_iomap_begin()
In reply to John GarryFor CoW-based atomic writes, reuse the infrastructure for reflink CoW fork support.
Add ->iomap_begin() callback xfs_atomic_write_cow_iomap_begin() to create staging mappings in the CoW fork for atomic write updates.
The general steps in the function are as follows:
- find extent mapping in the CoW fork for the FS block range being written
- if part or full extent is found, proceed to process found extent
- if no extent found, map in new blocks to the CoW fork
- convert unwritten blocks in extent if required
- update iomap extent mapping and return
The bulk of this function is quite similar to the processing in xfs_reflink_allocate_cow(), where we try to find an extent mapping; if none exists, then allocate a new extent in the CoW fork, convert unwritten blocks, and return a mapping.
Performance testing has shown the XFS_ILOCK_EXCL locking to be quite a bottleneck, so this is an area which could be optimised in future.
Christoph Hellwig contributed almost all of the code in xfs_atomic_write_cow_iomap_begin().
--- fs/xfs/xfs_iomap.c | 128 +++++++++++++++++++++++++++++++++++++++++++ fs/xfs/xfs_iomap.h | 1 + fs/xfs/xfs_mount.h | 5 ++ fs/xfs/xfs_reflink.c | 2 +- fs/xfs/xfs_reflink.h | 2 + fs/xfs/xfs_trace.h | 22 ++++++++ 6 files changed, 159 insertions(+), 1 deletion(-)
fs/xfs/xfs_iomap.c +128 -0
@@ -1022,6 +1022,134 @@ const struct iomap_ops xfs_zoned_direct_write_iomap_ops = { };#endif /* CONFIG_XFS_RT */ +static int +xfs_atomic_write_cow_iomap_begin ( +struct inode *inode, +loff_t offset, +loff_t length, +unsigned flags, +struct iomap *iomap, +struct iomap *srcmap) +{ +struct xfs_inode *ip =XFS_I (inode); +struct xfs_mount *mp = ip->i_mount; +const xfs_fileoff_t offset_fsb =XFS_B_TO_FSBT (mp, offset); +xfs_fileoff_t end_fsb =xfs_iomap_end_fsb (mp, offset, length); +xfs_filblks_t count_fsb = end_fsb - offset_fsb; +int nmaps =1 ; +xfs_filblks_t resaligned; +struct xfs_bmbt_irec cmap; +struct xfs_iext_cursor icur; +struct xfs_trans *tp; +unsigned int dblocks =0 , rblocks =0 ; +int error; +u64 seq; + +ASSERT (flags &IOMAP_WRITE ); +ASSERT (flags &IOMAP_DIRECT ); + +if (xfs_is_shutdown (mp)) +return -EIO ; + +if (!xfs_can_sw_atomic_write (mp)) { +ASSERT (xfs_can_sw_atomic_write (mp)); +return -EINVAL ; + } + +/* blocks are always allocated in this path */ +if (flags &IOMAP_NOWAIT ) +return -EAGAIN ; + +trace_xfs_iomap_atomic_write_cow (ip, offset, length); + +xfs_ilock (ip,XFS_ILOCK_EXCL ); + +if (!ip->i_cowfp) { +ASSERT (!xfs_is_reflink_inode (ip)); +xfs_ifork_init_cow (ip); + } + +if (!xfs_iext_lookup_extent (ip, ip->i_cowfp, offset_fsb, &icur, &cmap)) + cmap.br_startoff = end_fsb; +if (cmap.br_startoff <= offset_fsb) { +xfs_trim_extent (&cmap, offset_fsb, count_fsb); + goto found; + } + + end_fsb = cmap.br_startoff; + count_fsb = end_fsb - offset_fsb; + + resaligned =xfs_aligned_fsb_count (offset_fsb, count_fsb, +xfs_get_cowextsz_hint (ip)); +xfs_iunlock (ip,XFS_ILOCK_EXCL ); + +if (XFS_IS_REALTIME_INODE (ip)) { + dblocks =XFS_DIOSTRAT_SPACE_RES (mp,0 ); + rblocks = resaligned; + }else { + dblocks =XFS_DIOSTRAT_SPACE_RES (mp, resaligned); + rblocks =0 ; + } + + error =xfs_trans_alloc_inode (ip, &M_RES (mp)->tr_write, dblocks, + rblocks, false, &tp); +if (error) +return error; + +/* extent layout could have changed since the unlock, so check again */ +if (!xfs_iext_lookup_extent (ip, ip->i_cowfp, offset_fsb, &icur, &cmap)) + cmap.br_startoff = end_fsb; +if (cmap.br_startoff <= offset_fsb) { +xfs_trim_extent (&cmap, offset_fsb, count_fsb); +xfs_trans_cancel (tp); + goto found; + } + +/* +* Allocate the entire reservation as unwritten blocks. +* +* Use XFS_BMAPI_EXTSZALIGN to hint at aligning new extents according to +* extszhint, such that there will be a greater chance that future +* atomic writes to that same range will be aligned (and don't require +* this COW-based method). +*/ + error =xfs_bmapi_write (tp, ip, offset_fsb, count_fsb, +XFS_BMAPI_COWFORK |XFS_BMAPI_PREALLOC | +XFS_BMAPI_EXTSZALIGN ,0 , &cmap, &nmaps); +if (error) { +xfs_trans_cancel (tp); + goto out_unlock; + } + +xfs_inode_set_cowblocks_tag (ip); + error =xfs_trans_commit (tp); +if (error) + goto out_unlock; + +found: +if (cmap.br_state !=XFS_EXT_NORM ) { + error =xfs_reflink_convert_cow_locked (ip, offset_fsb, + count_fsb); +if (error) + goto out_unlock; + cmap.br_state =XFS_EXT_NORM ; + } + + length =XFS_FSB_TO_B (mp, cmap.br_startoff + cmap.br_blockcount); +trace_xfs_iomap_found (ip, offset, length - offset,XFS_COW_FORK , &cmap); + seq =xfs_iomap_inode_sequence (ip,IOMAP_F_SHARED ); +xfs_iunlock (ip,XFS_ILOCK_EXCL ); +return xfs_bmbt_to_iomap (ip, iomap, &cmap, flags,IOMAP_F_SHARED , seq); + +out_unlock: +xfs_iunlock (ip,XFS_ILOCK_EXCL ); +return error; +} + +const struct iomap_ops xfs_atomic_write_cow_iomap_ops = { + .iomap_begin = xfs_atomic_write_cow_iomap_begin, +}; + static int xfs_dax_write_iomap_end( struct inode *inode,
fs/xfs/xfs_iomap.h +1 -0
@@ -56,5 +56,6 @@ extern const struct iomap_ops xfs_read_iomap_ops;extern const struct iomap_ops xfs_seek_iomap_ops;extern const struct iomap_ops xfs_xattr_iomap_ops;extern const struct iomap_ops xfs_dax_write_iomap_ops; +extern const struct iomap_ops xfs_atomic_write_cow_iomap_ops;#endif /* __XFS_IOMAP_H__*/
fs/xfs/xfs_mount.h +5 -0
@@ -464,6 +464,11 @@ static inline bool xfs_has_nonzoned(const struct xfs_mount *mp)return !xfs_has_zoned (mp); } +static inline bool xfs_can_sw_atomic_write (struct xfs_mount *mp) +{ +return xfs_has_reflink (mp); +} +/* * Some features are always on for v5 file systems, allow the compiler to * eliminiate dead code when building without v4 support.
fs/xfs/xfs_reflink.c +1 -1
@@ -293,7 +293,7 @@ xfs_bmap_trim_cow(return xfs_reflink_trim_around_shared (ip, imap, shared); } -static int +int xfs_reflink_convert_cow_locked( struct xfs_inode *ip, xfs_fileoff_t offset_fsb,
fs/xfs/xfs_reflink.h +2 -0
@@ -35,6 +35,8 @@ int xfs_reflink_allocate_cow(struct xfs_inode *ip, struct xfs_bmbt_irec *imap, bool convert_now);extern int xfs_reflink_convert_cow (struct xfs_inode *ip,xfs_off_t offset,xfs_off_t count); +int xfs_reflink_convert_cow_locked (struct xfs_inode *ip, +xfs_fileoff_t offset_fsb,xfs_filblks_t count_fsb); extern int xfs_reflink_cancel_cow_blocks(struct xfs_inode *ip, struct xfs_trans **tpp, xfs_fileoff_t offset_fsb,
fs/xfs/xfs_trace.h +22 -0
@@ -1657,6 +1657,28 @@ DEFINE_RW_EVENT(xfs_file_direct_write);DEFINE_RW_EVENT (xfs_file_dax_write);DEFINE_RW_EVENT (xfs_reflink_bounce_dio_write); +TRACE_EVENT (xfs_iomap_atomic_write_cow, + TP_PROTO(struct xfs_inode *ip, xfs_off_t offset, ssize_t count), +TP_ARGS (ip, offset, count), +TP_STRUCT__entry ( + __field(dev_t, dev) + __field(xfs_ino_t, ino) + __field(xfs_off_t, offset) +__field (ssize_t, count) + ), +TP_fast_assign ( + __entry->dev = VFS_I(ip)->i_sb->s_dev; + __entry->ino = ip->i_ino; + __entry->offset = offset; + __entry->count = count; + ), +TP_printk ("dev %d:%d ino 0x%llx pos 0x%llx bytecount 0x%zx" , +MAJOR (__entry->dev),MINOR (__entry->dev), + __entry->ino, + __entry->offset, + __entry->count) +) + DECLARE_EVENT_CLASS(xfs_imap_class, TP_PROTO(struct xfs_inode *ip, xfs_off_t offset, ssize_t count, int whichfork, struct xfs_bmbt_irec *irec),
Signature · 1 line
2.31.1
PATCH v9 10/15 xfs: add large atomic writes checks in xfs_direct_write_iomap_begin()
In reply to John GarryFor when large atomic writes (> 1x FS block) are supported, there will be various occasions when HW offload may not be possible.
Such instances include:
- unaligned extent mapping wrt write length
- extent mappings which do not cover the full write, e.g. the write spans sparse or mixed-mapping extents
- the write length is greater than HW offload can support
- no hardware support at all
In those cases, we need to fallback to the CoW-based atomic write mode. For this, report special code -ENOPROTOOPT to inform the caller that HW offload-based method is not possible.
In addition to the occasions mentioned, if the write covers an unallocated range, we again judge that we need to rely on the CoW-based method when we would need to allocate anything more than 1x block. This is because if we allocate less blocks that is required for the write, then again HW offload-based method would not be possible. So we are taking a pessimistic approach to writes covering unallocated space.
--- fs/xfs/xfs_iomap.c | 62 ++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 60 insertions(+), 2 deletions(-)
fs/xfs/xfs_iomap.c +60 -2
@@ -798,6 +798,38 @@ imap_spans_range(return true; } +static bool +xfs_bmap_hw_atomic_write_possible ( +struct xfs_inode *ip, +struct xfs_bmbt_irec *imap, +xfs_fileoff_t offset_fsb, +xfs_fileoff_t end_fsb) +{ +struct xfs_mount *mp = ip->i_mount; +xfs_fsize_t len =XFS_FSB_TO_B (mp, end_fsb - offset_fsb); + +/* +* atomic writes are required to be naturally aligned for disk blocks, +* which ensures that we adhere to block layer rules that we won't +* straddle any boundary or violate write alignment requirement. +*/ +if (!IS_ALIGNED (imap->br_startblock, imap->br_blockcount)) +return false; + +/* +* Spanning multiple extents would mean that multiple BIOs would be +* issued, and so would lose atomicity required for REQ_ATOMIC-based +* atomics. +*/ +if (!imap_spans_range (imap, offset_fsb, end_fsb)) +return false; + +/* +* The ->iomap_begin caller should ensure this, but check anyway. +*/ +return len <=xfs_inode_buftarg (ip)->bt_bdev_awu_max; +} + static int xfs_direct_write_iomap_begin( struct inode *inode,
@@ -812,9 +844,11 @@ xfs_direct_write_iomap_begin(struct xfs_bmbt_irec imap, cmap;xfs_fileoff_t offset_fsb =XFS_B_TO_FSBT (mp, offset);xfs_fileoff_t end_fsb =xfs_iomap_end_fsb (mp, offset, length); +xfs_fileoff_t orig_end_fsb = end_fsb;int nimaps =1 , error =0 ;bool shared = false;u16 iomap_flags =0 ; +bool needs_alloc;unsigned int lockmode;u64 seq;
@@ -875,13 +909,37 @@ xfs_direct_write_iomap_begin( (flags & IOMAP_DIRECT) || IS_DAX(inode));if (error) goto out_unlock; -if (shared) +if (shared) { +if ((flags &IOMAP_ATOMIC ) && + !xfs_bmap_hw_atomic_write_possible (ip, &cmap, + offset_fsb, end_fsb)) { + error = -ENOPROTOOPT ; + goto out_unlock; + } goto out_found_cow; + } end_fsb = imap.br_startoff + imap.br_blockcount; length =XFS_FSB_TO_B (mp, end_fsb) - offset; } -if (imap_needs_alloc (inode, flags, &imap, nimaps)) + needs_alloc =imap_needs_alloc (inode, flags, &imap, nimaps); + +if (flags &IOMAP_ATOMIC ) { + error = -ENOPROTOOPT ; +/* +* If we allocate less than what is required for the write +* then we may end up with multiple extents, which means that +* REQ_ATOMIC-based cannot be used, so avoid this possibility. +*/ +if (needs_alloc && orig_end_fsb - offset_fsb >1 ) + goto out_unlock; + +if (!xfs_bmap_hw_atomic_write_possible (ip, &imap, offset_fsb, + orig_end_fsb)) + goto out_unlock; + } + +if (needs_alloc) goto allocate_blocks;/*
Signature · 1 line
2.31.1
PATCH v9 11/15 xfs: commit CoW-based atomic writes atomically
In reply to John GarryWhen completing a CoW-based write, each extent range mapping update is covered by a separate transaction.
For a CoW-based atomic write, all mappings must be changed at once, so change to use a single transaction.
Note that there is a limit on the amount of log intent items which can be fit into a single transaction, but this is being ignored for now since the count of items for a typical atomic write would be much less than is typically supported. A typical atomic write would be expected to be 64KB or less, which means only 16 possible extents unmaps, which is quite small.
--- fs/xfs/libxfs/xfs_log_rlimit.c | 4 +++ fs/xfs/libxfs/xfs_trans_resv.c | 15 +++++++++ fs/xfs/libxfs/xfs_trans_resv.h | 1 + fs/xfs/xfs_file.c | 5 ++- fs/xfs/xfs_reflink.c | 56 ++++++++++++++++++++++++++++++++++ fs/xfs/xfs_reflink.h | 2 ++ 6 files changed, 82 insertions(+), 1 deletion(-)
fs/xfs/libxfs/xfs_log_rlimit.c +4 -0
@@ -91,6 +91,7 @@ xfs_log_calc_trans_resv_for_minlogblocks(*/ if (xfs_want_minlogsize_fixes (&mp->m_sb)) {xfs_trans_resv_calc (mp, resv); + resv->tr_atomic_ioend =M_RES (mp)->tr_atomic_ioend;return ; }
@@ -107,6 +108,9 @@ xfs_log_calc_trans_resv_for_minlogblocks(xfs_trans_resv_calc (mp, resv); +/* Copy the dynamic transaction reservation types from the running fs */ + resv->tr_atomic_ioend =M_RES (mp)->tr_atomic_ioend; +if (xfs_has_reflink (mp)) {/* * In the early days of reflink, typical log operation counts
fs/xfs/libxfs/xfs_trans_resv.c +15 -0
@@ -1284,6 +1284,15 @@ xfs_calc_namespace_reservations( resp->tr_mkdir.tr_logflags |=XFS_TRANS_PERM_LOG_RES ; } +STATIC void +xfs_calc_default_atomic_ioend_reservation ( +struct xfs_mount *mp, +struct xfs_trans_resv *resp) +{ +/* Pick a default that will scale reasonably for the log size. */ + resp->tr_atomic_ioend = resp->tr_itruncate; +} + void xfs_trans_resv_calc( struct xfs_mount *mp,
@@ -1378,4 +1387,10 @@ xfs_trans_resv_calc( resp->tr_itruncate.tr_logcount += logcount_adj; resp->tr_write.tr_logcount += logcount_adj; resp->tr_qm_dqalloc.tr_logcount += logcount_adj; + +/* +* Now that we've finished computing the static reservations, we can +* compute the dynamic reservation for atomic writes. +*/ +xfs_calc_default_atomic_ioend_reservation (mp, resp); }
fs/xfs/libxfs/xfs_trans_resv.h +1 -0
@@ -48,6 +48,7 @@ struct xfs_trans_resv {struct xfs_trans_res tr_qm_dqalloc;/* allocate quota on disk */ struct xfs_trans_res tr_sb;/* modify superblock */ struct xfs_trans_res tr_fsyncts;/* update timestamps on fsync */ +struct xfs_trans_res tr_atomic_ioend;/* untorn write completion */ };/* shorthand way of accessing reservation structure */
fs/xfs/xfs_file.c +4 -1
@@ -576,7 +576,10 @@ xfs_dio_write_end_io( nofs_flag =memalloc_nofs_save ();if (flags &IOMAP_DIO_COW ) { - error =xfs_reflink_end_cow (ip, offset, size); +if (iocb->ki_flags &IOCB_ATOMIC ) + error =xfs_reflink_end_atomic_cow (ip, offset, size); +else + error =xfs_reflink_end_cow (ip, offset, size);if (error) goto out; }
fs/xfs/xfs_reflink.c +56 -0
62 lines not on this page · raw message
fs/xfs/xfs_reflink.h +2 -0
@@ -45,6 +45,8 @@ extern int xfs_reflink_cancel_cow_range(struct xfs_inode *ip, xfs_off_t offset, xfs_off_t count, bool cancel_real);extern int xfs_reflink_end_cow (struct xfs_inode *ip,xfs_off_t offset,xfs_off_t count); +int xfs_reflink_end_atomic_cow (struct xfs_inode *ip,xfs_off_t offset, +xfs_off_t count);extern int xfs_reflink_recover_cow (struct xfs_mount *mp); extern loff_t xfs_reflink_remap_range(struct file *file_in, loff_t pos_in, struct file *file_out, loff_t pos_out, loff_t len,
Signature · 1 line
2.31.1
PATCH v9 12/15 xfs: add xfs_file_dio_write_atomic()
In reply to John GarryAdd xfs_file_dio_write_atomic() for dedicated handling of atomic writes.
Now HW offload will not be required to support atomic writes and is an optional feature.
CoW-based atomic writes will be supported with out-of-places write and atomic extent remapping.
Either mode of operation may be used for an atomic write, depending on the circumstances.
The preferred method is HW offload as it will be faster. If HW offload is not available then we always use the CoW-based method. If HW offload is available but not possible to use, then again we use the CoW-based method.
If available, HW offload would not be possible for the write length exceeding the HW offload limit, the write spanning multiple extents, unaligned disk blocks, etc.
Apart from the write exceeding the HW offload limit, other conditions for HW offload usage can only be detected in the iomap handling for the write. As such, we use a fallback method to issue the write if we detect in the ->iomap_begin() handler that HW offload is not possible. Special code -ENOPROTOOPT is returned from ->iomap_begin() to inform that HW offload is not possible.
In other words, atomic writes are supported on any filesystem that can perform out of place write remapping atomically (i.e. reflink) up to some fairly large size. If the conditions are right (a single correctly aligned overwrite mapping) then the filesystem will use any available hardware support to avoid the filesystem metadata updates.
--- fs/xfs/xfs_file.c | 68 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 68 insertions(+)
fs/xfs/xfs_file.c +68 -0
@@ -728,6 +728,72 @@ xfs_file_dio_write_zoned(return ret; } +/* +* Handle block atomic writes +* +* Two methods of atomic writes are supported: +* - REQ_ATOMIC-based, which would typically use some form of HW offload in the +* disk +* - COW-based, which uses a COW fork as a staging extent for data updates +* before atomically updating extent mappings for the range being written +* +*/ +static noinline ssize_t +xfs_file_dio_write_atomic ( +struct xfs_inode *ip, +struct kiocb *iocb, +struct iov_iter *from) +{ +unsigned int iolock =XFS_IOLOCK_SHARED ; +ssize_t ret, ocount =iov_iter_count (from); +const struct iomap_ops *dops; + +/* +* HW offload should be faster, so try that first if it is already +* known that the write length is not too large. +*/ +if (ocount >xfs_inode_buftarg (ip)->bt_bdev_awu_max) + dops = &xfs_atomic_write_cow_iomap_ops; +else + dops = &xfs_direct_write_iomap_ops; + +retry: + ret =xfs_ilock_iocb_for_write (iocb, &iolock); +if (ret) +return ret; + + ret =xfs_file_write_checks (iocb, from, &iolock,NULL ); +if (ret) + goto out_unlock; + +/* Demote similar to xfs_file_dio_write_aligned() */ +if (iolock ==XFS_IOLOCK_EXCL ) { +xfs_ilock_demote (ip,XFS_IOLOCK_EXCL ); + iolock =XFS_IOLOCK_SHARED ; + } + +trace_xfs_file_direct_write (iocb, from); + ret =iomap_dio_rw (iocb, from, dops, &xfs_dio_write_ops, +0 ,NULL ,0 ); + +/* +* The retry mechanism is based on the ->iomap_begin method returning +* -ENOPROTOOPT, which would be when the REQ_ATOMIC-based write is not +* possible. The REQ_ATOMIC-based method typically not be possible if +* the write spans multiple extents or the disk blocks are misaligned. +*/ +if (ret == -ENOPROTOOPT && dops == &xfs_direct_write_iomap_ops) { +xfs_iunlock (ip, iolock); + dops = &xfs_atomic_write_cow_iomap_ops; + goto retry; + } + +out_unlock: +if (iolock) +xfs_iunlock (ip, iolock); +return ret; +} +/* * Handle block unaligned direct I/O writes *
@@ -843,6 +909,8 @@ xfs_file_dio_write(return xfs_file_dio_write_unaligned (ip, iocb, from);if (xfs_is_zoned_inode (ip))return xfs_file_dio_write_zoned (ip, iocb, from); +if (iocb->ki_flags &IOCB_ATOMIC ) +return xfs_file_dio_write_atomic (ip, iocb, from);return xfs_file_dio_write_aligned (ip, iocb, from, &xfs_direct_write_iomap_ops, &xfs_dio_write_ops,NULL ); }
Signature · 1 line
2.31.1
PATCH v9 13/15 xfs: add xfs_compute_atomic_write_unit_max()
In reply to John GarryNow 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.
Function xfs_atomic_write_logitems() is added to find the limit the number of log items which can fit in a single transaction.
Amend the max atomic write computation to create a new transaction reservation type, and compute the maximum size of an atomic write completion (in fsblocks) based on this new transaction reservation. Initially, tr_atomic_write is a clone of tr_itruncate, which provides a reasonable level of parallelism. In the next patch, we'll add a mount option so that sysadmins can configure their own limits.
[djwong: use a new reservation type for atomic write ioends, refactor group limit calculations]
--- fs/xfs/libxfs/xfs_trans_resv.c | 94 ++++++++++++++++++++++++++++++++++ fs/xfs/libxfs/xfs_trans_resv.h | 2 + fs/xfs/xfs_mount.c | 81 +++++++++++++++++++++++++++++ fs/xfs/xfs_mount.h | 6 +++ fs/xfs/xfs_reflink.c | 16 ++++++ fs/xfs/xfs_reflink.h | 2 + fs/xfs/xfs_trace.h | 60 ++++++++++++++++++++++ 7 files changed, 261 insertions(+)
fs/xfs/libxfs/xfs_trans_resv.c +94 -0
@@ -22,6 +22,12 @@#include "xfs_rtbitmap.h" #include "xfs_attr_item.h" #include "xfs_log.h" +#include "xfs_defer.h" +#include "xfs_bmap_item.h" +#include "xfs_extfree_item.h" +#include "xfs_rmap_item.h" +#include "xfs_refcount_item.h" +#include "xfs_trace.h" #define _ALLOC true#define _FREE false
@@ -1394,3 +1400,91 @@ xfs_trans_resv_calc(*/ xfs_calc_default_atomic_ioend_reservation (mp, resp); } + +/* +* Return the per-extent and fixed transaction reservation sizes needed to +* complete an atomic write. +*/ +STATIC unsigned int +xfs_calc_atomic_write_ioend_geometry ( +struct xfs_mount *mp, +unsigned int *step_size) +{ +const unsigned int efi =xfs_efi_log_space (1 ); +const unsigned int efd =xfs_efd_log_space (1 ); +const unsigned int rui =xfs_rui_log_space (1 ); +const unsigned int rud =xfs_rud_log_space (); +const unsigned int cui =xfs_cui_log_space (1 ); +const unsigned int cud =xfs_cud_log_space (); +const unsigned int bui =xfs_bui_log_space (1 ); +const unsigned int bud =xfs_bud_log_space (); + +/* +* Maximum overhead to complete an atomic write ioend in software: +* remove data fork extent + remove cow fork extent + map extent into +* data fork. +* +* tx0: Creates a BUI and a CUI and that's all it needs. +* +* tx1: Roll to finish the BUI. Need space for the BUD, an RUI, and +* enough space to relog the CUI (== CUI + CUD). +* +* tx2: Roll again to finish the RUI. Need space for the RUD and space +* to relog the CUI. +* +* tx3: Roll again, need space for the CUD and possibly a new EFI. +* +* tx4: Roll again, need space for an EFD. +* +* If the extent referenced by the pair of BUI/CUI items is not the one +* being currently processed, then we need to reserve space to relog +* both items. +*/ +const unsigned int tx0 = bui + cui; +const unsigned int tx1 = bud + rui + cui + cud; +const unsigned int tx2 = rud + cui + cud; +const unsigned int tx3 = cud + efi; +const unsigned int tx4 = efd; +const unsigned int relog = bui + bud + cui + cud; + +const unsigned int per_intent =max (max3 (tx0, tx1, tx2), +max3 (tx3, tx4, relog)); + +/* Overhead to finish one step of each intent item type */ +const unsigned int f1 =xfs_calc_finish_efi_reservation (mp,1 ); +const unsigned int f2 =xfs_calc_finish_rui_reservation (mp,1 ); +const unsigned int f3 =xfs_calc_finish_cui_reservation (mp,1 ); +const unsigned int f4 =xfs_calc_finish_bui_reservation (mp,1 ); + +/* We only finish one item per transaction in a chain */ + *step_size =max (f4,max3 (f1, f2, f3)); + +return per_intent; +} + +/* +* Compute the maximum size (in fsblocks) of atomic writes that we can complete +* given the existing log reservations. +*/ +xfs_extlen_t +xfs_calc_max_atomic_write_fsblocks ( +struct xfs_mount *mp) +{ +const struct xfs_trans_res *resv = &M_RES (mp)->tr_atomic_ioend; +unsigned int per_intent =0 ; +unsigned int step_size =0 ; +unsigned int ret =0 ; + +if (resv->tr_logres >0 ) { + per_intent =xfs_calc_atomic_write_ioend_geometry (mp, + &step_size); + +if (resv->tr_logres >= step_size) + ret = (resv->tr_logres - step_size) / per_intent; + } + +trace_xfs_calc_max_atomic_write_fsblocks (mp, per_intent, step_size, + resv->tr_logres, ret); + +return ret; +}
fs/xfs/libxfs/xfs_trans_resv.h +2 -0
@@ -121,4 +121,6 @@ unsigned int xfs_calc_itruncate_reservation_minlogsize(struct xfs_mount *mp);unsigned int xfs_calc_write_reservation_minlogsize (struct xfs_mount *mp);unsigned int xfs_calc_qm_dqalloc_reservation_minlogsize (struct xfs_mount *mp); +xfs_extlen_t xfs_calc_max_atomic_write_fsblocks (struct xfs_mount *mp); +#endif /* __XFS_TRANS_RESV_H__ */
fs/xfs/xfs_mount.c +81 -0
93 lines not on this page · raw message
fs/xfs/xfs_mount.h +6 -0
@@ -119,6 +119,12 @@ struct xfs_groups {* SMR hard drives. */ xfs_fsblock_t start_fsb; + +/* +* Maximum length of an atomic write for files stored in this +* collection of allocation groups, in fsblocks. +*/ +xfs_extlen_t awu_max; };struct xfs_freecounter {
fs/xfs/xfs_reflink.c +16 -0
@@ -1040,6 +1040,22 @@ xfs_reflink_end_atomic_cow(return error; } +/* Compute the largest atomic write that we can complete through software. */ +xfs_extlen_t +xfs_reflink_max_atomic_cow ( +struct xfs_mount *mp) +{ +/* We cannot do any atomic writes without out of place writes. */ +if (!xfs_can_sw_atomic_write (mp)) +return 0 ; + +/* +* Atomic write limits must always be a power-of-2, according to +* generic_atomic_write_valid. +*/ +return rounddown_pow_of_two (xfs_calc_max_atomic_write_fsblocks (mp)); +} +/* * Free all CoW staging blocks that are still referenced by the ondisk refcount * metadata. The ondisk metadata does not track which inode created the
fs/xfs/xfs_reflink.h +2 -0
@@ -68,4 +68,6 @@ extern int xfs_reflink_update_dest(struct xfs_inode *dest, xfs_off_t newlen,bool xfs_reflink_supports_rextsize (struct xfs_mount *mp,unsigned int rextsize); +xfs_extlen_t xfs_reflink_max_atomic_cow (struct xfs_mount *mp); +#endif /* __XFS_REFLINK_H */
fs/xfs/xfs_trace.h +60 -0
66 lines not on this page · raw message
Signature · 1 line
2.31.1
Re: [PATCH v9 13/15] xfs: add xfs_compute_atomic_write_unit_max()
fs/xfs/xfs_mount.c xfs_agbtree_compute_maxlevels( · line 695
Quoted 5 lines · John Garry
fs/xfs/xfs_mount.c +5
-0+static inline xfs_extlen_t xfs_calc_perag_awu_max (struct xfs_mount *mp) +{ +if (mp->m_ddev_targp->bt_bdev_awu_min >0 ) +return max_pow_of_two_factor (mp->m_sb.sb_agblocks); +return mp->m_ag_max_usable;
I think that this should be rounddown_pow_of_two(mp->m_ag_max_usable)
ditto for rt
I will fix (unless disagree).
Re: [PATCH v9 13/15] xfs: add xfs_compute_atomic_write_unit_max()
Quoted 9 lines · John Garry
fs/xfs/xfs_mount.c xfs_agbtree_compute_maxlevels( · line 695
Quoted 5 lines · John Garry
fs/xfs/xfs_mount.c +5
-0+static inline xfs_extlen_t xfs_calc_perag_awu_max (struct xfs_mount *mp) +{ +if (mp->m_ddev_targp->bt_bdev_awu_min >0 ) +return max_pow_of_two_factor (mp->m_sb.sb_agblocks); +return mp->m_ag_max_usable;I think that this should be
rounddown_pow_of_two(mp->m_ag_max_usable)
Quoted 3 lines
ditto for rt
I will fix (unless disagree).
I don't think this needs fixing. If there's no hardware support on the device, then we can do any size of atomic write that we want.
--D
Re: [PATCH v9 13/15] xfs: add xfs_compute_atomic_write_unit_max()
Quoted 9 lines · Darrick J. Wong
Quoted 8 lines · John Garry
fs/xfs/xfs_mount.c xfs_agbtree_compute_maxlevels( · line 695
Quoted 5 lines · John Garry
fs/xfs/xfs_mount.c +5
-0+static inline xfs_extlen_t xfs_calc_perag_awu_max (struct xfs_mount *mp) +{ +if (mp->m_ddev_targp->bt_bdev_awu_min >0 ) +return max_pow_of_two_factor (mp->m_sb.sb_agblocks); +return mp->m_ag_max_usable;I think that this should be
rounddown_pow_of_two(mp->m_ag_max_usable)
Quoted 5 lines
Quoted 3 lines
ditto for rt
I will fix (unless disagree).
I don't think this needs fixing. If there's no hardware support on the device, then we can do any size of atomic write that we want.
Check man pages for statx:
stx_atomic_write_unit_min stx_atomic_write_unit_max
... These values are each guaranteed to be a power-of-2.
Same is enforced for size for RWF_ATOMIC.
Re: [PATCH v9 13/15] xfs: add xfs_compute_atomic_write_unit_max()
Quoted 16 lines · John Garry
Quoted 9 lines · Darrick J. Wong
Quoted 8 lines · John Garry
fs/xfs/xfs_mount.c xfs_agbtree_compute_maxlevels( · line 695
Quoted 5 lines · John Garry
fs/xfs/xfs_mount.c +5
-0+static inline xfs_extlen_t xfs_calc_perag_awu_max (struct xfs_mount *mp) +{ +if (mp->m_ddev_targp->bt_bdev_awu_min >0 ) +return max_pow_of_two_factor (mp->m_sb.sb_agblocks); +return mp->m_ag_max_usable;I think that this should be
rounddown_pow_of_two(mp->m_ag_max_usable)Quoted 5 lines
Quoted 3 lines
ditto for rt
I will fix (unless disagree).
I don't think this needs fixing. If there's no hardware support on the device, then we can do any size of atomic write that we want.
Quoted 8 lines
Check man pages for statx:
stx_atomic_write_unit_minstx_atomic_write_unit_max
... These values are each guaranteed to be a power-of-2.Same is enforced for size for
RWF_ATOMIC.
Ok then.
--D
PATCH v9 14/15 xfs: update atomic write limits
In reply to John GarryUpdate the limits returned from xfs_get_atomic_write_{min, max, max_opt)().
No reflink support always means no CoW-based atomic writes.
For updating xfs_get_atomic_write_min(), we support blocksize only and that depends on HW or reflink support.
For updating xfs_get_atomic_write_max(), for no reflink, we are limited to blocksize but only if HW support. Otherwise we are limited to combined limit in mp->m_atomic_write_unit_max.
For updating xfs_get_atomic_write_max_opt(), ultimately we are limited by the bdev atomic write limit. If xfs_get_atomic_write_max() does not report
Quoted 1 line
1x blocksize, then just continue to report 0 as before.
--- fs/xfs/xfs_file.c | 2 +- fs/xfs/xfs_iops.c | 52 +++++++++++++++++++++++++++++++++++++++++------ 2 files changed, 47 insertions(+), 7 deletions(-)
fs/xfs/xfs_file.c +1 -1
@@ -1557,7 +1557,7 @@ xfs_file_open(if (xfs_is_shutdown (XFS_M (inode->i_sb)))return -EIO ; file->f_mode |=FMODE_NOWAIT |FMODE_CAN_ODIRECT ; -if (xfs_inode_can_hw_atomic_write (XFS_I (inode))) +if (xfs_get_atomic_write_min (XFS_I (inode)) >0 ) file->f_mode |=FMODE_CAN_ATOMIC_WRITE ;return generic_file_open (inode, file); }
fs/xfs/xfs_iops.c +46 -6
73 lines not on this page · raw message
Signature · 1 line
2.31.1
PATCH v9 15/15 xfs: allow sysadmins to specify a maximum atomic write limit at mount time
In reply to John GarryFrom: "Darrick J. Wong" <[email protected]>
Introduce a mount option to allow sysadmins to specify the maximum size of an atomic write. If the filesystem can work with the supplied value, that becomes the new guaranteed maximum.
The value mustn't be too big for the existing filesystem geometry (max write size, max AG/rtgroup size). We dynamically recompute the tr_atomic_write transaction reservation based on the given block size, check that the current log size isn't less than the new minimum log size constraints, and set a new maximum.
The actual software atomic write max is still computed based off of tr_atomic_ioend the same way it has for the past few commits. Note also that xfs_calc_atomic_write_log_geometry is non-static because mkfs will need that.
--- Documentation/admin-guide/xfs.rst | 11 +++++ fs/xfs/libxfs/xfs_trans_resv.c | 69 ++++++++++++++++++++++++++ fs/xfs/libxfs/xfs_trans_resv.h | 4 ++ fs/xfs/xfs_mount.c | 80 ++++++++++++++++++++++++++++++- fs/xfs/xfs_mount.h | 6 +++ fs/xfs/xfs_super.c | 58 +++++++++++++++++++++- fs/xfs/xfs_trace.h | 33 +++++++++++++ 7 files changed, 259 insertions(+), 2 deletions(-)
Documentation/admin-guide/xfs.rst +11 -0
@@ -151,6 +151,17 @@ When mounting an XFS filesystem, the following options are accepted. optional, and the log section can be separate from the data section or contained within it. + max_atomic_write=value + Set the maximum size of an atomic write. The size may be + specified in bytes, in kilobytes with a "k" suffix, in megabytes + with a "m" suffix, or in gigabytes with a "g" suffix. The size + cannot be larger than the maximum write size, larger than the + size of any allocation group, or larger than the size of a + remapping operation that the log can complete atomically. + + The default value is to set the maximum I/O completion size + to allow each CPU to handle one at a time. + max_open_zones=value Specify the max number of zones to keep open for writing on a zoned rt device. Many open zones aids file data separation
fs/xfs/libxfs/xfs_trans_resv.c +69 -0
72 lines not on this page · raw message
fs/xfs/libxfs/xfs_trans_resv.h +4 -0
@@ -122,5 +122,9 @@ unsigned int xfs_calc_write_reservation_minlogsize(struct xfs_mount *mp);unsigned int xfs_calc_qm_dqalloc_reservation_minlogsize (struct xfs_mount *mp);xfs_extlen_t xfs_calc_max_atomic_write_fsblocks (struct xfs_mount *mp); +xfs_extlen_t xfs_calc_atomic_write_log_geometry (struct xfs_mount *mp, +xfs_extlen_t blockcount,unsigned int *new_logres); +int xfs_calc_atomic_write_reservation (struct xfs_mount *mp, +xfs_extlen_t blockcount);#endif /* __XFS_TRANS_RESV_H__ */
fs/xfs/xfs_mount.c +79 -1
92 lines not on this page · raw message
fs/xfs/xfs_mount.h +6 -0
@@ -237,6 +237,9 @@ typedef struct xfs_mount {unsigned int m_max_open_zones;unsigned int m_zonegc_low_space; +/* max_atomic_write mount option value */ +unsigned long long m_awu_max_bytes; +/* * Bitsets of per-fs metadata that have been checked and/or are sick. * Callers must hold m_sb_lock to access these two fields.
@@ -804,4 +807,7 @@ static inline void xfs_mod_sb_delalloc(struct xfs_mount *mp, int64_t delta) percpu_counter_add(&mp->m_delalloc_blks, delta); } +int xfs_set_max_atomic_write_opt (struct xfs_mount *mp, +unsigned long long new_max_bytes); +#endif /* __XFS_MOUNT_H__ */
fs/xfs/xfs_super.c +57 -1
94 lines not on this page · raw message
fs/xfs/xfs_trace.h +33 -0
@@ -230,6 +230,39 @@ TRACE_EVENT(xfs_calc_max_atomic_write_fsblocks, __entry->blockcount) ); +TRACE_EVENT (xfs_calc_max_atomic_write_log_geometry, + TP_PROTO(struct xfs_mount *mp, unsigned int per_intent, + unsigned int step_size, unsigned int blockcount, + unsigned int min_logblocks, unsigned int logres), +TP_ARGS (mp, per_intent, step_size, blockcount, min_logblocks, logres), +TP_STRUCT__entry ( + __field(dev_t, dev) + __field(unsigned int, per_intent) + __field(unsigned int, step_size) + __field(unsigned int, blockcount) + __field(unsigned int, min_logblocks) + __field(unsigned int, cur_logblocks) + __field(unsigned int, logres) + ), +TP_fast_assign ( + __entry->dev = mp->m_super->s_dev; + __entry->per_intent = per_intent; + __entry->step_size = step_size; + __entry->blockcount = blockcount; + __entry->min_logblocks = min_logblocks; + __entry->cur_logblocks = mp->m_sb.sb_logblocks; + __entry->logres = logres; + ), +TP_printk ("dev %d:%d per_intent %u step_size %u blockcount %u min_logblocks %u logblocks %u logres %u" , +MAJOR (__entry->dev),MINOR (__entry->dev), + __entry->per_intent, + __entry->step_size, + __entry->blockcount, + __entry->min_logblocks, + __entry->cur_logblocks, + __entry->logres) +); + TRACE_EVENT(xlog_intent_recovery_failed, TP_PROTO(struct xfs_mount *mp, const struct xfs_defer_op_type *ops, int error),
Signature · 1 line
2.31.1
Re: [PATCH v9 15/15] xfs: allow sysadmins to specify a maximum atomic write limit at mount time
So I guess the property variant didn't work out based on the replies from Darrick last round?
Re: [PATCH v9 15/15] xfs: allow sysadmins to specify a maximum atomic write limit at mount time
Quoted 2 lines · Christoph Hellwig
So I guess the property variant didn't work out based on the replies from Darrick last round?
Correct. Calling setxattr on the property wouldn't call xfs_set_max_atomic_write_opt to change the operational limit, and I don't want to start up the whole magic xattrs discussion again by making xfs_xattr_set do extra things if name=="trusted.xfs:max_atomic_write".
(Though iirc you were the most opposed to magic xattrs, and my opposition is 45% yuck factor and 55% "hch will nak it anyway" ;) )
--D
Hi Christoph,
At this point, is your only issue now with
05/15 xfs: ignore HW which cannot atomic write a single block ?
I am not sure on 15/15...
Thanks,
John
Quoted 7 lines · John Garry
Hi Christoph,
At this point, is your only issue now with
05/15 xfs: ignore HW which cannot atomic write a single block ?I am not sure on 15/15...
This series still needs reviews of patches 2, 3, 5, and 15, if I'm not mistaken.
--D
Quoted 3 lines
Thanks,
John
Quoted 11 lines · Darrick J. Wong
Quoted 7 lines · John Garry
Hi Christoph,
At this point, is your only issue now with
05/15 xfs: ignore HW which cannot atomic write a single block ?I am not sure on 15/15...
This series still needs reviews of patches 2, 3, 5, and 15, if I'm not mistaken.
I can review 2 and 3, but I am not familiar with the code so I don't think that there is much value in that. I feel that very few are. So who else will?
Quoted 7 lines · John Garry
Hi Christoph,
At this point, is your only issue now with
05/15 xfs: ignore HW which cannot atomic write a single block ?I am not sure on 15/15...
I don't like it, but it's a mount option and nothing persistent so I should probably just shut up.