RFC: support for zoned devices
Re: [PATCH 27/43] xfs: implement buffered writes to zoned RT devices
In reply to Christoph HellwigQuoted 20 lines · Christoph Hellwig
Implement buffered writes including page faults and block zeroing for zoned RT devices. Buffered writes to zoned RT devices are split into three phases:
1) a reservation for the worst case data block usage is taken before acquiring the iolock. When there are enough free blocks but not enough available one, garbage collection is kicked of to free the space before continuing with the write. If there isn't enough freeable space, the block reservation is reduced and a short write will happen as expected by normal Linux write semantics.
2) with the iolock held, the generic iomap buffered write code is called, which through theiomap_beginoperation usually just inserts delalloc extents for the range in a single iteration. Only for overwrites of existing data that are not block aligned, or zeroing operations the existing extent mapping is read to fill out the srcmap and to figure out if zeroing is required.
3) the ->map_blocks callback to the generic iomap writeback code calls into the zoned space allocator to actually allocate on-disk space for the range before kicking of the writeback.
Quoted 10 lines
Note that because all writes are out of place, truncate or hole punches that are not aligned to block size boundaries need to allocate space. For block zeroing from truncate, ->setattr is called with the iolock (aka
i_rwsem) already held, so a hacky deviation from the above scheme is needed. In this case the space reservations is called with the iolock held, but is required not to block and can dip into the reserved block pool. This can lead to-ENOSPCwhen truncating a file, which is unfortunate. But fixing the calling conventions in the VFS is probably much easier with code requiring it already in mainline.
Urk, that's messy. :(
Quoted 18 lines
Signed-off-by Christoph Hellwig <[email protected]>--- fs/xfs/xfs_aops.c | 134 +++++++++++++++++++++++++-- fs/xfs/xfs_bmap_util.c | 21 +++-- fs/xfs/xfs_bmap_util.h | 12 ++- fs/xfs/xfs_file.c | 202 +++++++++++++++++++++++++++++++++++++---- fs/xfs/xfs_iomap.c | 186 ++++++++++++++++++++++++++++++++++++- fs/xfs/xfs_iomap.h | 6 +- fs/xfs/xfs_iops.c | 31 ++++++- fs/xfs/xfs_reflink.c | 2 +- fs/xfs/xfs_trace.h | 1 + 9 files changed, 550 insertions(+), 45 deletions(-)fs/xfs/xfs_aops.c +0
-0
fs/xfs/xfs_aops.c line 4
Quoted 5 lines
fs/xfs/xfs_aops.c +1
-1@@ -1,7 +1,7 @@// SPDX-License-Identifier: GPL-2.0 /* * Copyright (c) 2000-2005 Silicon Graphics, Inc. -* Copyright (c) 2016-2018 Christoph Hellwig. +* Copyright (c) 2016-2023 Christoph Hellwig.
2024, surely?
Or at this point, 2025
Quoted 146 lines
fs/xfs/xfs_aops.c +81
-5* All Rights Reserved. */ #include "xfs.h" @@ -19,6 +19,8 @@#include "xfs_reflink.h" #include "xfs_errortag.h" #include "xfs_error.h" +#include "xfs_zone_alloc.h" +#include "xfs_rtgroup.h" struct xfs_writepage_ctx {struct iomap_writepage_ctx ctx;@@ -85,6 +87,7 @@ xfs_end_ioend( {struct xfs_inode *ip =XFS_I (ioend->io_inode);struct xfs_mount *mp = ip->i_mount; +bool is_zoned =xfs_is_zoned_inode (ip);xfs_off_t offset = ioend->io_offset;size_t size = ioend->io_size;unsigned int nofs_flag;@@ -115,9 +118,10 @@ xfs_end_ioend( error =blk_status_to_errno (ioend->io_bio.bi_status);if (unlikely (error)) {if (ioend->io_flags &IOMAP_IOEND_SHARED ) { +ASSERT (!is_zoned);xfs_reflink_cancel_cow_range (ip, offset, size, true);xfs_bmap_punch_delalloc_range (ip,XFS_DATA_FORK , offset, - offset + size); + offset + size,NULL ); } goto done; }@@ -125,7 +129,10 @@ xfs_end_ioend(/* * Success: commit the COW or unwritten blocks if needed. */ -if (ioend->io_flags &IOMAP_IOEND_SHARED ) +if (is_zoned) + error =xfs_zoned_end_io (ip, offset, size, ioend->io_sector, +NULLFSBLOCK ); +else if (ioend->io_flags &IOMAP_IOEND_SHARED ) error =xfs_reflink_end_cow (ip, offset, size);else if (ioend->io_flags &IOMAP_IOEND_UNWRITTEN ) error =xfs_iomap_write_unwritten (ip, offset, size, false);@@ -175,17 +182,27 @@ xfs_end_io( } } -STATIC void +static void xfs_end_bio (struct bio *bio) {struct iomap_ioend *ioend =iomap_ioend_from_bio (bio);struct xfs_inode *ip =XFS_I (ioend->io_inode); +struct xfs_mount *mp = ip->i_mount;unsigned long flags; +/* +* For Appends record the actually written block number and set the +* boundary flag if needed. +*/ +if (IS_ENABLED (CONFIG_XFS_RT ) &&bio_is_zone_append (bio)) { + ioend->io_sector = bio->bi_iter.bi_sector; +xfs_mark_rtg_boundary (ioend); + } +spin_lock_irqsave (&ip->i_ioend_lock, flags);if (list_empty (&ip->i_ioend_list)) -WARN_ON_ONCE (!queue_work (ip->i_mount->m_unwritten_workqueue, +WARN_ON_ONCE (!queue_work (mp->m_unwritten_workqueue, &ip->i_ioend_work));list_add_tail (&ioend->io_list, &ip->i_ioend_list);spin_unlock_irqrestore (&ip->i_ioend_lock, flags);@@ -462,7 +479,7 @@ xfs_discard_folio(* folio itself and not the start offset that is passed in. */ xfs_bmap_punch_delalloc_range (ip,XFS_DATA_FORK , pos, -folio_pos (folio) +folio_size (folio)); +folio_pos (folio) +folio_size (folio),NULL ); }static const struct iomap_writeback_ops xfs_writeback_ops = {@@ -471,14 +488,117 @@ static const struct iomap_writeback_ops xfs_writeback_ops = { .discard_folio = xfs_discard_folio, }; +struct xfs_zoned_writepage_ctx { +struct iomap_writepage_ctx ctx; +struct xfs_open_zone *open_zone; +}; + +static inline struct xfs_zoned_writepage_ctx * +XFS_ZWPC (struct iomap_writepage_ctx *ctx) +{ + return container_of(ctx, struct xfs_zoned_writepage_ctx, ctx); +} + +static int +xfs_zoned_map_blocks ( +struct iomap_writepage_ctx *wpc, +struct inode *inode, +loff_t offset, +unsigned int len) +{ +struct xfs_inode *ip =XFS_I (inode); +struct xfs_mount *mp = ip->i_mount; +xfs_fileoff_t offset_fsb =XFS_B_TO_FSBT (mp, offset); +xfs_fileoff_t end_fsb =XFS_B_TO_FSB (mp, offset + len); +xfs_filblks_t count_fsb; +struct xfs_bmbt_irec imap, del; +struct xfs_iext_cursor icur; + +if (xfs_is_shutdown (mp)) +return -EIO ; + +XFS_ERRORTAG_DELAY (mp,XFS_ERRTAG_WB_DELAY_MS ); + +/* +* All dirty data must be covered by delalloc extents. But truncate can +* remove delalloc extents underneath us or reduce their size. +* Returning a hole tells iomap to not write back any data from this +* range, which is the right thing to do in that case. +* +* Otherwise just tell iomap to treat ranges previously covered by a +* delalloc extent as mapped. The actual block allocation will be done +* just before submitting the bio. +*/ +xfs_ilock (ip,XFS_ILOCK_EXCL ); +if (!xfs_iext_lookup_extent (ip, ip->i_cowfp, offset_fsb, &icur, &imap)) + imap.br_startoff = end_fsb;/* fake a hole past EOF */ +if (imap.br_startoff > offset_fsb) { + imap.br_blockcount = imap.br_startoff - offset_fsb; + imap.br_startoff = offset_fsb; + imap.br_startblock =HOLESTARTBLOCK ; + imap.br_state =XFS_EXT_NORM ; +xfs_iunlock (ip,XFS_ILOCK_EXCL ); +xfs_bmbt_to_iomap (ip, &wpc->iomap, &imap,0 ,0 ,0 ); +return 0 ; + } + end_fsb =min (end_fsb, imap.br_startoff + imap.br_blockcount); + count_fsb = end_fsb - offset_fsb; + + del = imap; +xfs_trim_extent (&del, offset_fsb, count_fsb); + xfs_bmap_del_extent_delay(ip, XFS_COW_FORK, &icur, &imap, &del,
fs/xfs/xfs_aops.c static const struct iomap_writeback_ops xfs_writeback_ops = { · line 559
Quoted 10 lines
fs/xfs/xfs_aops.c +10
-0+ XFS_BMAPI_REMAP); +xfs_iunlock (ip,XFS_ILOCK_EXCL ); + + wpc->iomap.type =IOMAP_MAPPED ; + wpc->iomap.flags =IOMAP_F_DIRTY ; + wpc->iomap.bdev = mp->m_rtdev_targp->bt_bdev; + wpc->iomap.offset = offset; + wpc->iomap.length =XFS_FSB_TO_B (mp, count_fsb); + wpc->iomap.flags =IOMAP_F_ZONE_APPEND ; + wpc->iomap.addr =0 ;
/me wonders if this should be set somewhere other than block 0 just in case we screw up? That might just be paranoia since I think iomap puts the bio if it doesn't get to ->submit_bio.
Quoted 26 lines
fs/xfs/xfs_aops.c +23
-0+ +trace_xfs_zoned_map_blocks (ip, offset, wpc->iomap.length); +return 0 ; +} + +static int +xfs_zoned_submit_ioend ( +struct iomap_writepage_ctx *wpc, +int status) +{ + wpc->ioend->io_bio.bi_end_io = xfs_end_bio; +if (status) +return status; +xfs_zone_alloc_and_submit (wpc->ioend, &XFS_ZWPC (wpc)->open_zone); +return 0 ; +} + +static const struct iomap_writeback_ops xfs_zoned_writeback_ops = { + .map_blocks = xfs_zoned_map_blocks, + .submit_ioend = xfs_zoned_submit_ioend, + .discard_folio = xfs_discard_folio, +}; + STATIC int xfs_vm_writepages( struct address_space *mapping,
fs/xfs/xfs_aops.c static const struct iomap_writeback_ops xfs_writeback_ops = { · line 594
Quoted 10 lines
fs/xfs/xfs_aops.c +5
-1struct writeback_control *wbc) { +struct xfs_inode *ip =XFS_I (mapping->host);struct xfs_writepage_ctx wpc = { }; +int error; -xfs_iflags_clear (XFS_I (mapping->host),XFS_ITRUNCATED ); +xfs_iflags_clear (ip,XFS_ITRUNCATED ); +if (xfs_is_zoned_inode (ip)) { +struct xfs_zoned_writepage_ctx xc = { };
I noticed that the zoned writepage ctx doesn't track data/cow fork sequence numbers. Why is this not necessary? Can we not race with someone else doing writeback?
Quoted 302 lines
fs/xfs/xfs_aops.c +7
-0+ + error =iomap_writepages (mapping, wbc, &xc.ctx, + &xfs_zoned_writeback_ops); +if (xc.open_zone) +xfs_open_zone_put (xc.open_zone); +return error; + }return iomap_writepages (mapping, wbc, &wpc.ctx, &xfs_writeback_ops); }fs/xfs/xfs_bmap_util.c +14
-7@@ -30,6 +30,7 @@#include "xfs_reflink.h" #include "xfs_rtbitmap.h" #include "xfs_rtgroup.h" +#include "xfs_zone_alloc.h" /* Kernel only BMAP related definitions and functions */ @@ -436,7 +437,8 @@ xfs_bmap_punch_delalloc_range(struct xfs_inode *ip, int whichfork, xfs_off_t start_byte, - xfs_off_t end_byte) + xfs_off_t end_byte, + struct xfs_zone_alloc_ctx *ac) { struct xfs_mount *mp = ip->i_mount;struct xfs_ifork *ifp =xfs_ifork_ptr (ip, whichfork);@@ -467,7 +469,10 @@ xfs_bmap_punch_delalloc_range(continue ; } -xfs_bmap_del_extent_delay (ip, whichfork, &icur, &got, &del,0 ); +xfs_bmap_del_extent_delay (ip, whichfork, &icur, &got, &del, + ac ?XFS_BMAPI_REMAP :0 ); +if (xfs_is_zoned_inode (ip) && ac) + ac->reserved_blocks += del.br_blockcount;if (!xfs_iext_get_extent (ifp, &icur, &got))break ; }@@ -582,7 +587,7 @@ xfs_free_eofblocks(if (ip->i_delayed_blks) {xfs_bmap_punch_delalloc_range (ip,XFS_DATA_FORK ,round_up (XFS_ISIZE (ip), mp->m_sb.sb_blocksize), -LLONG_MAX ); +LLONG_MAX ,NULL ); }xfs_inode_clear_eofblocks_tag (ip);return 0 ;@@ -825,7 +830,8 @@ intxfs_free_file_space ( struct xfs_inode *ip, xfs_off_t offset, - xfs_off_t len) + xfs_off_t len, + struct xfs_zone_alloc_ctx *ac) { struct xfs_mount *mp = ip->i_mount;xfs_fileoff_t startoffset_fsb;@@ -880,7 +886,7 @@ xfs_free_file_space(return 0 ;if (offset + len >XFS_ISIZE (ip)) len =XFS_ISIZE (ip) - offset; - error =xfs_zero_range (ip, offset, len,NULL ); + error =xfs_zero_range (ip, offset, len, ac,NULL );if (error)return error;@@ -968,7 +974,8 @@ intxfs_collapse_file_space ( struct xfs_inode *ip, xfs_off_t offset, - xfs_off_t len) + xfs_off_t len, + struct xfs_zone_alloc_ctx *ac) { struct xfs_mount *mp = ip->i_mount;struct xfs_trans *tp;@@ -981,7 +988,7 @@ xfs_collapse_file_space(trace_xfs_collapse_file_space (ip); - error =xfs_free_file_space (ip, offset, len); + error =xfs_free_file_space (ip, offset, len, ac);if (error)return error;fs/xfs/xfs_bmap_util.h +7
-5@@ -15,6 +15,7 @@ struct xfs_inode;struct xfs_mount ;struct xfs_trans ;struct xfs_bmalloca ; +struct xfs_zone_alloc_ctx ;#ifdef CONFIG_XFS_RT int xfs_bmap_rtalloc (struct xfs_bmalloca *ap);@@ -31,7 +32,8 @@ xfs_bmap_rtalloc(struct xfs_bmalloca *ap)#endif /* CONFIG_XFS_RT */ void xfs_bmap_punch_delalloc_range (struct xfs_inode *ip,int whichfork, -xfs_off_t start_byte,xfs_off_t end_byte); +xfs_off_t start_byte,xfs_off_t end_byte, +struct xfs_zone_alloc_ctx *ac);struct kgetbmap {__s64 bmv_offset;/* file offset of segment in blocks */ @@ -54,13 +56,13 @@ int xfs_bmap_last_extent(struct xfs_trans *tp, struct xfs_inode *ip,/* preallocation and hole punch interface */ int xfs_alloc_file_space (struct xfs_inode *ip,xfs_off_t offset, -xfs_off_t len); +xfs_off_t len);int xfs_free_file_space (struct xfs_inode *ip,xfs_off_t offset, -xfs_off_t len); +xfs_off_t len,struct xfs_zone_alloc_ctx *ac);int xfs_collapse_file_space (struct xfs_inode *,xfs_off_t offset, -xfs_off_t len); +xfs_off_t len,struct xfs_zone_alloc_ctx *ac);int xfs_insert_file_space (struct xfs_inode *,xfs_off_t offset, -xfs_off_t len); +xfs_off_t len);/* EOF block manipulation functions */ bool xfs_can_free_eofblocks (struct xfs_inode *ip);fs/xfs/xfs_file.c +85
-8@@ -25,6 +25,7 @@#include "xfs_iomap.h" #include "xfs_reflink.h" #include "xfs_file.h" +#include "xfs_zone_alloc.h" #include <linux/dax.h> #include <linux/falloc.h> @@ -360,7 +361,8 @@ xfs_file_write_zero_eof(struct iov_iter *from, unsigned int *iolock, size_t count, - bool *drained_dio) + bool *drained_dio, + struct xfs_zone_alloc_ctx *ac) { struct xfs_inode *ip = XFS_I(iocb->ki_filp->f_mapping->host);loff_t isize;@@ -414,7 +416,7 @@ xfs_file_write_zero_eof(trace_xfs_zero_eof (ip, isize, iocb->ki_pos - isize);xfs_ilock (ip,XFS_MMAPLOCK_EXCL ); - error =xfs_zero_range (ip, isize, iocb->ki_pos - isize,NULL ); + error =xfs_zero_range (ip, isize, iocb->ki_pos - isize, ac,NULL );xfs_iunlock (ip,XFS_MMAPLOCK_EXCL );return error;@@ -431,7 +433,8 @@ STATIC ssize_txfs_file_write_checks ( struct kiocb *iocb, struct iov_iter *from, - unsigned int *iolock) + unsigned int *iolock, + struct xfs_zone_alloc_ctx *ac) { struct inode *inode = iocb->ki_filp->f_mapping->host;size_t count =iov_iter_count (from);@@ -481,7 +484,7 @@ xfs_file_write_checks(*/ if (iocb->ki_pos >i_size_read (inode)) { error =xfs_file_write_zero_eof (iocb, from, iolock, count, - &drained_dio); + &drained_dio, ac);if (error ==1 ) goto restart;if (error)@@ -491,6 +494,48 @@ xfs_file_write_checks(return kiocb_modified (iocb); } +static ssize_t +xfs_zoned_write_space_reserve ( +struct xfs_inode *ip, +struct kiocb *iocb, +struct iov_iter *from, +unsigned int flags, +struct xfs_zone_alloc_ctx *ac) +{ +loff_t count =iov_iter_count (from); +int error; + +if (iocb->ki_flags &IOCB_NOWAIT ) + flags |=XFS_ZR_NOWAIT ; + +/* +* Check the rlimit and LFS boundary first so that we don't over-reserve +* by possibly a lot. +* +* The generic write path will redo this check later, and it might have +* changed by then. If it got expanded we'll stick to our earlier +* smaller limit, and if it is decreased the new smaller limit will be +* used and our extra space reservation will be returned after finishing +* the write. +*/ + error =generic_write_check_limits (iocb->ki_filp, iocb->ki_pos, &count); +if (error) +return error; + +/* +* Sloppily round up count to file system blocks. +* +* This will often reserve an extra block, but that avoids having to look +* at the start offset, which isn't stable for O_APPEND until taking the +* iolock. Also we need to reserve a block each for zeroing the old +* EOF block and the new start block if they are unaligned. +* +* Any remaining block will be returned after the write. +*/ +return xfs_zoned_space_reserve (ip, +XFS_B_TO_FSB (ip->i_mount, count) +1 +2 , flags, ac); +} + static int xfs_dio_write_end_io( struct kiocb *iocb,@@ -597,7 +642,7 @@ xfs_file_dio_write_aligned( ret =xfs_ilock_iocb_for_write (iocb, &iolock);if (ret)return ret; - ret =xfs_file_write_checks (iocb, from, &iolock); + ret =xfs_file_write_checks (iocb, from, &iolock,NULL );if (ret) goto out_unlock;@@ -675,7 +720,7 @@ xfs_file_dio_write_unaligned( goto out_unlock; } - ret =xfs_file_write_checks (iocb, from, &iolock); + ret =xfs_file_write_checks (iocb, from, &iolock,NULL );if (ret) goto out_unlock;@@ -749,7 +794,7 @@ xfs_file_dax_write( ret =xfs_ilock_iocb (iocb, iolock);if (ret)return ret; - ret =xfs_file_write_checks (iocb, from, &iolock); + ret =xfs_file_write_checks (iocb, from, &iolock,NULL );if (ret) goto out;@@ -793,7 +838,7 @@ xfs_file_buffered_write(if (ret)return ret; - ret =xfs_file_write_checks (iocb, from, &iolock); + ret =xfs_file_write_checks (iocb, from, &iolock,NULL );if (ret) goto out;@@ -840,6 +885,67 @@ xfs_file_buffered_write(return ret; } +STATIC ssize_t +xfs_file_buffered_write_zoned ( +struct kiocb *iocb, +struct iov_iter *from) +{ +struct xfs_inode *ip =XFS_I (iocb->ki_filp->f_mapping->host); +struct xfs_mount *mp = ip->i_mount; +unsigned int iolock =XFS_IOLOCK_EXCL ; +bool cleared_space = false; +struct xfs_zone_alloc_ctx ac = { }; +ssize_t ret; + + ret =xfs_zoned_write_space_reserve (ip, iocb, from,XFS_ZR_GREEDY , &ac); +if (ret <0 ) +return ret; + + ret =xfs_ilock_iocb (iocb, iolock); +if (ret) + goto out_unreserve; + + ret =xfs_file_write_checks (iocb, from, &iolock, &ac); +if (ret) + goto out_unlock; + +/* +* Truncate the iter to the length that we were actually able to +* allocate blocks for. This needs to happen after +* xfs_file_write_checks, because that assigns ki_pos for O_APPEND +* writes. +*/ + iov_iter_truncate(from, + XFS_FSB_TO_B(mp, ac.reserved_blocks) -
fs/xfs/xfs_file.c xfs_file_buffered_write( · line 929
Quoted 10 lines
fs/xfs/xfs_file.c +10
-0+ (iocb->ki_pos & mp->m_blockmask)); +if (!iov_iter_count (from)) + goto out_unlock; + +retry: +trace_xfs_file_buffered_write (iocb, from); + ret =iomap_file_buffered_write (iocb, from, + &xfs_buffered_write_iomap_ops, &ac); +if (ret == -ENOSPC && !cleared_space) { +/*
^ extra space
Quoted 159 lines
fs/xfs/xfs_file.c +59
-10+* Kick off writeback to convert delalloc space and release the +* usually too pessimistic indirect block reservations. +*/ +xfs_flush_inodes (mp); + cleared_space = true; + goto retry; + } + +out_unlock: +xfs_iunlock (ip, iolock); +out_unreserve: +xfs_zoned_space_unreserve (ip, &ac); +if (ret >0 ) { +XFS_STATS_ADD (mp, xs_write_bytes, ret); + ret =generic_write_sync (iocb, ret); + } +return ret; +} + STATIC ssize_t xfs_file_write_iter( struct kiocb *iocb,@@ -887,6 +993,8 @@ xfs_file_write_iter(return ret; } +if (xfs_is_zoned_inode (ip)) +return xfs_file_buffered_write_zoned (iocb, from);return xfs_file_buffered_write (iocb, from); }@@ -941,7 +1049,8 @@ static intxfs_falloc_collapse_range ( struct file *file, loff_t offset, - loff_t len) + loff_t len, + struct xfs_zone_alloc_ctx *ac) { struct inode *inode = file_inode(file);loff_t new_size =i_size_read (inode) - len;@@ -957,7 +1066,7 @@ xfs_falloc_collapse_range(if (offset + len >=i_size_read (inode))return -EINVAL ; - error =xfs_collapse_file_space (XFS_I (inode), offset, len); + error =xfs_collapse_file_space (XFS_I (inode), offset, len, ac);if (error)return error;return xfs_falloc_setsize (file, new_size);@@ -1013,7 +1122,8 @@ xfs_falloc_zero_range(struct file *file, int mode, loff_t offset, - loff_t len) + loff_t len, + struct xfs_zone_alloc_ctx *ac) { struct inode *inode = file_inode(file);unsigned int blksize =i_blocksize (inode);@@ -1026,7 +1136,7 @@ xfs_falloc_zero_range(if (error)return error; - error =xfs_free_file_space (XFS_I (inode), offset, len); + error =xfs_free_file_space (XFS_I (inode), offset, len, ac);if (error)return error;@@ -1107,12 +1217,29 @@ xfs_file_fallocate(struct xfs_inode *ip =XFS_I (inode);long error;uint iolock =XFS_IOLOCK_EXCL |XFS_MMAPLOCK_EXCL ; +struct xfs_zone_alloc_ctx ac = { };if (!S_ISREG (inode->i_mode))return -EINVAL ;if (mode & ~XFS_FALLOC_FL_SUPPORTED )return -EOPNOTSUPP ; +/* +* For zoned file systems, zeroing the first and last block of a hole +* punch requires allocating a new block to rewrite the remaining data +* and new zeroes out of place. Get a reservations for those before +* taking the iolock. Dip into the reserved pool because we are +* expected to be able to punch a hole even on a completely full +* file system. +*/ +if (xfs_is_zoned_inode (ip) && + (mode & (FALLOC_FL_PUNCH_HOLE |FALLOC_FL_ZERO_RANGE | +FALLOC_FL_COLLAPSE_RANGE ))) { + error =xfs_zoned_space_reserve (ip,2 ,XFS_ZR_RESERVED , &ac); +if (error) +return error; + } +xfs_ilock (ip, iolock); error =xfs_break_layouts (inode, &iolock,BREAK_UNMAP );if (error)@@ -1133,16 +1260,16 @@ xfs_file_fallocate(switch (mode &FALLOC_FL_MODE_MASK ) {case FALLOC_FL_PUNCH_HOLE : - error =xfs_free_file_space (ip, offset, len); + error =xfs_free_file_space (ip, offset, len, &ac);break ;case FALLOC_FL_COLLAPSE_RANGE : - error =xfs_falloc_collapse_range (file, offset, len); + error =xfs_falloc_collapse_range (file, offset, len, &ac);break ;case FALLOC_FL_INSERT_RANGE : error =xfs_falloc_insert_range (file, offset, len);break ;case FALLOC_FL_ZERO_RANGE : - error =xfs_falloc_zero_range (file, mode, offset, len); + error =xfs_falloc_zero_range (file, mode, offset, len, &ac);break ;case FALLOC_FL_UNSHARE_RANGE : error =xfs_falloc_unshare_range (file, mode, offset, len);@@ -1160,6 +1287,8 @@ xfs_file_fallocate( out_unlock:xfs_iunlock (ip, iolock); +if (xfs_is_zoned_inode (ip)) +xfs_zoned_space_unreserve (ip, &ac);return error; }@@ -1485,9 +1614,10 @@ xfs_dax_read_fault(* i_lock (XFS - extent map serialisation) */ static vm_fault_t -xfs_write_fault ( +__xfs_write_fault (struct vm_fault *vmf, -unsigned int order) +unsigned int order, +struct xfs_zone_alloc_ctx *ac) {struct inode *inode =file_inode (vmf->vma->vm_file);struct xfs_inode *ip =XFS_I (inode);@@ -1515,13 +1645,49 @@ xfs_write_fault( ret =xfs_dax_fault_locked (vmf, order, true); else ret =iomap_page_mkwrite (vmf, &xfs_buffered_write_iomap_ops, -NULL ); + ac);xfs_iunlock (ip, lock_mode);sb_end_pagefault (inode->i_sb);return ret; } +static vm_fault_t +xfs_write_fault_zoned ( +struct vm_fault *vmf, +unsigned int order) +{ +struct xfs_inode *ip =XFS_I (file_inode (vmf->vma->vm_file));
fs/xfs/xfs_file.c xfs_write_fault( · line 1670
Quoted 10 lines
fs/xfs/xfs_file.c +10
-0+unsigned int len =folio_size (page_folio (vmf->page)); +struct xfs_zone_alloc_ctx ac = { }; +int error; +vm_fault_t ret; + +/* +* This could over-allocate as it doesn't check for truncation. +* +* But as the overallocation is limited to less than a folio and will be +8 release instantly that's just fine.
Nit: ^ should be an asterisk.
Quoted 40 lines
fs/xfs/xfs_file.c +20
-0+*/ + error =xfs_zoned_space_reserve (ip,XFS_B_TO_FSB (ip->i_mount, len),0 , + &ac); +if (error <0 ) +return vmf_fs_error (error); + ret =__xfs_write_fault (vmf, order, &ac); +xfs_zoned_space_unreserve (ip, &ac); +return ret; +} + +static vm_fault_t +xfs_write_fault ( +struct vm_fault *vmf, +unsigned int order) +{ +if (xfs_is_zoned_inode (XFS_I (file_inode (vmf->vma->vm_file)))) +return xfs_write_fault_zoned (vmf, order); +return __xfs_write_fault (vmf, order,NULL ); +} +static inline bool xfs_is_write_fault (struct vm_fault *vmf)fs/xfs/xfs_iomap.c +2
-0@@ -31,6 +31,7 @@#include "xfs_health.h" #include "xfs_rtbitmap.h" #include "xfs_icache.h" +#include "xfs_zone_alloc.h" #define XFS_ALLOC_ALIGN (mp, off) \ (((off) >> mp->m_allocsize_log) << mp->m_allocsize_log)@@ -1270,6 +1271,176 @@ xfs_bmapi_reserve_delalloc(return error; } +static int
fs/xfs/xfs_iomap.c xfs_bmapi_reserve_delalloc( · line 1284
Quoted 10 lines
fs/xfs/xfs_iomap.c +10
-0+xfs_zoned_buffered_write_iomap_begin ( + struct inode *inode, + loff_t offset, + loff_t count, + unsigned flags, + struct iomap *iomap, + struct iomap *srcmap) +{ + struct iomap_iter *iter = + container_of(iomap, struct iomap_iter, iomap);
I still wonder if iomap should be passing a (const struct iomap_iter *) to the ->iomap_begin function instead of passing all these variables and then implementations have to container_of if they want iter->private too.
Quoted 108 lines
fs/xfs/xfs_iomap.c +108
-0+struct xfs_zone_alloc_ctx *ac = iter->private; +struct xfs_inode *ip =XFS_I (inode); +struct xfs_mount *mp = ip->i_mount; +xfs_fileoff_t offset_fsb =XFS_B_TO_FSBT (mp, offset); +xfs_fileoff_t end_fsb =xfs_iomap_end_fsb (mp, offset, count); +u16 iomap_flags =IOMAP_F_SHARED ; +unsigned int lockmode =XFS_ILOCK_EXCL ; +xfs_filblks_t count_fsb; +xfs_extlen_t indlen; +struct xfs_bmbt_irec got; +struct xfs_iext_cursor icur; +int error =0 ; + +ASSERT (!xfs_get_extsz_hint (ip)); +ASSERT (!(flags &IOMAP_UNSHARE )); +ASSERT (ac); + +if (xfs_is_shutdown (mp)) +return -EIO ; + + error =xfs_qm_dqattach (ip); +if (error) +return error; + + error =xfs_ilock_for_iomap (ip, flags, &lockmode); +if (error) +return error; + +if (XFS_IS_CORRUPT (mp, !xfs_ifork_has_extents (&ip->i_df)) || +XFS_TEST_ERROR (false, mp,XFS_ERRTAG_BMAPIFORMAT )) { +xfs_bmap_mark_sick (ip,XFS_DATA_FORK ); + error = -EFSCORRUPTED ; + goto out_unlock; + } + +XFS_STATS_INC (mp, xs_blk_mapw); + + error =xfs_iread_extents (NULL , ip,XFS_DATA_FORK ); +if (error) + goto out_unlock; + +/* +* For zeroing operations check if there is any data to zero first. +* +* For regular writes we always need to allocate new blocks, but need to +* provide the source mapping when the range is unaligned to support +* read-modify-write of the whole block in the page cache. +* +* In either case we need to limit the reported range to the boundaries +* of the source map in the data fork. +*/ +if (!IS_ALIGNED (offset, mp->m_sb.sb_blocksize) || + !IS_ALIGNED (offset + count, mp->m_sb.sb_blocksize) || + (flags &IOMAP_ZERO )) { +struct xfs_bmbt_irec smap; +struct xfs_iext_cursor scur; + +if (!xfs_iext_lookup_extent (ip, &ip->i_df, offset_fsb, &scur, + &smap)) + smap.br_startoff = end_fsb;/* fake hole until EOF */ +if (smap.br_startoff > offset_fsb) { +/* +* We never need to allocate blocks for zeroing a hole. +*/ +if (flags &IOMAP_ZERO ) { +xfs_hole_to_iomap (ip, iomap, offset_fsb, + smap.br_startoff); + goto out_unlock; + } + end_fsb =min (end_fsb, smap.br_startoff); + }else { + end_fsb =min (end_fsb, + smap.br_startoff + smap.br_blockcount); +xfs_trim_extent (&smap, offset_fsb, + end_fsb - offset_fsb); + error =xfs_bmbt_to_iomap (ip, srcmap, &smap, flags,0 , +xfs_iomap_inode_sequence (ip,0 )); +if (error) + goto out_unlock; + } + } + +if (!ip->i_cowfp) +xfs_ifork_init_cow (ip); + +if (!xfs_iext_lookup_extent (ip, ip->i_cowfp, offset_fsb, &icur, &got)) + got.br_startoff = end_fsb; +if (got.br_startoff <= offset_fsb) { +trace_xfs_reflink_cow_found (ip, &got); + goto done; + } + +/* +* Cap the maximum length to keep the chunks of work done here somewhat +* symmetric with the work writeback does. +*/ + end_fsb =min (end_fsb, got.br_startoff); + count_fsb =min3 (end_fsb - offset_fsb,XFS_MAX_BMBT_EXTLEN , +XFS_B_TO_FSB (mp,1024 *PAGE_SIZE )); + +/* +* The block reservation is supposed to cover all blocks that the +* operation could possible write, but there is a nasty corner case +* where blocks could be stolen from underneath us: +* +* 1) while this thread iterates over a larger buffered write, +* 2) another thread is causing a write fault that calls into +* ->page_mkwrite in range this thread writes to, using up the
fs/xfs/xfs_iomap.c xfs_bmapi_reserve_delalloc( · line 1402
Quoted 10 lines
fs/xfs/xfs_iomap.c +10
-0+* delalloc reservation created by a previous call to this function. +* 3) another thread does direct I/O on the range that the write fault +* happened on, which causes writeback of the dirty data. +* 4) this then set the stale flag, which cuts the current iomap +* iteration short, causing the new call to ->iomap_begin that gets +* us here again, but now without a sufficient reservation. +* +* This is a very unusual I/O pattern, and nothing but generic/095 is +* known to hit it. There's not really much we can do here, so turn this +* into a short write.
Wheeeeee. >:(
fs/xfs/xfs_iomap.c xfs_bmapi_reserve_delalloc( · line 1407
Quoted 5 lines
fs/xfs/xfs_iomap.c +5
-0+*/ +if (count_fsb > ac->reserved_blocks) { +xfs_warn_ratelimited (mp, +"Short write on ino 0x%llx comm %.20s due to three-way race with write fault and direct I/O" , + ip->i_ino, current->comm);
Aren't continuations ^^^ supposed to be indented two tabs?
Quoted 191 lines
fs/xfs/xfs_iomap.c +48
-3+ count_fsb = ac->reserved_blocks; +if (!count_fsb) { + error = -EIO ; + goto out_unlock; + } + } + + error =xfs_quota_reserve_blkres (ip, count_fsb); +if (error) + goto out_unlock; + + indlen =xfs_bmap_worst_indlen (ip, count_fsb); + error =xfs_dec_fdblocks (mp, indlen, false); +if (error) + goto out_unlock; + ip->i_delayed_blks += count_fsb; +xfs_mod_delalloc (ip, count_fsb, indlen); + + got.br_startoff = offset_fsb; + got.br_startblock =nullstartblock (indlen); + got.br_blockcount = count_fsb; + got.br_state =XFS_EXT_NORM ; +xfs_bmap_add_extent_hole_delay (ip,XFS_COW_FORK , &icur, &got); + ac->reserved_blocks -= count_fsb; + iomap_flags |=IOMAP_F_NEW ; + +trace_xfs_iomap_alloc (ip, offset,XFS_FSB_TO_B (mp, count_fsb), +XFS_COW_FORK , &got); +done: + error =xfs_bmbt_to_iomap (ip, iomap, &got, flags, iomap_flags, +xfs_iomap_inode_sequence (ip,IOMAP_F_SHARED )); +out_unlock: +xfs_iunlock (ip, lockmode); +return error; +} + static int xfs_buffered_write_iomap_begin( struct inode *inode,@@ -1296,6 +1467,10 @@ xfs_buffered_write_iomap_begin(if (xfs_is_shutdown (mp))return -EIO ; +if (xfs_is_zoned_inode (ip)) +return xfs_zoned_buffered_write_iomap_begin (inode, offset, + count, flags, iomap, srcmap); +/* we can't use delayed allocations when using extent size hints */ if (xfs_get_extsz_hint (ip)) return xfs_direct_write_iomap_begin(inode, offset, count,@@ -1528,10 +1703,13 @@ xfs_buffered_write_delalloc_punch(loff_t length, struct iomap *iomap) { + struct iomap_iter *iter = + container_of(iomap, struct iomap_iter, iomap); +xfs_bmap_punch_delalloc_range (XFS_I (inode), (iomap->flags &IOMAP_F_SHARED ) ?XFS_COW_FORK :XFS_DATA_FORK , - offset, offset + length); + offset, offset + length, iter->private); } static int@@ -1768,6 +1946,7 @@ xfs_zero_range(struct xfs_inode *ip, loff_t pos, loff_t len, + struct xfs_zone_alloc_ctx *ac, bool *did_zero) { struct inode *inode = VFS_I(ip);@@ -1778,13 +1957,14 @@ xfs_zero_range(return dax_zero_range (inode, pos, len, did_zero, &xfs_dax_write_iomap_ops);return iomap_zero_range (inode, pos, len, did_zero, - &xfs_buffered_write_iomap_ops,NULL ); + &xfs_buffered_write_iomap_ops, ac); }int xfs_truncate_page (struct xfs_inode *ip,loff_t pos, +struct xfs_zone_alloc_ctx *ac,bool *did_zero) {struct inode *inode =VFS_I (ip);@@ -1793,5 +1973,5 @@ xfs_truncate_page(return dax_truncate_page (inode, pos, did_zero, &xfs_dax_write_iomap_ops);return iomap_truncate_page (inode, pos, did_zero, - &xfs_buffered_write_iomap_ops,NULL ); + &xfs_buffered_write_iomap_ops, ac); }fs/xfs/xfs_iomap.h +4
-2@@ -10,6 +10,7 @@struct xfs_inode ;struct xfs_bmbt_irec ; +struct xfs_zone_alloc_ctx ; int xfs_iomap_write_direct(struct xfs_inode *ip, xfs_fileoff_t offset_fsb, xfs_fileoff_t count_fsb, unsigned int flags,@@ -24,8 +25,9 @@ int xfs_bmbt_to_iomap(struct xfs_inode *ip, struct iomap *iomap, u16 iomap_flags, u64 sequence_cookie);int xfs_zero_range (struct xfs_inode *ip,loff_t pos,loff_t len, -bool *did_zero); -int xfs_truncate_page (struct xfs_inode *ip,loff_t pos,bool *did_zero); +struct xfs_zone_alloc_ctx *ac,bool *did_zero); +int xfs_truncate_page (struct xfs_inode *ip,loff_t pos, +struct xfs_zone_alloc_ctx *ac,bool *did_zero);static inline xfs_filblks_t xfs_aligned_fsb_count(fs/xfs/xfs_iops.c +29
-2@@ -29,6 +29,7 @@#include "xfs_xattr.h" #include "xfs_file.h" #include "xfs_bmap.h" +#include "xfs_zone_alloc.h" #include <linux/posix_acl.h> #include <linux/security.h> @@ -852,6 +853,7 @@ xfs_setattr_size(uint lock_flags =0 ;uint resblks =0 ;bool did_zeroing = false; +struct xfs_zone_alloc_ctx ac = { };xfs_assert_ilocked (ip,XFS_IOLOCK_EXCL |XFS_MMAPLOCK_EXCL );ASSERT (S_ISREG (inode->i_mode));@@ -887,6 +889,28 @@ xfs_setattr_size(*/ inode_dio_wait (inode); +/* +* Normally xfs_zoned_space_reserve is supposed to be called outside the +* IOLOCK. For truncate we can't do that since ->setattr is called with +* it already held by the VFS. So for now chicken out and try to +* allocate space under it. +* +* To avoid deadlocks this means we can't block waiting for space, which +* can lead to spurious -ENOSPC if there are no directly available +* blocks. We mitigate this a bit by allowing zeroing to dip into the +* reserved pool, but eventually the VFS calling convention needs to +* change. +*/ +if (xfs_is_zoned_inode (ip)) { + error =xfs_zoned_space_reserve (ip,1 , +XFS_ZR_NOWAIT |XFS_ZR_RESERVED , &ac); +if (error) { +if (error == -EAGAIN ) +return -ENOSPC ; +return error; + } + } +/* * File data changes must be complete before we start the transaction to * modify the inode. This needs to be done before joining the inode to @@ -900,11 +924,14 @@ xfs_setattr_size(if (newsize > oldsize) {trace_xfs_zero_eof (ip, oldsize, newsize - oldsize); error =xfs_zero_range (ip, oldsize, newsize - oldsize, - &did_zeroing); + &ac, &did_zeroing); }else { - error =xfs_truncate_page (ip, newsize, &did_zeroing); + error =xfs_truncate_page (ip, newsize, &ac, &did_zeroing); } +if (xfs_is_zoned_inode (ip)) +xfs_zoned_space_unreserve (ip, &ac); +if (error)return error;fs/xfs/xfs_reflink.c +0
-0
fs/xfs/xfs_reflink.c xfs_reflink_zero_posteof( · line 1541
Quoted 5 lines
fs/xfs/xfs_reflink.c +1
-1@@ -1538,7 +1538,7 @@ xfs_reflink_zero_posteof(return 0 ;trace_xfs_zero_eof (ip, isize, pos - isize); -return xfs_zero_range (ip, isize, pos - isize,NULL ); +return xfs_zero_range (ip, isize, pos - isize,NULL ,NULL );
Not really a fan of passing the *ac pointers around everywhere, but atm I can't think of a better option.
--D
Quoted 19 lines
fs/xfs/xfs_reflink.c +0
-0}/* fs/xfs/xfs_trace.h +1
-0@@ -1694,6 +1694,7 @@ DEFINE_SIMPLE_IO_EVENT(xfs_end_io_direct_write);DEFINE_SIMPLE_IO_EVENT (xfs_end_io_direct_write_unwritten);DEFINE_SIMPLE_IO_EVENT (xfs_end_io_direct_write_append);DEFINE_SIMPLE_IO_EVENT (xfs_file_splice_read); +DEFINE_SIMPLE_IO_EVENT (xfs_zoned_map_blocks); DECLARE_EVENT_CLASS(xfs_itrunc_class, TP_PROTO(struct xfs_inode *ip, xfs_fsize_t new_size),Signature · 1 line
2.45.2
Re: [PATCH 27/43] xfs: implement buffered writes to zoned RT devices
Quoted 12 lines · Darrick J. Wong
fs/xfs/xfs_aops.c line 4
Quoted 9 lines
index
d35ac4c19fb2..67392413216b100644fs/xfs/xfs_aops.c +1
-1@@ -1,7 +1,7 @@// SPDX-License-Identifier: GPL-2.0 /* * Copyright (c) 2000-2005 Silicon Graphics, Inc. -* Copyright (c) 2016-2018 Christoph Hellwig. +* Copyright (c) 2016-2023 Christoph Hellwig. 2024, surely?
Quoted 1 line
Or at this point, 2025
Nost of this actually was done (and pushed to a semi-public tree) in 2023. But I guess I touched it enough in 2024 to cover that.
Quoted 11 lines
fs/xfs/xfs_aops.c static const struct iomap_writeback_ops xfs_writeback_ops = { · line 559
Quoted 7 lines
fs/xfs/xfs_aops.c +7
-0+ wpc->iomap.type =IOMAP_MAPPED ; + wpc->iomap.flags =IOMAP_F_DIRTY ; + wpc->iomap.bdev = mp->m_rtdev_targp->bt_bdev; + wpc->iomap.offset = offset; + wpc->iomap.length =XFS_FSB_TO_B (mp, count_fsb); + wpc->iomap.flags =IOMAP_F_ZONE_APPEND ; + wpc->iomap.addr =0 ;/me wonders if this should be set somewhere other than block 0 just in case we screw up? That might just be paranoia since I think iomap puts the bio if it doesn't get to ->submit_bio.
I'll give it a spin.
Quoted 4 lines
Quoted 4 lines
fs/xfs/xfs_aops.c +2
-0+struct xfs_inode *ip =XFS_I (mapping->host);struct xfs_writepage_ctx wpc = { }; +int error;
Quoted 8 lines
fs/xfs/xfs_aops.c static const struct iomap_writeback_ops xfs_writeback_ops = { · line 594
Quoted 4 lines
fs/xfs/xfs_aops.c +3
-1-xfs_iflags_clear (XFS_I (mapping->host),XFS_ITRUNCATED ); +xfs_iflags_clear (ip,XFS_ITRUNCATED ); +if (xfs_is_zoned_inode (ip)) { +struct xfs_zoned_writepage_ctx xc = { };I noticed that the zoned writepage ctx doesn't track data/cow fork sequence numbers. Why is this not necessary? Can we not race with someone else doing writeback?
Unlike "regular" XFS writeback, which tries to convert large extents from preallocations (or just large ranges), zoned writeback works a single folio at time, that there is a new mapping for each folio. And these are only dummy mappings anyway. So all work happens on folios that are locked or have the writeback bit set and are off limits to other writeback threads, new buffered writers or invalidation. I guess I need to document this better.
Quoted 7 lines
Quoted 7 lines
fs/xfs/xfs_aops.c +7
-0+xfs_zoned_buffered_write_iomap_begin ( + struct inode *inode, + loff_t offset, + loff_t count, + unsigned flags, + struct iomap *iomap, + struct iomap *srcmap)
Quoted 8 lines
fs/xfs/xfs_aops.c
Quoted 3 lines
fs/xfs/xfs_aops.c +3
-0+{ +struct iomap_iter *iter = + container_of(iomap, struct iomap_iter, iomap);I still wonder if iomap should be passing a (const struct
iomap_iter*) to the ->iomap_begin function instead of passing all these variables and then implementations have tocontainer_ofif they wantiter->privatetoo.
It should, and I plan to pass the iter when reworking this towards the iter model. Hopefully I can get to that relatively soon after this project lands.
PATCH 28/43 xfs: implement direct writes to zoned RT devices
In reply to Christoph HellwigDirect writes to zoned RT devices are extremely simple. After taking the block reservation before acquiring the iolock, the iomap direct I/O calls into ->iomap_begin which will return a "fake" iomap for the entire requested range. The actual block allocation is then done from the submit_io handler using code shared with the buffered I/O path.
The iomap_dio_ops set the bio_set to the (iomap) ioend one and initialize the embedded ioend, which allows reusing the existing ioend based buffered I/O completion path.
--- fs/xfs/xfs_aops.c | 6 ++-- fs/xfs/xfs_aops.h | 3 +- fs/xfs/xfs_file.c | 80 +++++++++++++++++++++++++++++++++++++++++----- fs/xfs/xfs_iomap.c | 54 +++++++++++++++++++++++++++++++ fs/xfs/xfs_iomap.h | 1 + 5 files changed, 133 insertions(+), 11 deletions(-)
fs/xfs/xfs_aops.c +4 -2
@@ -137,7 +137,9 @@ xfs_end_ioend(else if (ioend->io_flags &IOMAP_IOEND_UNWRITTEN ) error =xfs_iomap_write_unwritten (ip, offset, size, false); -if (!error &&xfs_ioend_is_append (ioend)) +if (!error && + !(ioend->io_flags &IOMAP_IOEND_DIRECT ) && +xfs_ioend_is_append (ioend)) error =xfs_setfilesize (ip, ioend->io_offset, ioend->io_size); done:iomap_finish_ioends (ioend, error);
@@ -182,7 +184,7 @@ xfs_end_io( } } -static void +void xfs_end_bio (struct bio *bio) {
fs/xfs/xfs_aops.h +2 -1
@@ -9,6 +9,7 @@extern const struct address_space_operations xfs_address_space_operations;extern const struct address_space_operations xfs_dax_aops; -int xfs_setfilesize (struct xfs_inode *ip,xfs_off_t offset,size_t size); +int xfs_setfilesize (struct xfs_inode *ip,xfs_off_t offset,size_t size); +void xfs_end_bio (struct bio *bio);#endif /* __XFS_AOPS_H__ */
fs/xfs/xfs_file.c +72 -8
123 lines not on this page · raw message
fs/xfs/xfs_iomap.c +54 -0
60 lines not on this page · raw message
fs/xfs/xfs_iomap.h +1 -0
@@ -51,6 +51,7 @@ xfs_aligned_fsb_count(extern const struct iomap_ops xfs_buffered_write_iomap_ops;extern const struct iomap_ops xfs_direct_write_iomap_ops; +extern const struct iomap_ops xfs_zoned_direct_write_iomap_ops;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;
Signature · 1 line
2.45.2
Re: [PATCH 28/43] xfs: implement direct writes to zoned RT devices
Quoted 11 lines · Christoph Hellwig
Direct writes to zoned RT devices are extremely simple. After taking the block reservation before acquiring the iolock, the iomap direct I/O calls into ->iomap_begin which will return a "fake" iomap for the entire requested range. The actual block allocation is then done from the
submit_iohandler using code shared with the buffered I/O path.The
iomap_dio_opsset thebio_setto the (iomap) ioend one and initialize the embedded ioend, which allows reusing the existing ioend based buffered I/O completion path.Signed-off-by Christoph Hellwig <[email protected]>
Yeah that is a lot simpler. :)
--D
Quoted 259 lines
--- fs/xfs/xfs_aops.c | 6 ++-- fs/xfs/xfs_aops.h | 3 +- fs/xfs/xfs_file.c | 80 +++++++++++++++++++++++++++++++++++++++++----- fs/xfs/xfs_iomap.c | 54 +++++++++++++++++++++++++++++++ fs/xfs/xfs_iomap.h | 1 + 5 files changed, 133 insertions(+), 11 deletions(-)fs/xfs/xfs_aops.c +4
-2@@ -137,7 +137,9 @@ xfs_end_ioend(else if (ioend->io_flags &IOMAP_IOEND_UNWRITTEN ) error =xfs_iomap_write_unwritten (ip, offset, size, false); -if (!error &&xfs_ioend_is_append (ioend)) +if (!error && + !(ioend->io_flags &IOMAP_IOEND_DIRECT ) && +xfs_ioend_is_append (ioend)) error =xfs_setfilesize (ip, ioend->io_offset, ioend->io_size); done:iomap_finish_ioends (ioend, error);@@ -182,7 +184,7 @@ xfs_end_io( } } -static void +void xfs_end_bio (struct bio *bio) {fs/xfs/xfs_aops.h +2
-1@@ -9,6 +9,7 @@extern const struct address_space_operations xfs_address_space_operations;extern const struct address_space_operations xfs_dax_aops; -int xfs_setfilesize (struct xfs_inode *ip,xfs_off_t offset,size_t size); +int xfs_setfilesize (struct xfs_inode *ip,xfs_off_t offset,size_t size); +void xfs_end_bio (struct bio *bio);#endif /* __XFS_AOPS_H__ */ fs/xfs/xfs_file.c +72
-8@@ -25,6 +25,7 @@#include "xfs_iomap.h" #include "xfs_reflink.h" #include "xfs_file.h" +#include "xfs_aops.h" #include "xfs_zone_alloc.h" #include <linux/dax.h> @@ -548,6 +549,9 @@ xfs_dio_write_end_io(loff_t offset = iocb->ki_pos;unsigned int nofs_flag; +ASSERT (!xfs_is_zoned_inode (ip) || + !(flags & (IOMAP_DIO_UNWRITTEN |IOMAP_DIO_COW ))); +trace_xfs_end_io_direct_write (ip, offset, size);if (xfs_is_shutdown (ip->i_mount))@@ -627,14 +631,51 @@ static const struct iomap_dio_ops xfs_dio_write_ops = { .end_io = xfs_dio_write_end_io, }; +static void +xfs_dio_zoned_submit_io ( +const struct iomap_iter *iter, +struct bio *bio, +loff_t file_offset) +{ +struct xfs_mount *mp =XFS_I (iter->inode)->i_mount; +struct xfs_zone_alloc_ctx *ac = iter->private; +xfs_filblks_t count_fsb; +struct iomap_ioend *ioend; + + count_fsb =XFS_B_TO_FSB (mp, bio->bi_iter.bi_size); +if (count_fsb > ac->reserved_blocks) { +xfs_err (mp, +"allocation (%lld) larger than reservation (%lld)." , + count_fsb, ac->reserved_blocks); +xfs_force_shutdown (mp,SHUTDOWN_CORRUPT_INCORE ); +bio_io_error (bio); +return ; + } + ac->reserved_blocks -= count_fsb; + + bio->bi_end_io = xfs_end_bio; + ioend =iomap_init_ioend (iter->inode, bio, file_offset, +IOMAP_IOEND_DIRECT ); +xfs_zone_alloc_and_submit (ioend, &ac->open_zone); +} + +static const struct iomap_dio_ops xfs_dio_zoned_write_ops = { + .bio_set = &iomap_ioend_bioset, + .submit_io = xfs_dio_zoned_submit_io, + .end_io = xfs_dio_write_end_io, +}; +/* -* Handle block aligned direct I/O writes +* Handle block aligned direct I/O writes. */ static noinline ssize_txfs_file_dio_write_aligned (struct xfs_inode *ip,struct kiocb *iocb, -struct iov_iter *from) +struct iov_iter *from, +const struct iomap_ops *ops, +const struct iomap_dio_ops *dops, +struct xfs_zone_alloc_ctx *ac) {unsigned int iolock =XFS_IOLOCK_SHARED ;ssize_t ret;@@ -642,7 +683,7 @@ xfs_file_dio_write_aligned( ret =xfs_ilock_iocb_for_write (iocb, &iolock);if (ret)return ret; - ret =xfs_file_write_checks (iocb, from, &iolock,NULL ); + ret =xfs_file_write_checks (iocb, from, &iolock, ac);if (ret) goto out_unlock;@@ -656,11 +697,31 @@ xfs_file_dio_write_aligned( iolock =XFS_IOLOCK_SHARED ; }trace_xfs_file_direct_write (iocb, from); - ret =iomap_dio_rw (iocb, from, &xfs_direct_write_iomap_ops, - &xfs_dio_write_ops,0 ,NULL ,0 ); + ret =iomap_dio_rw (iocb, from, ops, dops,0 , ac,0 ); out_unlock: -if (iolock) -xfs_iunlock (ip, iolock); +xfs_iunlock (ip, iolock); +return ret; +} + +/* +* Handle block aligned direct I/O writes to zoned devices. +*/ +static noinline ssize_t +xfs_file_dio_write_zoned ( +struct xfs_inode *ip, +struct kiocb *iocb, +struct iov_iter *from) +{ +struct xfs_zone_alloc_ctx ac = { }; +ssize_t ret; + + ret =xfs_zoned_write_space_reserve (ip, iocb, from,0 , &ac); +if (ret <0 ) +return ret; + ret =xfs_file_dio_write_aligned (ip, iocb, from, + &xfs_zoned_direct_write_iomap_ops, + &xfs_dio_zoned_write_ops, &ac); +xfs_zoned_space_unreserve (ip, &ac);return ret; }@@ -777,7 +838,10 @@ xfs_file_dio_write( (xfs_is_always_cow_inode(ip) && (iov_iter_alignment(from) & ip->i_mount->m_blockmask)))return xfs_file_dio_write_unaligned (ip, iocb, from); -return xfs_file_dio_write_aligned (ip, iocb, from); +if (xfs_is_zoned_inode (ip)) +return xfs_file_dio_write_zoned (ip, iocb, from); +return xfs_file_dio_write_aligned (ip, iocb, from, + &xfs_direct_write_iomap_ops, &xfs_dio_write_ops,NULL ); }static noinline ssize_tfs/xfs/xfs_iomap.c +54
-0@@ -965,6 +965,60 @@ const struct iomap_ops xfs_direct_write_iomap_ops = { .iomap_begin = xfs_direct_write_iomap_begin, }; +#ifdef CONFIG_XFS_RT +/* +* This is really simple. The space has already been reserved before taking the +* IOLOCK, the actual block allocation is done just before submitting the bio +* and only recorded in the extent map on I/O completion. +*/ +static int +xfs_zoned_direct_write_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); +int error; + +ASSERT (!(flags &IOMAP_OVERWRITE_ONLY )); + +/* +* Needs to be pushed down into the allocator so that only writes into +* a single zone can be supported. +*/ +if (flags &IOMAP_NOWAIT ) +return -EAGAIN ; + +/* +* Ensure the extent list is in memory in so that we don't have to do +* read it from the I/O completion handler. +*/ +if (xfs_need_iread_extents (&ip->i_df)) { +xfs_ilock (ip,XFS_ILOCK_EXCL ); + error =xfs_iread_extents (NULL , ip,XFS_DATA_FORK ); +xfs_iunlock (ip,XFS_ILOCK_EXCL ); +if (error) +return error; + } + + iomap->type =IOMAP_MAPPED ; + iomap->flags =IOMAP_F_DIRTY ; + iomap->bdev = ip->i_mount->m_rtdev_targp->bt_bdev; + iomap->offset = offset; + iomap->length = length; + iomap->flags =IOMAP_F_ZONE_APPEND ; + iomap->addr =0 ; +return 0 ; +} + +const struct iomap_ops xfs_zoned_direct_write_iomap_ops = { + .iomap_begin = xfs_zoned_direct_write_iomap_begin, +}; +#endif /* CONFIG_XFS_RT */ + static int xfs_dax_write_iomap_end( struct inode *inode,fs/xfs/xfs_iomap.h +1
-0@@ -51,6 +51,7 @@ xfs_aligned_fsb_count(extern const struct iomap_ops xfs_buffered_write_iomap_ops;extern const struct iomap_ops xfs_direct_write_iomap_ops; +extern const struct iomap_ops xfs_zoned_direct_write_iomap_ops;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;Signature · 1 line
2.45.2
PATCH 29/43 xfs: wire up zoned block freeing in xfs_rtextent_free_finish_item
In reply to Christoph HellwigMake xfs_rtextent_free_finish_item call into the zoned allocator to free blocks on zoned RT devices.
--- fs/xfs/xfs_extfree_item.c | 35 +++++++++++++++++++++++++---------- 1 file changed, 25 insertions(+), 10 deletions(-)
fs/xfs/xfs_extfree_item.c +25 -10
@@ -29,6 +29,7 @@#include "xfs_inode.h" #include "xfs_rtbitmap.h" #include "xfs_rtgroup.h" +#include "xfs_zone_alloc.h" struct kmem_cache *xfs_efi_cache;struct kmem_cache *xfs_efd_cache;
@@ -767,21 +768,35 @@ xfs_rtextent_free_finish_item(trace_xfs_extent_free_deferred (mp, xefi); -if (!(xefi->xefi_flags &XFS_EFI_CANCELLED )) { -if (*rtgp !=to_rtg (xefi->xefi_group)) { - *rtgp =to_rtg (xefi->xefi_group); -xfs_rtgroup_lock (*rtgp,XFS_RTGLOCK_BITMAP ); -xfs_rtgroup_trans_join (tp, *rtgp, -XFS_RTGLOCK_BITMAP ); - } - error =xfs_rtfree_blocks (tp, *rtgp, - xefi->xefi_startblock, xefi->xefi_blockcount); +if (xefi->xefi_flags &XFS_EFI_CANCELLED ) + goto done; + +if (*rtgp !=to_rtg (xefi->xefi_group)) { +unsigned int lock_flags; + +if (xfs_has_zoned (mp)) + lock_flags =XFS_RTGLOCK_RMAP ; +else + lock_flags =XFS_RTGLOCK_BITMAP ; + + *rtgp =to_rtg (xefi->xefi_group); +xfs_rtgroup_lock (*rtgp, lock_flags); +xfs_rtgroup_trans_join (tp, *rtgp, lock_flags); } + +if (xfs_has_zoned (mp)) { + error =xfs_zone_free_blocks (tp, *rtgp, xefi->xefi_startblock, + xefi->xefi_blockcount); + }else { + error =xfs_rtfree_blocks (tp, *rtgp, xefi->xefi_startblock, + xefi->xefi_blockcount); + } +if (error == -EAGAIN ) {xfs_efd_from_efi (efdp);return error; } - +done:xfs_efd_add_extent (efdp, xefi);xfs_extent_free_cancel_item (item);return error;
Signature · 1 line
2.45.2
Re: [PATCH 29/43] xfs: wire up zoned block freeing in xfs_rtextent_free_finish_item
Quoted 4 lines · Christoph Hellwig
Make
xfs_rtextent_free_finish_itemcall into the zoned allocator to free blocks on zoned RT devices.Signed-off-by Christoph Hellwig <[email protected]>
Looks good,
--D
Quoted 66 lines
--- fs/xfs/xfs_extfree_item.c | 35 +++++++++++++++++++++++++---------- 1 file changed, 25 insertions(+), 10 deletions(-)fs/xfs/xfs_extfree_item.c +25
-10@@ -29,6 +29,7 @@#include "xfs_inode.h" #include "xfs_rtbitmap.h" #include "xfs_rtgroup.h" +#include "xfs_zone_alloc.h" struct kmem_cache *xfs_efi_cache;struct kmem_cache *xfs_efd_cache;@@ -767,21 +768,35 @@ xfs_rtextent_free_finish_item(trace_xfs_extent_free_deferred (mp, xefi); -if (!(xefi->xefi_flags &XFS_EFI_CANCELLED )) { -if (*rtgp !=to_rtg (xefi->xefi_group)) { - *rtgp =to_rtg (xefi->xefi_group); -xfs_rtgroup_lock (*rtgp,XFS_RTGLOCK_BITMAP ); -xfs_rtgroup_trans_join (tp, *rtgp, -XFS_RTGLOCK_BITMAP ); - } - error =xfs_rtfree_blocks (tp, *rtgp, - xefi->xefi_startblock, xefi->xefi_blockcount); +if (xefi->xefi_flags &XFS_EFI_CANCELLED ) + goto done; + +if (*rtgp !=to_rtg (xefi->xefi_group)) { +unsigned int lock_flags; + +if (xfs_has_zoned (mp)) + lock_flags =XFS_RTGLOCK_RMAP ; +else + lock_flags =XFS_RTGLOCK_BITMAP ; + + *rtgp =to_rtg (xefi->xefi_group); +xfs_rtgroup_lock (*rtgp, lock_flags); +xfs_rtgroup_trans_join (tp, *rtgp, lock_flags); } + +if (xfs_has_zoned (mp)) { + error =xfs_zone_free_blocks (tp, *rtgp, xefi->xefi_startblock, + xefi->xefi_blockcount); + }else { + error =xfs_rtfree_blocks (tp, *rtgp, xefi->xefi_startblock, + xefi->xefi_blockcount); + } +if (error == -EAGAIN ) {xfs_efd_from_efi (efdp);return error; } - +done:xfs_efd_add_extent (efdp, xefi);xfs_extent_free_cancel_item (item);return error;Signature · 1 line
2.45.2
PATCH 30/43 xfs: hide reserved RT blocks from statfs
In reply to Christoph HellwigFile systems with a zoned RT device have a large number of reserved blocks that are required for garbage collection, and which can't be filled with user data. Exclude them from the available blocks reported through stat(v)fs.
--- fs/xfs/xfs_super.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
fs/xfs/xfs_super.c +2 -1
@@ -865,7 +865,8 @@ xfs_statfs_rt(xfs_sum_freecounter (mp,XC_FREE_RTEXTENTS ); st->f_bfree =xfs_rtbxlen_to_blen (mp,max (0LL , freertx)); - st->f_blocks = mp->m_sb.sb_rblocks; + st->f_blocks = mp->m_sb.sb_rblocks - +xfs_rtbxlen_to_blen (mp, mp->m_resblks[XC_FREE_RTEXTENTS ].total); } static void
Signature · 1 line
2.45.2
Re: [PATCH 30/43] xfs: hide reserved RT blocks from statfs
Quoted 15 lines · Christoph Hellwig
File systems with a zoned RT device have a large number of reserved blocks that are required for garbage collection, and which can't be filled with user data. Exclude them from the available blocks reported through stat(v)fs.
Signed-off-by Christoph Hellwig <[email protected]>--- fs/xfs/xfs_super.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)fs/xfs/xfs_super.c +0
-0
fs/xfs/xfs_super.c xfs_statfs_rt( · line 869
Quoted 6 lines
fs/xfs/xfs_super.c +2
-1@@ -865,7 +865,8 @@ xfs_statfs_rt(xfs_sum_freecounter (mp,XC_FREE_RTEXTENTS ); st->f_bfree =xfs_rtbxlen_to_blen (mp,max (0LL , freertx)); - st->f_blocks = mp->m_sb.sb_rblocks; + st->f_blocks = mp->m_sb.sb_rblocks - +xfs_rtbxlen_to_blen (mp, mp->m_resblks[XC_FREE_RTEXTENTS ].total);
I wonder, is mp->m_resblks[XC_FREE_RTEXTENTS].total considered "unavailable"? Should that be added to xfs_freecounter_unavailable?
--D
Quoted 7 lines
fs/xfs/xfs_super.c +0
-0} static voidSignature · 1 line
2.45.2
Re: [PATCH 30/43] xfs: hide reserved RT blocks from statfs
Quoted 6 lines · Darrick J. Wong
fs/xfs/xfs_super.c xfs_statfs_rt( · line 869
Quoted 3 lines
fs/xfs/xfs_super.c +2
-1- st->f_blocks = mp->m_sb.sb_rblocks; + st->f_blocks = mp->m_sb.sb_rblocks - +xfs_rtbxlen_to_blen (mp, mp->m_resblks[XC_FREE_RTEXTENTS ].total);I wonder, is mp->m_resblks[XC_FREE_RTEXTENTS].total considered "unavailable"? Should that be added to
xfs_freecounter_unavailable?
That messed up the set_aside calculation in xfs_dec_freecounter and I think also xfs_reserve_blocks. I tried this early on in the project and it made a complete mess of the free block accounting.
PATCH 31/43 xfs: support growfs on zoned file systems
In reply to Christoph HellwigReplace the inner loop growing one RT bitmap block at a time with one just modifying the superblock counters for growing an entire zone (aka RTG). The big restriction is just like at mkfs time only a RT extent size of a single FSB is allowed, and the file system capacity needs to be aligned to the zone size.
--- fs/xfs/xfs_rtalloc.c | 121 ++++++++++++++++++++++++++++++++++++------- 1 file changed, 101 insertions(+), 20 deletions(-)
fs/xfs/xfs_rtalloc.c +101 -20
@@ -860,6 +860,84 @@ xfs_growfs_rt_init_rtsb(return error; } +static void +xfs_growfs_rt_sb_fields ( +struct xfs_trans *tp, +const struct xfs_mount *nmp) +{ +struct xfs_mount *mp = tp->t_mountp; + +if (nmp->m_sb.sb_rextsize != mp->m_sb.sb_rextsize) +xfs_trans_mod_sb (tp,XFS_TRANS_SB_REXTSIZE , + nmp->m_sb.sb_rextsize - mp->m_sb.sb_rextsize); +if (nmp->m_sb.sb_rbmblocks != mp->m_sb.sb_rbmblocks) +xfs_trans_mod_sb (tp,XFS_TRANS_SB_RBMBLOCKS , + nmp->m_sb.sb_rbmblocks - mp->m_sb.sb_rbmblocks); +if (nmp->m_sb.sb_rblocks != mp->m_sb.sb_rblocks) +xfs_trans_mod_sb (tp,XFS_TRANS_SB_RBLOCKS , + nmp->m_sb.sb_rblocks - mp->m_sb.sb_rblocks); +if (nmp->m_sb.sb_rextents != mp->m_sb.sb_rextents) +xfs_trans_mod_sb (tp,XFS_TRANS_SB_REXTENTS , + nmp->m_sb.sb_rextents - mp->m_sb.sb_rextents); +if (nmp->m_sb.sb_rextslog != mp->m_sb.sb_rextslog) +xfs_trans_mod_sb (tp,XFS_TRANS_SB_REXTSLOG , + nmp->m_sb.sb_rextslog - mp->m_sb.sb_rextslog); +if (nmp->m_sb.sb_rgcount != mp->m_sb.sb_rgcount) +xfs_trans_mod_sb (tp,XFS_TRANS_SB_RGCOUNT , + nmp->m_sb.sb_rgcount - mp->m_sb.sb_rgcount); +} + +static int +xfs_growfs_rt_zoned ( +struct xfs_rtgroup *rtg, +xfs_rfsblock_t nrblocks) +{ +struct xfs_mount *mp =rtg_mount (rtg); +struct xfs_mount *nmp; +struct xfs_trans *tp; +xfs_rtbxlen_t freed_rtx; +int error; + +/* +* Calculate new sb and mount fields for this round. Also ensure the +* rtg_extents value is uptodate as the rtbitmap code relies on it. +*/ + nmp =xfs_growfs_rt_alloc_fake_mount (mp, nrblocks, + mp->m_sb.sb_rextsize); +if (!nmp) +return -ENOMEM ; + freed_rtx = nmp->m_sb.sb_rextents - mp->m_sb.sb_rextents; + +xfs_rtgroup_calc_geometry (nmp, rtg,rtg_rgno (rtg), + nmp->m_sb.sb_rgcount, nmp->m_sb.sb_rextents); + + error =xfs_trans_alloc (mp, &M_RES (nmp)->tr_growrtfree,0 ,0 ,0 , &tp); +if (error) + goto out_free; + +xfs_rtgroup_lock (rtg,XFS_RTGLOCK_RMAP ); +xfs_rtgroup_trans_join (tp, rtg,XFS_RTGLOCK_RMAP ); + +xfs_growfs_rt_sb_fields (tp, nmp); +xfs_trans_mod_sb (tp,XFS_TRANS_SB_FREXTENTS , freed_rtx); + + error =xfs_trans_commit (tp); +if (error) + goto out_free; + +/* +* Ensure the mount RT feature flag is now set, and compute new +* maxlevels for rt btrees. +*/ + mp->m_features |=XFS_FEAT_REALTIME ; +xfs_rtrmapbt_compute_maxlevels (mp); +xfs_rtrefcountbt_compute_maxlevels (mp); +xfs_zoned_add_available (mp, freed_rtx); +out_free: +kfree (nmp); +return error; +} + static int xfs_growfs_rt_bmblock( struct xfs_rtgroup *rtg,
@@ -945,24 +1023,7 @@ xfs_growfs_rt_bmblock(/* * Update superblock fields. */ -if (nmp->m_sb.sb_rextsize != mp->m_sb.sb_rextsize) -xfs_trans_mod_sb (args.tp,XFS_TRANS_SB_REXTSIZE , - nmp->m_sb.sb_rextsize - mp->m_sb.sb_rextsize); -if (nmp->m_sb.sb_rbmblocks != mp->m_sb.sb_rbmblocks) -xfs_trans_mod_sb (args.tp,XFS_TRANS_SB_RBMBLOCKS , - nmp->m_sb.sb_rbmblocks - mp->m_sb.sb_rbmblocks); -if (nmp->m_sb.sb_rblocks != mp->m_sb.sb_rblocks) -xfs_trans_mod_sb (args.tp,XFS_TRANS_SB_RBLOCKS , - nmp->m_sb.sb_rblocks - mp->m_sb.sb_rblocks); -if (nmp->m_sb.sb_rextents != mp->m_sb.sb_rextents) -xfs_trans_mod_sb (args.tp,XFS_TRANS_SB_REXTENTS , - nmp->m_sb.sb_rextents - mp->m_sb.sb_rextents); -if (nmp->m_sb.sb_rextslog != mp->m_sb.sb_rextslog) -xfs_trans_mod_sb (args.tp,XFS_TRANS_SB_REXTSLOG , - nmp->m_sb.sb_rextslog - mp->m_sb.sb_rextslog); -if (nmp->m_sb.sb_rgcount != mp->m_sb.sb_rgcount) -xfs_trans_mod_sb (args.tp,XFS_TRANS_SB_RGCOUNT , - nmp->m_sb.sb_rgcount - mp->m_sb.sb_rgcount); +xfs_growfs_rt_sb_fields (args.tp, nmp);/* * Free the new extent.
@@ -1129,6 +1190,11 @@ xfs_growfs_rtg( goto out_rele; } +if (xfs_has_zoned (mp)) { + error =xfs_growfs_rt_zoned (rtg, nrblocks); + goto out_rele; + } + error =xfs_growfs_rt_alloc_blocks (rtg, nrblocks, rextsize, &bmblocks);if (error) goto out_rele;
@@ -1148,8 +1214,7 @@ xfs_growfs_rtg(if (old_rsum_cache)kvfree (old_rsum_cache); -xfs_rtgroup_rele (rtg); -return 0 ; + goto out_rele; out_error:/*
@@ -1197,6 +1262,22 @@ xfs_growfs_check_rtgeom(if (min_logfsbs > mp->m_sb.sb_logblocks)return -EINVAL ; + +if (xfs_has_zoned (mp)) { +uint32_t gblocks = mp->m_groups[XG_TYPE_RTG ].blocks; +uint32_t rem; + +if (rextsize !=1 ) +return -EINVAL ; +div_u64_rem (mp->m_sb.sb_rblocks, gblocks, &rem); +if (rem) { +xfs_warn (mp, +"new RT volume size (%lld) not aligned to RT group size (%d)" , + mp->m_sb.sb_rblocks, gblocks); +return -EINVAL ; + } + } +return 0 ; }
Signature · 1 line
2.45.2
Re: [PATCH 31/43] xfs: support growfs on zoned file systems
Quoted 7 lines · Christoph Hellwig
Replace the inner loop growing one RT bitmap block at a time with one just modifying the superblock counters for growing an entire zone (aka RTG). The big restriction is just like at mkfs time only a RT extent size of a single FSB is allowed, and the file system capacity needs to be aligned to the zone size.
Signed-off-by Christoph Hellwig <[email protected]>
Got it, that really is nice to do growfs a group at a time.
--D
Quoted 168 lines
--- fs/xfs/xfs_rtalloc.c | 121 ++++++++++++++++++++++++++++++++++++------- 1 file changed, 101 insertions(+), 20 deletions(-)fs/xfs/xfs_rtalloc.c +101
-20@@ -860,6 +860,84 @@ xfs_growfs_rt_init_rtsb(return error; } +static void +xfs_growfs_rt_sb_fields ( +struct xfs_trans *tp, +const struct xfs_mount *nmp) +{ +struct xfs_mount *mp = tp->t_mountp; + +if (nmp->m_sb.sb_rextsize != mp->m_sb.sb_rextsize) +xfs_trans_mod_sb (tp,XFS_TRANS_SB_REXTSIZE , + nmp->m_sb.sb_rextsize - mp->m_sb.sb_rextsize); +if (nmp->m_sb.sb_rbmblocks != mp->m_sb.sb_rbmblocks) +xfs_trans_mod_sb (tp,XFS_TRANS_SB_RBMBLOCKS , + nmp->m_sb.sb_rbmblocks - mp->m_sb.sb_rbmblocks); +if (nmp->m_sb.sb_rblocks != mp->m_sb.sb_rblocks) +xfs_trans_mod_sb (tp,XFS_TRANS_SB_RBLOCKS , + nmp->m_sb.sb_rblocks - mp->m_sb.sb_rblocks); +if (nmp->m_sb.sb_rextents != mp->m_sb.sb_rextents) +xfs_trans_mod_sb (tp,XFS_TRANS_SB_REXTENTS , + nmp->m_sb.sb_rextents - mp->m_sb.sb_rextents); +if (nmp->m_sb.sb_rextslog != mp->m_sb.sb_rextslog) +xfs_trans_mod_sb (tp,XFS_TRANS_SB_REXTSLOG , + nmp->m_sb.sb_rextslog - mp->m_sb.sb_rextslog); +if (nmp->m_sb.sb_rgcount != mp->m_sb.sb_rgcount) +xfs_trans_mod_sb (tp,XFS_TRANS_SB_RGCOUNT , + nmp->m_sb.sb_rgcount - mp->m_sb.sb_rgcount); +} + +static int +xfs_growfs_rt_zoned ( +struct xfs_rtgroup *rtg, +xfs_rfsblock_t nrblocks) +{ +struct xfs_mount *mp =rtg_mount (rtg); +struct xfs_mount *nmp; +struct xfs_trans *tp; +xfs_rtbxlen_t freed_rtx; +int error; + +/* +* Calculate new sb and mount fields for this round. Also ensure the +* rtg_extents value is uptodate as the rtbitmap code relies on it. +*/ + nmp =xfs_growfs_rt_alloc_fake_mount (mp, nrblocks, + mp->m_sb.sb_rextsize); +if (!nmp) +return -ENOMEM ; + freed_rtx = nmp->m_sb.sb_rextents - mp->m_sb.sb_rextents; + +xfs_rtgroup_calc_geometry (nmp, rtg,rtg_rgno (rtg), + nmp->m_sb.sb_rgcount, nmp->m_sb.sb_rextents); + + error =xfs_trans_alloc (mp, &M_RES (nmp)->tr_growrtfree,0 ,0 ,0 , &tp); +if (error) + goto out_free; + +xfs_rtgroup_lock (rtg,XFS_RTGLOCK_RMAP ); +xfs_rtgroup_trans_join (tp, rtg,XFS_RTGLOCK_RMAP ); + +xfs_growfs_rt_sb_fields (tp, nmp); +xfs_trans_mod_sb (tp,XFS_TRANS_SB_FREXTENTS , freed_rtx); + + error =xfs_trans_commit (tp); +if (error) + goto out_free; + +/* +* Ensure the mount RT feature flag is now set, and compute new +* maxlevels for rt btrees. +*/ + mp->m_features |=XFS_FEAT_REALTIME ; +xfs_rtrmapbt_compute_maxlevels (mp); +xfs_rtrefcountbt_compute_maxlevels (mp); +xfs_zoned_add_available (mp, freed_rtx); +out_free: +kfree (nmp); +return error; +} + static int xfs_growfs_rt_bmblock( struct xfs_rtgroup *rtg,@@ -945,24 +1023,7 @@ xfs_growfs_rt_bmblock(/* * Update superblock fields. */ -if (nmp->m_sb.sb_rextsize != mp->m_sb.sb_rextsize) -xfs_trans_mod_sb (args.tp,XFS_TRANS_SB_REXTSIZE , - nmp->m_sb.sb_rextsize - mp->m_sb.sb_rextsize); -if (nmp->m_sb.sb_rbmblocks != mp->m_sb.sb_rbmblocks) -xfs_trans_mod_sb (args.tp,XFS_TRANS_SB_RBMBLOCKS , - nmp->m_sb.sb_rbmblocks - mp->m_sb.sb_rbmblocks); -if (nmp->m_sb.sb_rblocks != mp->m_sb.sb_rblocks) -xfs_trans_mod_sb (args.tp,XFS_TRANS_SB_RBLOCKS , - nmp->m_sb.sb_rblocks - mp->m_sb.sb_rblocks); -if (nmp->m_sb.sb_rextents != mp->m_sb.sb_rextents) -xfs_trans_mod_sb (args.tp,XFS_TRANS_SB_REXTENTS , - nmp->m_sb.sb_rextents - mp->m_sb.sb_rextents); -if (nmp->m_sb.sb_rextslog != mp->m_sb.sb_rextslog) -xfs_trans_mod_sb (args.tp,XFS_TRANS_SB_REXTSLOG , - nmp->m_sb.sb_rextslog - mp->m_sb.sb_rextslog); -if (nmp->m_sb.sb_rgcount != mp->m_sb.sb_rgcount) -xfs_trans_mod_sb (args.tp,XFS_TRANS_SB_RGCOUNT , - nmp->m_sb.sb_rgcount - mp->m_sb.sb_rgcount); +xfs_growfs_rt_sb_fields (args.tp, nmp);/* * Free the new extent. @@ -1129,6 +1190,11 @@ xfs_growfs_rtg( goto out_rele; } +if (xfs_has_zoned (mp)) { + error =xfs_growfs_rt_zoned (rtg, nrblocks); + goto out_rele; + } + error =xfs_growfs_rt_alloc_blocks (rtg, nrblocks, rextsize, &bmblocks);if (error) goto out_rele;@@ -1148,8 +1214,7 @@ xfs_growfs_rtg(if (old_rsum_cache)kvfree (old_rsum_cache); -xfs_rtgroup_rele (rtg); -return 0 ; + goto out_rele; out_error:/* @@ -1197,6 +1262,22 @@ xfs_growfs_check_rtgeom(if (min_logfsbs > mp->m_sb.sb_logblocks)return -EINVAL ; + +if (xfs_has_zoned (mp)) { +uint32_t gblocks = mp->m_groups[XG_TYPE_RTG ].blocks; +uint32_t rem; + +if (rextsize !=1 ) +return -EINVAL ; +div_u64_rem (mp->m_sb.sb_rblocks, gblocks, &rem); +if (rem) { +xfs_warn (mp, +"new RT volume size (%lld) not aligned to RT group size (%d)" , + mp->m_sb.sb_rblocks, gblocks); +return -EINVAL ; + } + } +return 0 ; }Signature · 1 line
2.45.2
PATCH 32/43 xfs: allow COW forks on zoned file systems in xchk_bmap
In reply to Christoph Hellwigzoned file systems can have COW forks even without reflinks.
--- fs/xfs/scrub/bmap.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
fs/xfs/scrub/bmap.c +1 -1
@@ -1039,7 +1039,7 @@ xchk_bmap(switch (whichfork) {case XFS_COW_FORK :/* No CoW forks on non-reflink filesystems. */ -if (!xfs_has_reflink (mp)) { +if (!xfs_has_reflink (mp) && !xfs_has_zoned (mp)) {xchk_ino_set_corrupt (sc, sc->ip->i_ino);return 0 ; }
Signature · 1 line
2.45.2
Re: [PATCH 32/43] xfs: allow COW forks on zoned file systems in xchk_bmap
Quoted 12 lines · Christoph Hellwig
zoned file systems can have COW forks even without reflinks.
Signed-off-by Christoph Hellwig <[email protected]>--- fs/xfs/scrub/bmap.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)fs/xfs/scrub/bmap.c +0
-0
fs/xfs/scrub/bmap.c xchk_bmap( · line 1042
Quoted 5 lines
fs/xfs/scrub/bmap.c +1
-1@@ -1039,7 +1039,7 @@ xchk_bmap(switch (whichfork) {case XFS_COW_FORK :/* No CoW forks on non-reflink filesystems. */ -if (!xfs_has_reflink (mp)) { +if (!xfs_has_reflink (mp) && !xfs_has_zoned (mp)) {
Might want to update the comment
/* No CoW forks filesystem doesn't support out of place writes */
--D
Quoted 7 lines
fs/xfs/scrub/bmap.c +0
-0xchk_ino_set_corrupt (sc, sc->ip->i_ino);return 0 ; }Signature · 1 line
2.45.2
PATCH 33/43 xfs: support xchk_xref_is_used_rt_space on zoned file systems
In reply to Christoph HellwigSpace usage is tracked by the rmap, which already is separately cross-reference. But on top of that we have the write pointer and can do a basic sanity check here that the block is not beyond the write pointer.
--- fs/xfs/scrub/rtbitmap.c | 11 +++++++++-- 1 file changed, 9 insertions(+), 2 deletions(-)
fs/xfs/scrub/rtbitmap.c +9 -2
@@ -21,6 +21,7 @@#include "xfs_rmap.h" #include "xfs_rtrmap_btree.h" #include "xfs_exchmaps.h" +#include "xfs_zone_alloc.h" #include "scrub/scrub.h" #include "scrub/common.h" #include "scrub/repair.h"
@@ -272,7 +273,6 @@ xchk_xref_is_used_rt_space( xfs_extlen_t len) {struct xfs_rtgroup *rtg = sc->sr.rtg; -struct xfs_inode *rbmip =rtg_bitmap (rtg);xfs_rtxnum_t startext;xfs_rtxnum_t endext;bool is_free;
@@ -281,6 +281,13 @@ xchk_xref_is_used_rt_space(if (xchk_skip_xref (sc->sm))return ; +if (xfs_has_zoned (sc->mp)) { +if (!xfs_zone_rgbno_is_valid (rtg, +xfs_rtb_to_rgbno (sc->mp, rtbno) + len -1 )) +xchk_ino_xref_set_corrupt (sc,rtg_rmap (rtg)->i_ino); +return ; + } + startext =xfs_rtb_to_rtx (sc->mp, rtbno); endext =xfs_rtb_to_rtx (sc->mp, rtbno + len -1 ); error = xfs_rtalloc_extent_is_free(rtg, sc->tp, startext,
@@ -288,5 +295,5 @@ xchk_xref_is_used_rt_space(if (!xchk_should_check_xref (sc, &error,NULL ))return ;if (is_free) -xchk_ino_xref_set_corrupt (sc, rbmip->i_ino); +xchk_ino_xref_set_corrupt (sc,rtg_bitmap (rtg)->i_ino); }
Signature · 1 line
2.45.2
Re: [PATCH 33/43] xfs: support xchk_xref_is_used_rt_space on zoned file systems
Quoted 2 lines · Christoph Hellwig
Space usage is tracked by the rmap, which already is separately cross-reference. But on top of that we have the write pointer and can
cross-referenced
Quoted 43 lines
do a basic sanity check here that the block is not beyond the write pointer.
Signed-off-by Christoph Hellwig <[email protected]>--- fs/xfs/scrub/rtbitmap.c | 11 +++++++++-- 1 file changed, 9 insertions(+), 2 deletions(-)fs/xfs/scrub/rtbitmap.c +8
-1@@ -21,6 +21,7 @@#include "xfs_rmap.h" #include "xfs_rtrmap_btree.h" #include "xfs_exchmaps.h" +#include "xfs_zone_alloc.h" #include "scrub/scrub.h" #include "scrub/common.h" #include "scrub/repair.h" @@ -272,7 +273,6 @@ xchk_xref_is_used_rt_space( xfs_extlen_t len) {struct xfs_rtgroup *rtg = sc->sr.rtg; -struct xfs_inode *rbmip =rtg_bitmap (rtg);xfs_rtxnum_t startext;xfs_rtxnum_t endext;bool is_free;@@ -281,6 +281,13 @@ xchk_xref_is_used_rt_space(if (xchk_skip_xref (sc->sm))return ; +if (xfs_has_zoned (sc->mp)) { +if (!xfs_zone_rgbno_is_valid (rtg, +xfs_rtb_to_rgbno (sc->mp, rtbno) + len -1 )) +xchk_ino_xref_set_corrupt (sc,rtg_rmap (rtg)->i_ino); +return ; + } + startext =xfs_rtb_to_rtx (sc->mp, rtbno); endext =xfs_rtb_to_rtx (sc->mp, rtbno + len -1 ); error = xfs_rtalloc_extent_is_free(rtg, sc->tp, startext,
fs/xfs/scrub/rtbitmap.c xchk_xref_is_used_rt_space( · line 298
Quoted 5 lines
fs/xfs/scrub/rtbitmap.c +1
-1@@ -288,5 +295,5 @@ xchk_xref_is_used_rt_space(if (!xchk_should_check_xref (sc, &error,NULL ))return ;if (is_free) -xchk_ino_xref_set_corrupt (sc, rbmip->i_ino); +xchk_ino_xref_set_corrupt (sc,rtg_bitmap (rtg)->i_ino);
rbmip is already the return value from rtg_bitmap()
--D
Quoted 5 lines
fs/xfs/scrub/rtbitmap.c +0
-0}Signature · 1 line
2.45.2
Re: [PATCH 33/43] xfs: support xchk_xref_is_used_rt_space on zoned file systems
Quoted 7 lines · Darrick J. Wong
Quoted 5 lines
fs/xfs/scrub/rtbitmap.c +0
-1@@ -272,7 +273,6 @@ xchk_xref_is_used_rt_space( xfs_extlen_t len) {struct xfs_rtgroup *rtg = sc->sr.rtg; -struct xfs_inode *rbmip =rtg_bitmap (rtg);
Quoted 5 lines
fs/xfs/scrub/rtbitmap.c xchk_xref_is_used_rt_space( · line 298
Quoted 3 lines
fs/xfs/scrub/rtbitmap.c +1
-1if (is_free) -xchk_ino_xref_set_corrupt (sc, rbmip->i_ino); +xchk_ino_xref_set_corrupt (sc,rtg_bitmap (rtg)->i_ino);rbmip is already the return value from
rtg_bitmap()
Yes, but it gets removed above. Because it only has a single user, and it keeps me from incorrectly referencing it in the zone branch, which I did initially and which didn't end up well :)
Darrick J. Wong
Reviewed-byRe: [PATCH 33/43] xfs: support xchk_xref_is_used_rt_space on zoned file systems
Quoted 14 lines · Christoph Hellwig
Quoted 7 lines · Darrick J. Wong
Quoted 5 lines
fs/xfs/scrub/rtbitmap.c +0
-1@@ -272,7 +273,6 @@ xchk_xref_is_used_rt_space( xfs_extlen_t len) {struct xfs_rtgroup *rtg = sc->sr.rtg; -struct xfs_inode *rbmip =rtg_bitmap (rtg);Quoted 5 lines
fs/xfs/scrub/rtbitmap.c xchk_xref_is_used_rt_space( · line 298
Quoted 3 lines
fs/xfs/scrub/rtbitmap.c +1
-1if (is_free) -xchk_ino_xref_set_corrupt (sc, rbmip->i_ino); +xchk_ino_xref_set_corrupt (sc,rtg_bitmap (rtg)->i_ino);rbmip is already the return value from
rtg_bitmap()
Quoted 3 lines
Yes, but it gets removed above. Because it only has a single user, and it keeps me from incorrectly referencing it in the zone branch, which I did initially and which didn't end up well :)
Oh right, my bad. With the typo in the commit message fixed,
--D
PATCH 34/43 xfs: support xrep_require_rtext_inuse on zoned file systems
In reply to Christoph HellwigSpace usage is tracked by the rmap, which already is separately cross-reference. But on top of that we have the write pointer and can do a basic sanity check here that the block is not beyond the write pointer.
--- fs/xfs/scrub/repair.c | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-)
fs/xfs/scrub/repair.c +8 -1
@@ -43,6 +43,7 @@#include "xfs_rtalloc.h" #include "xfs_metafile.h" #include "xfs_rtrefcount_btree.h" +#include "xfs_zone_alloc.h" #include "scrub/scrub.h" #include "scrub/common.h" #include "scrub/trace.h"
@@ -1048,7 +1049,13 @@ xrep_require_rtext_inuse(xfs_rtxnum_t startrtx;xfs_rtxnum_t endrtx;bool is_free = false; -int error; +int error =0 ; + +if (xfs_has_zoned (mp)) { +if (!xfs_zone_rgbno_is_valid (sc->sr.rtg, rgbno + len -1 )) +return -EFSCORRUPTED ; +return 0 ; + } startrtx =xfs_rgbno_to_rtx (mp, rgbno); endrtx =xfs_rgbno_to_rtx (mp, rgbno + len -1 );
Signature · 1 line
2.45.2
Re: [PATCH 34/43] xfs: support xrep_require_rtext_inuse on zoned file systems
Quoted 6 lines · Christoph Hellwig
Space usage is tracked by the rmap, which already is separately cross-reference. But on top of that we have the write pointer and can do a basic sanity check here that the block is not beyond the write pointer.
Signed-off-by Christoph Hellwig <[email protected]>
Looks ok,
--D
Quoted 35 lines
--- fs/xfs/scrub/repair.c | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-)fs/xfs/scrub/repair.c +8
-1@@ -43,6 +43,7 @@#include "xfs_rtalloc.h" #include "xfs_metafile.h" #include "xfs_rtrefcount_btree.h" +#include "xfs_zone_alloc.h" #include "scrub/scrub.h" #include "scrub/common.h" #include "scrub/trace.h" @@ -1048,7 +1049,13 @@ xrep_require_rtext_inuse(xfs_rtxnum_t startrtx;xfs_rtxnum_t endrtx;bool is_free = false; -int error; +int error =0 ; + +if (xfs_has_zoned (mp)) { +if (!xfs_zone_rgbno_is_valid (sc->sr.rtg, rgbno + len -1 )) +return -EFSCORRUPTED ; +return 0 ; + } startrtx =xfs_rgbno_to_rtx (mp, rgbno); endrtx =xfs_rgbno_to_rtx (mp, rgbno + len -1 );Signature · 1 line
2.45.2
PATCH 35/43 xfs: enable fsmap reporting for internal RT devices
In reply to Christoph HellwigFile system with internal RT devices are a bit odd in that we need to report AGs and RGs. To make this happen use separate synthetic fmr_device values for the different sections instead of the dev_t mapping used by other XFS configurations.
The data device is reported as file system metadata before the start of the RGs for the synthetic RT fmr_device.
--- fs/xfs/libxfs/xfs_fs.h | 9 +++++ fs/xfs/xfs_fsmap.c | 80 +++++++++++++++++++++++++++++++++--------- 2 files changed, 72 insertions(+), 17 deletions(-)
fs/xfs/libxfs/xfs_fs.h +9 -0
@@ -1082,6 +1082,15 @@ struct xfs_rtgroup_geometry {#define XFS_IOC_COMMIT_RANGE _IOW ('X', 131, struct xfs_commit_range)/* XFS_IOC_GETFSUUID ---------- deprecated 140 */ +/* +* Devices supported by a single XFS file system. Reported in fsmaps fmr_device +* when using internal RT devices. +*/ +enum xfs_device { +XFS_DEV_DATA =1 , +XFS_DEV_LOG =2 , +XFS_DEV_RT =3 , +};#ifndef HAVE_BBMACROS /*
fs/xfs/xfs_fsmap.c +63 -17
130 lines not on this page · raw message
Signature · 1 line
2.45.2
Re: [PATCH 35/43] xfs: enable fsmap reporting for internal RT devices
Quoted 63 lines · Christoph Hellwig
File system with internal RT devices are a bit odd in that we need to report AGs and RGs. To make this happen use separate synthetic
fmr_devicevalues for the different sections instead of thedev_tmapping used by other XFS configurations.The data device is reported as file system metadata before the start of the RGs for the synthetic RT
fmr_device.Signed-off-by Christoph Hellwig <[email protected]>--- fs/xfs/libxfs/xfs_fs.h | 9 +++++ fs/xfs/xfs_fsmap.c | 80 +++++++++++++++++++++++++++++++++--------- 2 files changed, 72 insertions(+), 17 deletions(-)fs/xfs/libxfs/xfs_fs.h +9
-0@@ -1082,6 +1082,15 @@ struct xfs_rtgroup_geometry {#define XFS_IOC_COMMIT_RANGE _IOW ('X', 131, struct xfs_commit_range)/* XFS_IOC_GETFSUUID ---------- deprecated 140 */ +/* +* Devices supported by a single XFS file system. Reported in fsmaps fmr_device +* when using internal RT devices. +*/ +enum xfs_device { +XFS_DEV_DATA =1 , +XFS_DEV_LOG =2 , +XFS_DEV_RT =3 , +};#ifndef HAVE_BBMACROS /* fs/xfs/xfs_fsmap.c +10
-3@@ -879,17 +879,39 @@ xfs_getfsmap_rtdev_rmapbt(struct xfs_mount *mp = tp->t_mountp;struct xfs_rtgroup *rtg =NULL ;struct xfs_btree_cur *bt_cur =NULL ; +xfs_daddr_t rtstart_daddr;xfs_rtblock_t start_rtb;xfs_rtblock_t end_rtb;xfs_rgnumber_t start_rg, end_rg;uint64_t eofs;int error =0 ; - eofs =XFS_FSB_TO_BB (mp, mp->m_sb.sb_rblocks); + eofs =XFS_FSB_TO_BB (mp, mp->m_sb.sb_rtstart + mp->m_sb.sb_rblocks);if (keys[0 ].fmr_physical >= eofs)return 0 ; - start_rtb =xfs_daddr_to_rtb (mp, keys[0 ].fmr_physical); - end_rtb =xfs_daddr_to_rtb (mp,min (eofs -1 , keys[1 ].fmr_physical)); + + rtstart_daddr =XFS_FSB_TO_BB (mp, mp->m_sb.sb_rtstart); +if (keys[0 ].fmr_physical < rtstart_daddr) { +struct xfs_fsmap_irec frec = { + .owner =XFS_RMAP_OWN_FS , + .len_daddr = rtstart_daddr, + }; +
fs/xfs/xfs_fsmap.c xfs_getfsmap_rtdev_rmapbt( · line 909
Quoted 10 lines
fs/xfs/xfs_fsmap.c +10
-0+/* Adjust the low key if we are continuing from where we left off. */ +if (keys[0 ].fmr_length >0 ) { + info->low_daddr = keys[0 ].fmr_physical + keys[0 ].fmr_length; +return 0 ; + } + +/* Fabricate an rmap entry for space occupied by the data dev */ + error =xfs_getfsmap_helper (tp, info, &frec); +if (error) +return error;
Seeing as you report different fmr_device values for the data and rt devices, I'd have though that you'd want the rt fsmappings to start at fmr_physical == 0. But then I guess for the sb_rtstart > 0 case, the rtblock values that get written into the bmbt have that rtstart value added in, don't they?
--D
Quoted 105 lines
fs/xfs/xfs_fsmap.c +43
-14+ } + + start_rtb =xfs_daddr_to_rtb (mp, rtstart_daddr + keys[0 ].fmr_physical); + end_rtb =xfs_daddr_to_rtb (mp, rtstart_daddr + +min (eofs -1 , keys[1 ].fmr_physical)); info->missing_owner =XFS_FMR_OWN_FREE ;@@ -1004,22 +1026,40 @@ xfs_getfsmap_rtdev_rmapbt( }#endif /* CONFIG_XFS_RT */ +static uint32_t +xfs_getfsmap_device ( +struct xfs_mount *mp, +enum xfs_device dev) +{ +if (mp->m_sb.sb_rtstart) +return dev; + +switch (dev) { +case XFS_DEV_DATA : +return new_encode_dev (mp->m_ddev_targp->bt_dev); +case XFS_DEV_LOG : +return new_encode_dev (mp->m_logdev_targp->bt_dev); +case XFS_DEV_RT : +if (!mp->m_rtdev_targp) +break ; +return new_encode_dev (mp->m_rtdev_targp->bt_dev); + } + +return -1 ; +} +/* Do we recognize the device? */ STATIC boolxfs_getfsmap_is_valid_device (struct xfs_mount *mp,struct xfs_fsmap *fm) { -if (fm->fmr_device ==0 || fm->fmr_device ==UINT_MAX || - fm->fmr_device ==new_encode_dev (mp->m_ddev_targp->bt_dev)) -return true; -if (mp->m_logdev_targp && - fm->fmr_device ==new_encode_dev (mp->m_logdev_targp->bt_dev)) -return true; -if (mp->m_rtdev_targp && - fm->fmr_device ==new_encode_dev (mp->m_rtdev_targp->bt_dev)) -return true; -return false; +return fm->fmr_device ==0 || + fm->fmr_device ==UINT_MAX || + fm->fmr_device ==xfs_getfsmap_device (mp,XFS_DEV_DATA ) || + fm->fmr_device ==xfs_getfsmap_device (mp,XFS_DEV_LOG ) || + (mp->m_rtdev_targp && + fm->fmr_device ==xfs_getfsmap_device (mp,XFS_DEV_RT )); }/* Ensure that the low key is less than the high key. */ @@ -1126,7 +1166,7 @@ xfs_getfsmap(/* Set up our device handlers. */ memset (handlers,0 ,sizeof (handlers)); handlers[0 ].nr_sectors =XFS_FSB_TO_BB (mp, mp->m_sb.sb_dblocks); - handlers[0 ].dev =new_encode_dev (mp->m_ddev_targp->bt_dev); + handlers[0 ].dev =xfs_getfsmap_device (mp,XFS_DEV_DATA );if (use_rmap) handlers[0 ].fn = xfs_getfsmap_datadev_rmapbt;else @@ -1134,7 +1174,7 @@ xfs_getfsmap(if (mp->m_logdev_targp != mp->m_ddev_targp) { handlers[1 ].nr_sectors =XFS_FSB_TO_BB (mp, mp->m_sb.sb_logblocks); - handlers[1 ].dev =new_encode_dev (mp->m_logdev_targp->bt_dev); + handlers[1 ].dev =xfs_getfsmap_device (mp,XFS_DEV_LOG ); handlers[1 ].fn = xfs_getfsmap_logdev; }#ifdef CONFIG_XFS_RT @@ -1144,7 +1184,7 @@ xfs_getfsmap(*/ if (mp->m_rtdev_targp && (use_rmap || !xfs_has_zoned (mp))) { handlers[2 ].nr_sectors =XFS_FSB_TO_BB (mp, mp->m_sb.sb_rblocks); - handlers[2 ].dev =new_encode_dev (mp->m_rtdev_targp->bt_dev); + handlers[2 ].dev =xfs_getfsmap_device (mp,XFS_DEV_RT );if (use_rmap) handlers[2 ].fn = xfs_getfsmap_rtdev_rmapbt;else @@ -1234,7 +1274,13 @@ xfs_getfsmap(if (tp)xfs_trans_cancel (tp); - head->fmh_oflags =FMH_OF_DEV_T ; + +/* +* For internal RT device we need to report different synthetic devices +* for a single physical device, and thus can't report the actual dev_t. +*/ +if (!mp->m_sb.sb_rtstart) + head->fmh_oflags =FMH_OF_DEV_T ;return error; }Signature · 1 line
2.45.2
Re: [PATCH 35/43] xfs: enable fsmap reporting for internal RT devices
Quoted 10 lines · Darrick J. Wong
fs/xfs/xfs_fsmap.c xfs_getfsmap_rtdev_rmapbt( · line 909
Quoted 4 lines
fs/xfs/xfs_fsmap.c +4
-0+/* Fabricate an rmap entry for space occupied by the data dev */ + error =xfs_getfsmap_helper (tp, info, &frec); +if (error) +return error;Seeing as you report different
fmr_devicevalues for the data and rt devices, I'd have though that you'd want the rt fsmappings to start atfmr_physical== 0. But then I guess for thesb_rtstart> 0 case, the rtblock values that get written into the bmbt have that rtstart value added in, don't they?
The bmbt values are all relative to rtstart, the daddr translation is what adds the offset. So if we want to take the offset out of the fsmap reporting, I'll need new helpers to not add it or manually subtract it afterwards. If that's preferred it should be doable, even if the fsmap code keeps confusing me more each time I look at it.
Re: [PATCH 35/43] xfs: enable fsmap reporting for internal RT devices
Quoted 12 lines · Christoph Hellwig
Quoted 10 lines · Darrick J. Wong
fs/xfs/xfs_fsmap.c xfs_getfsmap_rtdev_rmapbt( · line 909
Quoted 4 lines
fs/xfs/xfs_fsmap.c +4
-0+/* Fabricate an rmap entry for space occupied by the data dev */ + error =xfs_getfsmap_helper (tp, info, &frec); +if (error) +return error;Seeing as you report different
fmr_devicevalues for the data and rt devices, I'd have though that you'd want the rt fsmappings to start atfmr_physical== 0. But then I guess for thesb_rtstart> 0 case, the rtblock values that get written into the bmbt have that rtstart value added in, don't they?
Quoted 5 lines
The bmbt values are all relative to rtstart, the daddr translation is what adds the offset. So if we want to take the offset out of the fsmap reporting, I'll need new helpers to not add it or manually subtract it afterwards. If that's preferred it should be doable, even if the fsmap code keeps confusing me more each time I look at it.
I think it's ok if you can leave it as it is. Once you move to "virtual" fmr_device numbers (aka not a dev_t) then it's up to you to define how the fmr_physical address space works. It's no longer a reference to a block device that you can open/pread/etc.
--D
PATCH 36/43 xfs: disable reflink for zoned file systems
In reply to Christoph HellwigWhile the zoned on-disk format supports reflinks, the GC code currently always unshares reflinks when moving blocks to new zones, thus making the feature unusuable. Disable reflinks until the GC code is refcount aware.
--- fs/xfs/xfs_super.c | 7 +++++++ 1 file changed, 7 insertions(+)
fs/xfs/xfs_super.c +7 -0
@@ -1818,6 +1818,13 @@ xfs_fs_fill_super( goto out_filestream_unmount; } +if (xfs_has_zoned (mp)) { +xfs_alert (mp, +"reflink not compatible with zoned RT device!" ); + error = -EINVAL ; + goto out_filestream_unmount; + } +/* * always-cow mode is not supported on filesystems with rt * extent sizes larger than a single block because we'd have
Signature · 1 line
2.45.2
Re: [PATCH 36/43] xfs: disable reflink for zoned file systems
Quoted 3 lines · Christoph Hellwig
While the zoned on-disk format supports reflinks, the GC code currently always unshares reflinks when moving blocks to new zones, thus making the feature unusuable. Disable reflinks until the GC code is refcount aware.
This goes back to the question I had in the gc patch -- can we let userspace do its own reflink-aware freespace copygc, and only use the in-kernel gc if userspace doesn't respond fast enough? I imagine someone will want to share used blocks on zoned storage at some point.
--D
Quoted 27 lines
Signed-off-by Christoph Hellwig <[email protected]>--- fs/xfs/xfs_super.c | 7 +++++++ 1 file changed, 7 insertions(+)fs/xfs/xfs_super.c +7
-0@@ -1818,6 +1818,13 @@ xfs_fs_fill_super( goto out_filestream_unmount; } +if (xfs_has_zoned (mp)) { +xfs_alert (mp, +"reflink not compatible with zoned RT device!" ); + error = -EINVAL ; + goto out_filestream_unmount; + } +/* * always-cow mode is not supported on filesystems with rt * extent sizes larger than a single block because we'd have Signature · 1 line
2.45.2
Re: [PATCH 36/43] xfs: disable reflink for zoned file systems
Quoted 9 lines · Darrick J. Wong
Quoted 3 lines · Christoph Hellwig
While the zoned on-disk format supports reflinks, the GC code currently always unshares reflinks when moving blocks to new zones, thus making the feature unusuable. Disable reflinks until the GC code is refcount aware.
This goes back to the question I had in the gc patch -- can we let userspace do its own reflink-aware freespace copygc, and only use the in-kernel gc if userspace doesn't respond fast enough? I imagine someone will want to share used blocks on zoned storage at some point.
I'm pretty sure we could, if we're willing to deal with worse decision making, worse performance and potential for deadlocks while dealing with a bigger and more complicated code base. But why?
Re: [PATCH 36/43] xfs: disable reflink for zoned file systems
Quoted 6 lines · Christoph Hellwig
Quoted 5 lines · Darrick J. Wong
Quoted 3 lines · Christoph Hellwig
While the zoned on-disk format supports reflinks, the GC code currently always unshares reflinks when moving blocks to new zones, thus making the feature unusuable. Disable reflinks until the GC code is refcount aware.
Quoted 8 lines
Quoted 4 lines
This goes back to the question I had in the gc patch -- can we let userspace do its own reflink-aware freespace copygc, and only use the in-kernel gc if userspace doesn't respond fast enough? I imagine someone will want to share used blocks on zoned storage at some point.
I'm pretty sure we could, if we're willing to deal with worse decision making, worse performance and potential for deadlocks while dealing with a bigger and more complicated code base. But why?
Mostly intellectual curiosity on my part about self-reorganizing filesystems. The zonegc you've already written is good enough for now, though the no-reflink requirement feels a bit onerous.
But hey, it's not like I have numbers showing that a userspace copy-dedupe gc strategy is any better, so I'll not hold up this whole series on account of that.
--D
Re: [PATCH 36/43] xfs: disable reflink for zoned file systems
Quoted 3 lines · Darrick J. Wong
Mostly intellectual curiosity on my part about self-reorganizing filesystems. The zonegc you've already written is good enough for now, though the no-reflink requirement feels a bit onerous.
The no-reflink is mostly because we want a minimum viable merge candidate, and our initial uses for things like lsm databases and objects stores don't strongly need it. I hope to add reflink support ~ 2 or 3 merge windows after the initial code.
Re: [PATCH 36/43] xfs: disable reflink for zoned file systems
Quoted 9 lines · Christoph Hellwig
Quoted 3 lines · Darrick J. Wong
Mostly intellectual curiosity on my part about self-reorganizing filesystems. The zonegc you've already written is good enough for now, though the no-reflink requirement feels a bit onerous.
The no-reflink is mostly because we want a minimum viable merge candidate, and our initial uses for things like lsm databases and objects stores don't strongly need it. I hope to add reflink support ~ 2 or 3 merge windows after the initial code.
<nod>
--D
PATCH 37/43 xfs: disable rt quotas for zoned file systems
In reply to Christoph HellwigThey'll need a little more work.
--- fs/xfs/xfs_qm.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
fs/xfs/xfs_qm.c +2 -1
@@ -1711,7 +1711,8 @@ xfs_qm_mount_quotas(* immediately. We only support rtquota if rtgroups are enabled to * avoid problems with older kernels. */ -if (mp->m_sb.sb_rextents && !xfs_has_rtgroups (mp)) { +if (mp->m_sb.sb_rextents && + (!xfs_has_rtgroups (mp) ||xfs_has_zoned (mp))) {xfs_notice (mp,"Cannot turn on quotas for realtime filesystem" ); mp->m_qflags =0 ; goto write_changes;
Signature · 1 line
2.45.2
Re: [PATCH 37/43] xfs: disable rt quotas for zoned file systems
Quoted 1 line · Christoph Hellwig
They'll need a little more work.
I guess we'll have to get back to this... :/
--D
Quoted 23 lines
Signed-off-by Christoph Hellwig <[email protected]>--- fs/xfs/xfs_qm.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)fs/xfs/xfs_qm.c +2
-1@@ -1711,7 +1711,8 @@ xfs_qm_mount_quotas(* immediately. We only support rtquota if rtgroups are enabled to * avoid problems with older kernels. */ -if (mp->m_sb.sb_rextents && !xfs_has_rtgroups (mp)) { +if (mp->m_sb.sb_rextents && + (!xfs_has_rtgroups (mp) ||xfs_has_zoned (mp))) {xfs_notice (mp,"Cannot turn on quotas for realtime filesystem" ); mp->m_qflags =0 ; goto write_changes;Signature · 1 line
2.45.2
Re: [PATCH 37/43] xfs: disable rt quotas for zoned file systems
Quoted 4 lines · Darrick J. Wong
Quoted 1 line · Christoph Hellwig
They'll need a little more work.
I guess we'll have to get back to this... :/
Yes. I've always been wanting to implement it, but not with the very highest priority. The fact that you pulled up the RT quota series to earlier in your patch stack threw a little monkey wrench here :)
PATCH 38/43 xfs: enable the zoned RT device feature
In reply to Christoph HellwigEnable the zoned RT device directory feature. With this feature, RT groups are written sequentially and always emptied before rewriting the blocks. This perfectly maps to zoned devices, but can also be used on conventional block devices.
--- fs/xfs/libxfs/xfs_format.h | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
fs/xfs/libxfs/xfs_format.h +2 -1
@@ -408,7 +408,8 @@ xfs_sb_has_ro_compat_feature( XFS_SB_FEAT_INCOMPAT_NREXT64 | \ XFS_SB_FEAT_INCOMPAT_EXCHRANGE | \ XFS_SB_FEAT_INCOMPAT_PARENT | \ - XFS_SB_FEAT_INCOMPAT_METADIR) + XFS_SB_FEAT_INCOMPAT_METADIR | \ + XFS_SB_FEAT_INCOMPAT_ZONED)#define XFS_SB_FEAT_INCOMPAT_UNKNOWN ~XFS_SB_FEAT_INCOMPAT_ALL static inline bool
Signature · 1 line
2.45.2
Re: [PATCH 38/43] xfs: enable the zoned RT device feature
Quoted 6 lines · Christoph Hellwig
Enable the zoned RT device directory feature. With this feature, RT groups are written sequentially and always emptied before rewriting the blocks. This perfectly maps to zoned devices, but can also be used on conventional block devices.
Signed-off-by Christoph Hellwig <[email protected]>
Looks ok, though it's a bit odd that this isn't the very end of the series.
--D
Quoted 22 lines
--- fs/xfs/libxfs/xfs_format.h | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)fs/xfs/libxfs/xfs_format.h +2
-1@@ -408,7 +408,8 @@ xfs_sb_has_ro_compat_feature( XFS_SB_FEAT_INCOMPAT_NREXT64 | \ XFS_SB_FEAT_INCOMPAT_EXCHRANGE | \ XFS_SB_FEAT_INCOMPAT_PARENT | \ - XFS_SB_FEAT_INCOMPAT_METADIR) + XFS_SB_FEAT_INCOMPAT_METADIR | \ + XFS_SB_FEAT_INCOMPAT_ZONED)#define XFS_SB_FEAT_INCOMPAT_UNKNOWN ~XFS_SB_FEAT_INCOMPAT_ALL static inline boolSignature · 1 line
2.45.2
Re: [PATCH 38/43] xfs: enable the zoned RT device feature
Quoted 10 lines · Darrick J. Wong
Quoted 6 lines · Christoph Hellwig
Enable the zoned RT device directory feature. With this feature, RT groups are written sequentially and always emptied before rewriting the blocks. This perfectly maps to zoned devices, but can also be used on conventional block devices.
Signed-off-by Christoph Hellwig <[email protected]>Looks ok, though it's a bit odd that this isn't the very end of the series.
The rest of the series adds another on-disk feature build on top of this (the zone gaps) and new in-memory only features (debug output in /proc/self/mountstats and hint based data placement). So I tried to keep the bracket of adding the first bits for a new feature and enabling it as small as possible (it's already pretty large anyway).
PATCH 39/43 xfs: support zone gaps
In reply to Christoph HellwigZoned devices can have gaps beyond the usable capacity of a zone and the end in the LBA/daddr address space. In other words, the hardware equivalent to the RT groups already takes care of the power of 2 alignment for us. In this case the sparse FSB/RTB address space maps 1:1 to the device address space.
--- fs/xfs/libxfs/xfs_format.h | 4 +++- fs/xfs/libxfs/xfs_group.h | 6 +++++- fs/xfs/libxfs/xfs_rtgroup.h | 13 ++++++++----- fs/xfs/libxfs/xfs_sb.c | 3 +++ fs/xfs/libxfs/xfs_zones.c | 19 +++++++++++++++++-- fs/xfs/xfs_mount.h | 9 +++++++++ 6 files changed, 45 insertions(+), 9 deletions(-)
fs/xfs/libxfs/xfs_format.h +3 -1
@@ -398,6 +398,7 @@ xfs_sb_has_ro_compat_feature(#define XFS_SB_FEAT_INCOMPAT_PARENT (1 << 7)/* parent pointers */ #define XFS_SB_FEAT_INCOMPAT_METADIR (1 << 8)/* metadata dir tree */ #define XFS_SB_FEAT_INCOMPAT_ZONED (1U << 31)/* zoned RT allocator */ +#define XFS_SB_FEAT_INCOMPAT_ZONE_GAPS (1U << 30)/* RTGs have LBA gaps */ #define XFS_SB_FEAT_INCOMPAT_ALL \ (XFS_SB_FEAT_INCOMPAT_FTYPE | \
@@ -409,7 +410,8 @@ xfs_sb_has_ro_compat_feature( XFS_SB_FEAT_INCOMPAT_EXCHRANGE | \ XFS_SB_FEAT_INCOMPAT_PARENT | \ XFS_SB_FEAT_INCOMPAT_METADIR | \ - XFS_SB_FEAT_INCOMPAT_ZONED) + XFS_SB_FEAT_INCOMPAT_ZONED | \ + XFS_SB_FEAT_INCOMPAT_ZONE_GAPS)#define XFS_SB_FEAT_INCOMPAT_UNKNOWN ~XFS_SB_FEAT_INCOMPAT_ALL static inline bool
fs/xfs/libxfs/xfs_group.h +5 -1
@@ -117,7 +117,11 @@ xfs_gbno_to_daddr(struct xfs_groups *g = &mp->m_groups[xg->xg_type];xfs_fsblock_t fsbno; - fsbno = (xfs_fsblock_t )xg->xg_gno * g->blocks + gbno; +if (g->has_daddr_gaps) + fsbno =xfs_gbno_to_fsb (xg, gbno); +else + fsbno = (xfs_fsblock_t )xg->xg_gno * g->blocks + gbno; +return XFS_FSB_TO_BB (mp, g->start_fsb + fsbno); }
fs/xfs/libxfs/xfs_rtgroup.h +8 -5
@@ -245,11 +245,14 @@ xfs_rtb_to_daddr( xfs_rtblock_t rtbno) {struct xfs_groups *g = &mp->m_groups[XG_TYPE_RTG ]; -xfs_rgnumber_t rgno =xfs_rtb_to_rgno (mp, rtbno); -uint64_t start_bno = (xfs_rtblock_t )rgno * g->blocks; -return XFS_FSB_TO_BB (mp, - g->start_fsb + start_bno + (rtbno & g->blkmask)); +if (xfs_has_rtgroups (mp) && !g->has_daddr_gaps) { +xfs_rgnumber_t rgno =xfs_rtb_to_rgno (mp, rtbno); + + rtbno = (xfs_rtblock_t )rgno * g->blocks + (rtbno & g->blkmask); + } + +return XFS_FSB_TO_BB (mp, g->start_fsb + rtbno); } static inline xfs_rtblock_t
@@ -261,7 +264,7 @@ xfs_daddr_to_rtb(xfs_rfsblock_t bno; bno =XFS_BB_TO_FSBT (mp, daddr) - g->start_fsb; -if (xfs_has_rtgroups (mp)) { +if (xfs_has_rtgroups (mp) && !g->has_daddr_gaps) {xfs_rgnumber_t rgno;uint32_t rgbno;
fs/xfs/libxfs/xfs_sb.c +3 -0
@@ -1176,6 +1176,9 @@ xfs_sb_mount_rextsize( rgs->blklog = mp->m_sb.sb_rgblklog; rgs->blkmask =xfs_mask32lo (mp->m_sb.sb_rgblklog); rgs->start_fsb = mp->m_sb.sb_rtstart; +if (xfs_sb_has_incompat_feature (sbp, +XFS_SB_FEAT_INCOMPAT_ZONE_GAPS )) + rgs->has_daddr_gaps = true; }else { rgs->blocks =0 ; rgs->blklog =0 ;
fs/xfs/libxfs/xfs_zones.c +17 -2
@@ -135,6 +135,7 @@ xfs_zone_validate( {struct xfs_mount *mp =rtg_mount (rtg);struct xfs_groups *g = &mp->m_groups[XG_TYPE_RTG ]; +uint32_t expected_size;/* * Check that the zone capacity matches the rtgroup size stored in the
@@ -149,11 +150,25 @@ xfs_zone_validate(return -EIO ; } -if (XFS_BB_TO_FSB (mp, zone->len) !=1 << g->blklog) { +if (g->has_daddr_gaps) { + expected_size =1 << g->blklog; + }else { +if (zone->len != zone->capacity) { +xfs_warn (mp, +"zone %u has capacity != size ((0x%llx vs 0x%llx)" , +rtg_rgno (rtg), +XFS_BB_TO_FSB (mp, zone->len), +XFS_BB_TO_FSB (mp, zone->capacity)); +return -EIO ; + } + expected_size = g->blocks; + } + +if (XFS_BB_TO_FSB (mp, zone->len) != expected_size) {xfs_warn (mp,"zone %u length (0x%llx) does match geometry (0x%x)." ,rtg_rgno (rtg),XFS_BB_TO_FSB (mp, zone->len), -1 << g->blklog); + expected_size); }switch (zone->type) {
fs/xfs/xfs_mount.h +9 -0
@@ -97,6 +97,15 @@ struct xfs_groups {*/ uint8_t blklog; +/* +* Zoned devices can have gaps beyond the usable capacity of a zone and +* the end in the LBA/daddr address space. In other words, the hardware +* equivalent to the RT groups already takes care of the power of 2 +* alignment for us. In this case the sparse FSB/RTB address space maps +* 1:1 to the device address space. +*/ +bool has_daddr_gaps; +/* * Mask to extract the group-relative block number from a FSB. * For a pre-rtgroups filesystem we pretend to have one very large
Signature · 1 line
2.45.2
Re: [PATCH 39/43] xfs: support zone gaps
Quoted 5 lines · Christoph Hellwig
Zoned devices can have gaps beyond the usable capacity of a zone and the end in the LBA/daddr address space. In other words, the hardware equivalent to the RT groups already takes care of the power of 2 alignment for us. In this case the sparse FSB/RTB address space maps 1:1 to the device address space.
Heh, sparse lba ranges.
Quoted 15 lines
Signed-off-by Christoph Hellwig <[email protected]>--- fs/xfs/libxfs/xfs_format.h | 4 +++- fs/xfs/libxfs/xfs_group.h | 6 +++++- fs/xfs/libxfs/xfs_rtgroup.h | 13 ++++++++----- fs/xfs/libxfs/xfs_sb.c | 3 +++ fs/xfs/libxfs/xfs_zones.c | 19 +++++++++++++++++-- fs/xfs/xfs_mount.h | 9 +++++++++ 6 files changed, 45 insertions(+), 9 deletions(-)fs/xfs/libxfs/xfs_format.h +0
-0
fs/xfs/libxfs/xfs_format.h xfs_sb_has_ro_compat_feature( · line 401
Quoted 4 lines
fs/xfs/libxfs/xfs_format.h +1
-0@@ -398,6 +398,7 @@ xfs_sb_has_ro_compat_feature(#define XFS_SB_FEAT_INCOMPAT_PARENT (1 << 7)/* parent pointers */ #define XFS_SB_FEAT_INCOMPAT_METADIR (1 << 8)/* metadata dir tree */ #define XFS_SB_FEAT_INCOMPAT_ZONED (1U << 31)/* zoned RT allocator */ +#define XFS_SB_FEAT_INCOMPAT_ZONE_GAPS (1U << 30)/* RTGs have LBA gaps */
These will have to be renumbered before merging.
Otherwise looks ok,
--D
Quoted 139 lines
fs/xfs/libxfs/xfs_format.h +2
-1#define XFS_SB_FEAT_INCOMPAT_ALL \ (XFS_SB_FEAT_INCOMPAT_FTYPE | \@@ -409,7 +410,8 @@ xfs_sb_has_ro_compat_feature( XFS_SB_FEAT_INCOMPAT_EXCHRANGE | \ XFS_SB_FEAT_INCOMPAT_PARENT | \ XFS_SB_FEAT_INCOMPAT_METADIR | \ - XFS_SB_FEAT_INCOMPAT_ZONED) + XFS_SB_FEAT_INCOMPAT_ZONED | \ + XFS_SB_FEAT_INCOMPAT_ZONE_GAPS)#define XFS_SB_FEAT_INCOMPAT_UNKNOWN ~XFS_SB_FEAT_INCOMPAT_ALL static inline boolfs/xfs/libxfs/xfs_group.h +5
-1@@ -117,7 +117,11 @@ xfs_gbno_to_daddr(struct xfs_groups *g = &mp->m_groups[xg->xg_type];xfs_fsblock_t fsbno; - fsbno = (xfs_fsblock_t )xg->xg_gno * g->blocks + gbno; +if (g->has_daddr_gaps) + fsbno =xfs_gbno_to_fsb (xg, gbno); +else + fsbno = (xfs_fsblock_t )xg->xg_gno * g->blocks + gbno; +return XFS_FSB_TO_BB (mp, g->start_fsb + fsbno); }fs/xfs/libxfs/xfs_rtgroup.h +8
-5@@ -245,11 +245,14 @@ xfs_rtb_to_daddr( xfs_rtblock_t rtbno) {struct xfs_groups *g = &mp->m_groups[XG_TYPE_RTG ]; -xfs_rgnumber_t rgno =xfs_rtb_to_rgno (mp, rtbno); -uint64_t start_bno = (xfs_rtblock_t )rgno * g->blocks; -return XFS_FSB_TO_BB (mp, - g->start_fsb + start_bno + (rtbno & g->blkmask)); +if (xfs_has_rtgroups (mp) && !g->has_daddr_gaps) { +xfs_rgnumber_t rgno =xfs_rtb_to_rgno (mp, rtbno); + + rtbno = (xfs_rtblock_t )rgno * g->blocks + (rtbno & g->blkmask); + } + +return XFS_FSB_TO_BB (mp, g->start_fsb + rtbno); } static inline xfs_rtblock_t@@ -261,7 +264,7 @@ xfs_daddr_to_rtb(xfs_rfsblock_t bno; bno =XFS_BB_TO_FSBT (mp, daddr) - g->start_fsb; -if (xfs_has_rtgroups (mp)) { +if (xfs_has_rtgroups (mp) && !g->has_daddr_gaps) {xfs_rgnumber_t rgno;uint32_t rgbno;fs/xfs/libxfs/xfs_sb.c +3
-0@@ -1176,6 +1176,9 @@ xfs_sb_mount_rextsize( rgs->blklog = mp->m_sb.sb_rgblklog; rgs->blkmask =xfs_mask32lo (mp->m_sb.sb_rgblklog); rgs->start_fsb = mp->m_sb.sb_rtstart; +if (xfs_sb_has_incompat_feature (sbp, +XFS_SB_FEAT_INCOMPAT_ZONE_GAPS )) + rgs->has_daddr_gaps = true; }else { rgs->blocks =0 ; rgs->blklog =0 ;fs/xfs/libxfs/xfs_zones.c +17
-2@@ -135,6 +135,7 @@ xfs_zone_validate( {struct xfs_mount *mp =rtg_mount (rtg);struct xfs_groups *g = &mp->m_groups[XG_TYPE_RTG ]; +uint32_t expected_size;/* * Check that the zone capacity matches the rtgroup size stored in the @@ -149,11 +150,25 @@ xfs_zone_validate(return -EIO ; } -if (XFS_BB_TO_FSB (mp, zone->len) !=1 << g->blklog) { +if (g->has_daddr_gaps) { + expected_size =1 << g->blklog; + }else { +if (zone->len != zone->capacity) { +xfs_warn (mp, +"zone %u has capacity != size ((0x%llx vs 0x%llx)" , +rtg_rgno (rtg), +XFS_BB_TO_FSB (mp, zone->len), +XFS_BB_TO_FSB (mp, zone->capacity)); +return -EIO ; + } + expected_size = g->blocks; + } + +if (XFS_BB_TO_FSB (mp, zone->len) != expected_size) {xfs_warn (mp,"zone %u length (0x%llx) does match geometry (0x%x)." ,rtg_rgno (rtg),XFS_BB_TO_FSB (mp, zone->len), -1 << g->blklog); + expected_size); }switch (zone->type) {fs/xfs/xfs_mount.h +9
-0@@ -97,6 +97,15 @@ struct xfs_groups {*/ uint8_t blklog; +/* +* Zoned devices can have gaps beyond the usable capacity of a zone and +* the end in the LBA/daddr address space. In other words, the hardware +* equivalent to the RT groups already takes care of the power of 2 +* alignment for us. In this case the sparse FSB/RTB address space maps +* 1:1 to the device address space. +*/ +bool has_daddr_gaps; +/* * Mask to extract the group-relative block number from a FSB. * For a pre-rtgroups filesystem we pretend to have one very large Signature · 1 line
2.45.2
PATCH 40/43 xfs: add a max_open_zones mount option
In reply to Christoph HellwigAllow limiting the number of open zones used below that exported by the device. This is required to tune the number of write streams when zoned RT devices are used on conventional devices, and can be useful on zoned devices that support a very large number of open zones.
--- fs/xfs/xfs_super.c | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-)
fs/xfs/xfs_super.c +8 -1
@@ -110,7 +110,7 @@ enum { Opt_filestreams, Opt_quota, Opt_noquota, Opt_usrquota, Opt_grpquota, Opt_prjquota, Opt_uquota, Opt_gquota, Opt_pquota, Opt_uqnoenforce, Opt_gqnoenforce, Opt_pqnoenforce, Opt_qnoenforce, - Opt_discard, Opt_nodiscard, Opt_dax, Opt_dax_enum, + Opt_discard, Opt_nodiscard, Opt_dax, Opt_dax_enum, Opt_max_open_zones, }; static const struct fs_parameter_spec xfs_fs_parameters[] = {
@@ -155,6 +155,7 @@ static const struct fs_parameter_spec xfs_fs_parameters[] = {fsparam_flag ("nodiscard" , Opt_nodiscard),fsparam_flag ("dax" , Opt_dax),fsparam_enum ("dax" , Opt_dax_enum, dax_param_enums), + fsparam_u32("max_open_zones", Opt_max_open_zones), {} };
@@ -234,6 +235,9 @@ xfs_fs_show_options(if (!(mp->m_qflags &XFS_ALL_QUOTA_ACCT ))seq_puts (m,",noquota" ); +if (mp->m_max_open_zones) +seq_printf (m,",max_open_zones=%u" , mp->m_max_open_zones); +return 0 ; }
@@ -1456,6 +1460,9 @@ xfs_fs_parse_param(xfs_fs_warn_deprecated (fc, param,XFS_FEAT_NOATTR2 , true); parsing_mp->m_features |=XFS_FEAT_NOATTR2 ;return 0 ; +case Opt_max_open_zones: + parsing_mp->m_max_open_zones = result.uint_32; +return 0 ;default :xfs_warn (parsing_mp,"unknown mount option [%s]." , param->key);return -EINVAL ;
Signature · 1 line
2.45.2
Re: [PATCH 40/43] xfs: add a max_open_zones mount option
Quoted 4 lines · Christoph Hellwig
Allow limiting the number of open zones used below that exported by the device. This is required to tune the number of write streams when zoned RT devices are used on conventional devices, and can be useful on zoned devices that support a very large number of open zones.
Can this be changed during a remount operation? Do we have to revalidate the value?
--D
Quoted 50 lines
Signed-off-by Christoph Hellwig <[email protected]>--- fs/xfs/xfs_super.c | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-)fs/xfs/xfs_super.c +8
-1@@ -110,7 +110,7 @@ enum { Opt_filestreams, Opt_quota, Opt_noquota, Opt_usrquota, Opt_grpquota, Opt_prjquota, Opt_uquota, Opt_gquota, Opt_pquota, Opt_uqnoenforce, Opt_gqnoenforce, Opt_pqnoenforce, Opt_qnoenforce, - Opt_discard, Opt_nodiscard, Opt_dax, Opt_dax_enum, + Opt_discard, Opt_nodiscard, Opt_dax, Opt_dax_enum, Opt_max_open_zones, }; static const struct fs_parameter_spec xfs_fs_parameters[] = {@@ -155,6 +155,7 @@ static const struct fs_parameter_spec xfs_fs_parameters[] = {fsparam_flag ("nodiscard" , Opt_nodiscard),fsparam_flag ("dax" , Opt_dax),fsparam_enum ("dax" , Opt_dax_enum, dax_param_enums), + fsparam_u32("max_open_zones", Opt_max_open_zones), {} };@@ -234,6 +235,9 @@ xfs_fs_show_options(if (!(mp->m_qflags &XFS_ALL_QUOTA_ACCT ))seq_puts (m,",noquota" ); +if (mp->m_max_open_zones) +seq_printf (m,",max_open_zones=%u" , mp->m_max_open_zones); +return 0 ; }@@ -1456,6 +1460,9 @@ xfs_fs_parse_param(xfs_fs_warn_deprecated (fc, param,XFS_FEAT_NOATTR2 , true); parsing_mp->m_features |=XFS_FEAT_NOATTR2 ;return 0 ; +case Opt_max_open_zones: + parsing_mp->m_max_open_zones = result.uint_32; +return 0 ;default :xfs_warn (parsing_mp,"unknown mount option [%s]." , param->key);return -EINVAL ;Signature · 1 line
2.45.2
Re: [PATCH 40/43] xfs: add a max_open_zones mount option
Quoted 8 lines · Darrick J. Wong
Quoted 4 lines · Christoph Hellwig
Allow limiting the number of open zones used below that exported by the device. This is required to tune the number of write streams when zoned RT devices are used on conventional devices, and can be useful on zoned devices that support a very large number of open zones.
Can this be changed during a remount operation? Do we have to revalidate the value?
Right no it can't be changed during remount as there is no code added for it in xfs_fs_reconfigure. If a strong use case to change it shows up we could support it, but it's going to require some nasty code especially for reducing the limit, so I'd rather not do it unless I have to.
Re: [PATCH 40/43] xfs: add a max_open_zones mount option
Quoted 7 lines · Christoph Hellwig
Quoted 6 lines · Darrick J. Wong
Quoted 4 lines · Christoph Hellwig
Allow limiting the number of open zones used below that exported by the device. This is required to tune the number of write streams when zoned RT devices are used on conventional devices, and can be useful on zoned devices that support a very large number of open zones.
Quoted 7 lines
Quoted 2 lines
Can this be changed during a remount operation? Do we have to revalidate the value?
Right no it can't be changed during remount as there is no code added for it in
xfs_fs_reconfigure. If a strong use case to change it shows up we could support it, but it's going to require some nasty code especially for reducing the limit, so I'd rather not do it unless I have to.
Nah let's wait until someone actually gives us a use case.
--D
PATCH 41/43 xfs: support write life time based data placement
In reply to Christoph HellwigFrom: Hans Holmberg <[email protected]>
Add a file write life time data placement allocation scheme that aims to minimize fragmentation and thereby to do two things:
a) separate file data to different zones when possible.
b) colocate file data of similar life times when feasible.
To get best results, average file sizes should align with the zone capacity that is reported through the XFS_IOC_FSGEOMETRY ioctl.
For RocksDB using leveled compaction, the lifetime hints can improve throughput for overwrite workloads at 80% file system utilization by ~10%.
Lifetime hints can be disabled using the nolifetime mount option.
--- fs/xfs/xfs_mount.h | 2 + fs/xfs/xfs_super.c | 10 ++++ fs/xfs/xfs_zone_alloc.c | 126 +++++++++++++++++++++++++++++++++++----- fs/xfs/xfs_zone_gc.c | 2 +- fs/xfs/xfs_zone_priv.h | 9 ++- 5 files changed, 134 insertions(+), 15 deletions(-)
fs/xfs/xfs_mount.h +2 -0
@@ -365,6 +365,7 @@ typedef struct xfs_mount {#define XFS_FEAT_ZONED (1ULL << 29)/* zoned RT device */ /* Mount features */ +#define XFS_FEAT_NOLIFETIME (1ULL << 47)/* disable lifetime hints */ #define XFS_FEAT_NOATTR2 (1ULL << 48)/* disable attr2 creation */ #define XFS_FEAT_NOALIGN (1ULL << 49)/* ignore alignment */ #define XFS_FEAT_ALLOCSIZE (1ULL << 50)/* user specified allocation size */
@@ -420,6 +421,7 @@ __XFS_HAS_FEAT(large_extent_counts, NREXT64) __XFS_HAS_FEAT(exchange_range, EXCHANGE_RANGE) __XFS_HAS_FEAT(metadir, METADIR) __XFS_HAS_FEAT(zoned, ZONED) +__XFS_HAS_FEAT(nolifetime, NOLIFETIME)static inline bool xfs_has_rtgroups (const struct xfs_mount *mp) {
fs/xfs/xfs_super.c +10 -0
@@ -111,6 +111,7 @@ enum { Opt_prjquota, Opt_uquota, Opt_gquota, Opt_pquota, Opt_uqnoenforce, Opt_gqnoenforce, Opt_pqnoenforce, Opt_qnoenforce, Opt_discard, Opt_nodiscard, Opt_dax, Opt_dax_enum, Opt_max_open_zones, + Opt_lifetime, Opt_nolifetime, }; static const struct fs_parameter_spec xfs_fs_parameters[] = {
@@ -156,6 +157,8 @@ static const struct fs_parameter_spec xfs_fs_parameters[] = {fsparam_flag ("dax" , Opt_dax),fsparam_enum ("dax" , Opt_dax_enum, dax_param_enums),fsparam_u32 ("max_open_zones" , Opt_max_open_zones), +fsparam_flag ("lifetime" , Opt_lifetime), + fsparam_flag("nolifetime", Opt_nolifetime), {} };
@@ -184,6 +187,7 @@ xfs_fs_show_options( { XFS_FEAT_LARGE_IOSIZE, ",largeio" }, { XFS_FEAT_DAX_ALWAYS, ",dax=always" }, { XFS_FEAT_DAX_NEVER, ",dax=never" }, + { XFS_FEAT_NOLIFETIME, ",nolifetime" }, { 0, NULL } };struct xfs_mount *mp =XFS_M (root->d_sb);
@@ -1463,6 +1467,12 @@ xfs_fs_parse_param(case Opt_max_open_zones: parsing_mp->m_max_open_zones = result.uint_32;return 0 ; +case Opt_lifetime: + parsing_mp->m_features &= ~XFS_FEAT_NOLIFETIME ; +return 0 ; +case Opt_nolifetime: + parsing_mp->m_features |=XFS_FEAT_NOLIFETIME ; +return 0 ;default :xfs_warn (parsing_mp,"unknown mount option [%s]." , param->key);return -EINVAL ;
fs/xfs/xfs_zone_alloc.c +113 -13
225 lines not on this page · raw message
fs/xfs/xfs_zone_gc.c +1 -1
@@ -489,7 +489,7 @@ xfs_select_gc_zone(if (!xfs_group_marked (mp,XG_TYPE_RTG ,XFS_RTG_FREE )) oz =xfs_steal_open_zone_for_gc (zi);else - oz =xfs_open_zone (mp, true); + oz =xfs_open_zone (mp,WRITE_LIFE_NOT_SET , true);spin_unlock (&zi->zi_zone_list_lock);if (oz)
fs/xfs/xfs_zone_priv.h +8 -1
@@ -26,6 +26,12 @@ struct xfs_open_zone {xfs_rgblock_t oz_write_pointer;xfs_rgblock_t oz_written; +/* +* Write hint (data temperature) assigned to this zone, or +* WRITE_LIFE_NOT_SET if none was set. +*/ +enum rw_hint oz_write_hint; +/* * Is this open zone used for garbage collection? There can only be a * single open GC zone, which is pointed to by zi_open_gc_zone in
@@ -80,7 +86,8 @@ struct xfs_zone_info {struct xfs_group *zi_reset_list; }; -struct xfs_open_zone *xfs_open_zone (struct xfs_mount *mp,bool is_gc); +struct xfs_open_zone *xfs_open_zone (struct xfs_mount *mp, +enum rw_hint write_hint,bool is_gc);int xfs_zone_reset_sync (struct xfs_rtgroup *rtg);bool xfs_zoned_need_gc (struct xfs_mount *mp);
Signature · 1 line
2.45.2
Re: [PATCH 41/43] xfs: support write life time based data placement
Quoted 334 lines · Christoph Hellwig
From: Hans Holmberg <[email protected]>
Add a file write life time data placement allocation scheme that aims to minimize fragmentation and thereby to do two things:
a) separate file data to different zones when possible.
b) colocate file data of similar life times when feasible.To get best results, average file sizes should align with the zone capacity that is reported through the
XFS_IOC_FSGEOMETRYioctl.For RocksDB using leveled compaction, the lifetime hints can improve throughput for overwrite workloads at 80% file system utilization by ~10%.
Lifetime hints can be disabled using the nolifetime mount option.
Signed-off-by Hans Holmberg <[email protected]>Signed-off-by Christoph Hellwig <[email protected]>--- fs/xfs/xfs_mount.h | 2 + fs/xfs/xfs_super.c | 10 ++++ fs/xfs/xfs_zone_alloc.c | 126 +++++++++++++++++++++++++++++++++++----- fs/xfs/xfs_zone_gc.c | 2 +- fs/xfs/xfs_zone_priv.h | 9 ++- 5 files changed, 134 insertions(+), 15 deletions(-)fs/xfs/xfs_mount.h +2
-0@@ -365,6 +365,7 @@ typedef struct xfs_mount {#define XFS_FEAT_ZONED (1ULL << 29)/* zoned RT device */ /* Mount features */ +#define XFS_FEAT_NOLIFETIME (1ULL << 47)/* disable lifetime hints */ #define XFS_FEAT_NOATTR2 (1ULL << 48)/* disable attr2 creation */ #define XFS_FEAT_NOALIGN (1ULL << 49)/* ignore alignment */ #define XFS_FEAT_ALLOCSIZE (1ULL << 50)/* user specified allocation size */ @@ -420,6 +421,7 @@ __XFS_HAS_FEAT(large_extent_counts, NREXT64) __XFS_HAS_FEAT(exchange_range, EXCHANGE_RANGE) __XFS_HAS_FEAT(metadir, METADIR) __XFS_HAS_FEAT(zoned, ZONED) +__XFS_HAS_FEAT(nolifetime, NOLIFETIME)static inline bool xfs_has_rtgroups (const struct xfs_mount *mp) {fs/xfs/xfs_super.c +10
-0@@ -111,6 +111,7 @@ enum { Opt_prjquota, Opt_uquota, Opt_gquota, Opt_pquota, Opt_uqnoenforce, Opt_gqnoenforce, Opt_pqnoenforce, Opt_qnoenforce, Opt_discard, Opt_nodiscard, Opt_dax, Opt_dax_enum, Opt_max_open_zones, + Opt_lifetime, Opt_nolifetime, }; static const struct fs_parameter_spec xfs_fs_parameters[] = {@@ -156,6 +157,8 @@ static const struct fs_parameter_spec xfs_fs_parameters[] = {fsparam_flag ("dax" , Opt_dax),fsparam_enum ("dax" , Opt_dax_enum, dax_param_enums),fsparam_u32 ("max_open_zones" , Opt_max_open_zones), +fsparam_flag ("lifetime" , Opt_lifetime), + fsparam_flag("nolifetime", Opt_nolifetime), {} };@@ -184,6 +187,7 @@ xfs_fs_show_options( { XFS_FEAT_LARGE_IOSIZE, ",largeio" }, { XFS_FEAT_DAX_ALWAYS, ",dax=always" }, { XFS_FEAT_DAX_NEVER, ",dax=never" }, + { XFS_FEAT_NOLIFETIME, ",nolifetime" }, { 0, NULL } };struct xfs_mount *mp =XFS_M (root->d_sb);@@ -1463,6 +1467,12 @@ xfs_fs_parse_param(case Opt_max_open_zones: parsing_mp->m_max_open_zones = result.uint_32;return 0 ; +case Opt_lifetime: + parsing_mp->m_features &= ~XFS_FEAT_NOLIFETIME ; +return 0 ; +case Opt_nolifetime: + parsing_mp->m_features |=XFS_FEAT_NOLIFETIME ; +return 0 ;default :xfs_warn (parsing_mp,"unknown mount option [%s]." , param->key);return -EINVAL ;fs/xfs/xfs_zone_alloc.c +113
-13@@ -381,6 +381,7 @@ static struct xfs_open_zone *xfs_init_open_zone ( struct xfs_rtgroup *rtg, xfs_rgblock_t write_pointer, + enum rw_hint write_hint, bool is_gc) { struct xfs_open_zone *oz;@@ -391,6 +392,7 @@ xfs_init_open_zone( oz->oz_rtg = rtg; oz->oz_write_pointer = write_pointer; oz->oz_written = write_pointer; + oz->oz_write_hint = write_hint; oz->oz_is_gc = is_gc;/* @@ -407,6 +409,7 @@ xfs_init_open_zone(struct xfs_open_zone *xfs_open_zone (struct xfs_mount *mp, +enum rw_hint write_hint,bool is_gc) {struct xfs_zone_info *zi = mp->m_zone_info;@@ -422,7 +425,7 @@ xfs_open_zone(xfs_group_clear_mark (xg,XFS_RTG_FREE );atomic_dec (&zi->zi_nr_free_zones); zi->zi_free_zone_cursor = xg->xg_gno; -return xfs_init_open_zone (to_rtg (xg),0 , is_gc); +return xfs_init_open_zone (to_rtg (xg),0 , write_hint, is_gc); }/* @@ -434,7 +437,8 @@ xfs_open_zone(*/ static struct xfs_open_zone *xfs_activate_zone ( -struct xfs_mount *mp) +struct xfs_mount *mp, +enum rw_hint write_hint) {struct xfs_zone_info *zi = mp->m_zone_info;struct xfs_open_zone *oz;@@ -443,7 +447,7 @@ xfs_activate_zone( XFS_GC_ZONES - XFS_OPEN_GC_ZONES)return NULL ; - oz =xfs_open_zone (mp, false); + oz =xfs_open_zone (mp, write_hint, false);if (!oz)return NULL ;@@ -460,16 +464,78 @@ xfs_activate_zone(return oz; } +/* +* For data with short or medium lifetime, try to colocated it into an +* already open zone with a matching temperature. +*/ +static bool +xfs_colocate_eagerly ( +enum rw_hint file_hint) +{ +switch (file_hint) { +case WRITE_LIFE_MEDIUM : +case WRITE_LIFE_SHORT : +case WRITE_LIFE_NONE : +return true; +default : +return false; + } +} + +static bool +xfs_good_hint_match ( +struct xfs_open_zone *oz, +enum rw_hint file_hint) +{ +switch (oz->oz_write_hint) { +case WRITE_LIFE_LONG : +case WRITE_LIFE_EXTREME : +/* colocate long and extreme */ +if (file_hint ==WRITE_LIFE_LONG || + file_hint ==WRITE_LIFE_EXTREME ) +return true; +break ; +case WRITE_LIFE_MEDIUM : +/* colocate medium with medium */ +if (file_hint ==WRITE_LIFE_MEDIUM ) +return true; +break ; +case WRITE_LIFE_SHORT : +case WRITE_LIFE_NONE : +case WRITE_LIFE_NOT_SET : +/* colocate short and none */ +if (file_hint <=WRITE_LIFE_SHORT ) +return true; +break ; + } +return false; +} +static bool xfs_try_use_zone (struct xfs_zone_info *zi, -struct xfs_open_zone *oz) +enum rw_hint file_hint, +struct xfs_open_zone *oz, +bool lowspace) {if (oz->oz_write_pointer ==rtg_blocks (oz->oz_rtg))return false; +if (!lowspace && !xfs_good_hint_match (oz, file_hint)) +return false;if (!atomic_inc_not_zero (&oz->oz_ref))return false; +/* +* If we have a hint set for the data, use that for the zone even if +* some data was written already without any hint set, but don't change +* the temperature after that as that would make little sense without +* tracking per-temperature class written block counts, which is +* probably overkill anyway. +*/ +if (file_hint !=WRITE_LIFE_NOT_SET && + oz->oz_write_hint ==WRITE_LIFE_NOT_SET ) + oz->oz_write_hint = file_hint; +/* * If we couldn't match by inode or life time we just pick the first * zone with enough space above. For that we want the least busy zone @@ -484,28 +550,38 @@ xfs_try_use_zone(static struct xfs_open_zone *xfs_select_open_zone_lru ( -struct xfs_zone_info *zi) +struct xfs_zone_info *zi, +enum rw_hint file_hint, +bool lowspace) {struct xfs_open_zone *oz;list_for_each_entry (oz, &zi->zi_open_zones, oz_entry) -if (xfs_try_use_zone (zi, oz)) +if (xfs_try_use_zone (zi, file_hint, oz, lowspace))return oz;return NULL ; }static struct xfs_open_zone *xfs_select_open_zone_mru ( -struct xfs_zone_info *zi) +struct xfs_zone_info *zi, +enum rw_hint file_hint) {struct xfs_open_zone *oz;list_for_each_entry_reverse (oz, &zi->zi_open_zones, oz_entry) -if (xfs_try_use_zone (zi, oz)) +if (xfs_try_use_zone (zi, file_hint, oz, false))return oz;return NULL ; } +static inline enum rw_hint xfs_inode_write_hint (struct xfs_inode *ip) +{ +if (xfs_has_nolifetime (ip->i_mount)) +return WRITE_LIFE_NOT_SET ; +return VFS_I (ip)->i_write_hint; +} +/* * Try to pack inodes that are written back after they were closed tight instead * of trying to open new zones for them or spread them to the least recently @@ -535,10 +611,19 @@ xfs_select_zone_nowait( {struct xfs_mount *mp = ip->i_mount;struct xfs_zone_info *zi = mp->m_zone_info; +enum rw_hint write_hint =xfs_inode_write_hint (ip);struct xfs_open_zone *oz =NULL ; -if (xfs_zoned_pack_tight (ip)) - oz =xfs_select_open_zone_mru (zi); +/* +* Try to fill up open zones with matching temperature if available. It +* is better to try to co-locate data when this is favorable, so we can +* activate empty zones when it is statistically better to separate +* data. +*/ +if (xfs_colocate_eagerly (write_hint)) + oz =xfs_select_open_zone_lru (zi, write_hint, false); +else if (xfs_zoned_pack_tight (ip)) + oz =xfs_select_open_zone_mru (zi, write_hint);if (oz)return oz;@@ -546,12 +631,26 @@ xfs_select_zone_nowait(* If we are below the open limit try to activate a zone. */ if (zi->zi_nr_open_zones < mp->m_max_open_zones -XFS_OPEN_GC_ZONES ) { - oz =xfs_activate_zone (mp); + oz =xfs_activate_zone (mp, write_hint);if (oz)return oz; } -return xfs_select_open_zone_lru (zi); +/* +* Try to colocate cold data with other cold data if we failed to open a +* new zone for it. +*/ +if (write_hint !=WRITE_LIFE_NOT_SET && + !xfs_colocate_eagerly (write_hint)) { + oz =xfs_select_open_zone_lru (zi, write_hint, false); +if (oz) +return oz; + } + + oz =xfs_select_open_zone_lru (zi,WRITE_LIFE_NOT_SET , false); +if (oz) +return oz; +return xfs_select_open_zone_lru (zi,WRITE_LIFE_NOT_SET , true); } static struct xfs_open_zone *@@ -801,7 +900,8 @@ xfs_init_zone(struct xfs_open_zone *oz;atomic_inc (&rtg_group (rtg)->xg_active_ref); - oz =xfs_init_open_zone (rtg, write_pointer, false); + oz =xfs_init_open_zone (rtg, write_pointer,WRITE_LIFE_NOT_SET , + false);list_add_tail (&oz->oz_entry, &zi->zi_open_zones); zi->zi_nr_open_zones++;fs/xfs/xfs_zone_gc.c +0
-0
fs/xfs/xfs_zone_gc.c xfs_select_gc_zone( · line 492
Quoted 5 lines
fs/xfs/xfs_zone_gc.c +1
-1@@ -489,7 +489,7 @@ xfs_select_gc_zone(if (!xfs_group_marked (mp,XG_TYPE_RTG ,XFS_RTG_FREE )) oz =xfs_steal_open_zone_for_gc (zi);else - oz =xfs_open_zone (mp, true); + oz =xfs_open_zone (mp,WRITE_LIFE_NOT_SET , true);
I wonder, is it possible to remember (at least incore) what write hint was associated with an open zone all the way to gc time so that zones with compatible hints can be gc'd into a new zone with the same hint? Or is that overkill?
--D
Quoted 34 lines
fs/xfs/xfs_zone_gc.c +0
-0spin_unlock (&zi->zi_zone_list_lock);if (oz)fs/xfs/xfs_zone_priv.h +8
-1@@ -26,6 +26,12 @@ struct xfs_open_zone {xfs_rgblock_t oz_write_pointer;xfs_rgblock_t oz_written; +/* +* Write hint (data temperature) assigned to this zone, or +* WRITE_LIFE_NOT_SET if none was set. +*/ +enum rw_hint oz_write_hint; +/* * Is this open zone used for garbage collection? There can only be a * single open GC zone, which is pointed to by zi_open_gc_zone in @@ -80,7 +86,8 @@ struct xfs_zone_info {struct xfs_group *zi_reset_list; }; -struct xfs_open_zone *xfs_open_zone (struct xfs_mount *mp,bool is_gc); +struct xfs_open_zone *xfs_open_zone (struct xfs_mount *mp, +enum rw_hint write_hint,bool is_gc);int xfs_zone_reset_sync (struct xfs_rtgroup *rtg);bool xfs_zoned_need_gc (struct xfs_mount *mp);Signature · 1 line
2.45.2
Re: [PATCH 41/43] xfs: support write life time based data placement
Quoted 10 lines · Darrick J. Wong
fs/xfs/xfs_zone_gc.c xfs_select_gc_zone( · line 492
Quoted 5 lines
fs/xfs/xfs_zone_gc.c +1
-1if (!xfs_group_marked (mp,XG_TYPE_RTG ,XFS_RTG_FREE )) oz =xfs_steal_open_zone_for_gc (zi);else - oz =xfs_open_zone (mp, true); + oz =xfs_open_zone (mp,WRITE_LIFE_NOT_SET , true);I wonder, is it possible to remember (at least incore) what write hint was associated with an open zone all the way to gc time so that zones with compatible hints can be gc'd into a new zone with the same hint? Or is that overkill?
We've been thinking about that a lot. Right now we don't have an immediate use case for it, but it sure would be nice to have it without
needing another incompat bit. But then we'd need to find some space
(3 bits to be exact) in the on-disk inode for it that doesn't make otherwise useful space unavaіlable for more widely useful things. If you have a good idea I'll look into implementing it.
Re: [PATCH 41/43] xfs: support write life time based data placement
Quoted 12 lines · Christoph Hellwig
Quoted 10 lines · Darrick J. Wong
fs/xfs/xfs_zone_gc.c xfs_select_gc_zone( · line 492
Quoted 5 lines
fs/xfs/xfs_zone_gc.c +1
-1if (!xfs_group_marked (mp,XG_TYPE_RTG ,XFS_RTG_FREE )) oz =xfs_steal_open_zone_for_gc (zi);else - oz =xfs_open_zone (mp, true); + oz =xfs_open_zone (mp,WRITE_LIFE_NOT_SET , true);I wonder, is it possible to remember (at least incore) what write hint was associated with an open zone all the way to gc time so that zones with compatible hints can be gc'd into a new zone with the same hint? Or is that overkill?
Quoted 6 lines
We've been thinking about that a lot. Right now we don't have an immediate use case for it, but it sure would be nice to have it without
needing another incompat bit. But then we'd need to find some space
(3 bits to be exact) in the on-disk inode for it that doesn't make otherwise useful space unavaіlable for more widely useful things. If you have a good idea I'll look into implementing it.
How about reusing the dmapi fields in xfs_dinode, seeing as we forced them to zero in the base metadir series? Or do you have another use in mind for those 6 bytes?
--D
Re: [PATCH 41/43] xfs: support write life time based data placement
Quoted 10 lines · Darrick J. Wong
Quoted 6 lines
We've been thinking about that a lot. Right now we don't have an immediate use case for it, but it sure would be nice to have it without
needing another incompat bit. But then we'd need to find some space
(3 bits to be exact) in the on-disk inode for it that doesn't make otherwise useful space unavaіlable for more widely useful things. If you have a good idea I'll look into implementing it.How about reusing the dmapi fields in
xfs_dinode, seeing as we forced them to zero in the base metadir series? Or do you have another use in mind for those 6 bytes?
I've always seen those a general space reserve for things that could be useful for all inodes as they are fairly large and contiguous. For these three bits I'd rather still them where it doesn't hurt too much. But maybe I'm overthinking it.
Re: [PATCH 41/43] xfs: support write life time based data placement
Quoted 8 lines · Christoph Hellwig
Quoted 7 lines · Darrick J. Wong
Quoted 6 lines
We've been thinking about that a lot. Right now we don't have an immediate use case for it, but it sure would be nice to have it without
needing another incompat bit. But then we'd need to find some space
(3 bits to be exact) in the on-disk inode for it that doesn't make otherwise useful space unavaіlable for more widely useful things. If you have a good idea I'll look into implementing it.
Quoted 8 lines
Quoted 3 lines
How about reusing the dmapi fields in
xfs_dinode, seeing as we forced them to zero in the base metadir series? Or do you have another use in mind for those 6 bytes?I've always seen those a general space reserve for things that could be useful for all inodes as they are fairly large and contiguous. For these three bits I'd rather still them where it doesn't hurt too much. But maybe I'm overthinking it.
Is anyone planning to add persistent write hints to xfs files?
--D
PATCH 42/43 xfs: wire up the show_stats super operation
In reply to Christoph HellwigThe show_stats option allows a file system to dump plain text statistic on a per-mount basis into /proc/*/mountstats. Wire up a no-op version which will grow useful information for zoned file systems later.
--- fs/xfs/xfs_super.c | 9 +++++++++ 1 file changed, 9 insertions(+)
fs/xfs/xfs_super.c +9 -0
@@ -1238,6 +1238,14 @@ xfs_fs_shutdown(xfs_force_shutdown (XFS_M (sb),SHUTDOWN_DEVICE_REMOVED ); } +static int +xfs_fs_show_stats ( +struct seq_file *m, +struct dentry *root) +{ +return 0 ; +} +static const struct super_operations xfs_super_operations = { .alloc_inode = xfs_fs_alloc_inode, .destroy_inode = xfs_fs_destroy_inode,
@@ -1252,6 +1260,7 @@ static const struct super_operations xfs_super_operations = { .nr_cached_objects = xfs_fs_nr_cached_objects, .free_cached_objects = xfs_fs_free_cached_objects, .shutdown = xfs_fs_shutdown, + .show_stats = xfs_fs_show_stats, }; static int
Signature · 1 line
2.45.2
Re: [PATCH 42/43] xfs: wire up the show_stats super operation
Quoted 5 lines · Christoph Hellwig
The
show_statsoption allows a file system to dump plain text statistic on a per-mount basis into/proc/*/mountstats. Wire up a no-op version which will grow useful information for zoned file systems later.Signed-off-by Christoph Hellwig <[email protected]>
--D
Quoted 35 lines
--- fs/xfs/xfs_super.c | 9 +++++++++ 1 file changed, 9 insertions(+)fs/xfs/xfs_super.c +9
-0@@ -1238,6 +1238,14 @@ xfs_fs_shutdown(xfs_force_shutdown (XFS_M (sb),SHUTDOWN_DEVICE_REMOVED ); } +static int +xfs_fs_show_stats ( +struct seq_file *m, +struct dentry *root) +{ +return 0 ; +} +static const struct super_operations xfs_super_operations = { .alloc_inode = xfs_fs_alloc_inode, .destroy_inode = xfs_fs_destroy_inode,@@ -1252,6 +1260,7 @@ static const struct super_operations xfs_super_operations = { .nr_cached_objects = xfs_fs_nr_cached_objects, .free_cached_objects = xfs_fs_free_cached_objects, .shutdown = xfs_fs_shutdown, + .show_stats = xfs_fs_show_stats, }; static intSignature · 1 line
2.45.2
PATCH 43/43 xfs: export zone stats in /proc/*/mountstats
In reply to Christoph HellwigFrom: Hans Holmberg <[email protected]>
Add the per-zone life time hint and the used block distribution for fully written zones, grouping reclaimable zones in fixed-percentage buckets spanning 0..9%, 10..19% and full zones as 100% used as well as a few statistics about the zone allocator and open and reclaimable zones in /proc/*/mountstats.
This gives good insight into data fragmentation and data placement success rate.
--- fs/xfs/Makefile | 1 + fs/xfs/xfs_super.c | 4 ++ fs/xfs/xfs_zone_alloc.h | 1 + fs/xfs/xfs_zone_info.c | 120 ++++++++++++++++++++++++++++++++++++++++ 4 files changed, 126 insertions(+) create mode 100644 fs/xfs/xfs_zone_info.c
fs/xfs/Makefile +1 -0
@@ -140,6 +140,7 @@ xfs-$(CONFIG_XFS_QUOTA) += xfs_dquot.o \ xfs-$(CONFIG_XFS_RT) += xfs_rtalloc.o \ xfs_zone_alloc.o \ xfs_zone_gc.o \ + xfs_zone_info.o \ xfs_zone_space_resv.o xfs-$(CONFIG_XFS_POSIX_ACL) += xfs_acl.o
fs/xfs/xfs_super.c +4 -0
@@ -1243,6 +1243,10 @@ xfs_fs_show_stats(struct seq_file *m, struct dentry *root) { + struct xfs_mount *mp = XFS_M(root->d_sb); + +if (xfs_has_zoned (mp) &&IS_ENABLED (CONFIG_XFS_RT )) +xfs_zoned_show_stats (m, mp);return 0 ; }
fs/xfs/xfs_zone_alloc.h +1 -0
@@ -34,6 +34,7 @@ void xfs_mark_rtg_boundary(struct iomap_ioend *ioend);uint64_t xfs_zoned_default_resblks (struct xfs_mount *mp,enum xfs_free_counter ctr); +void xfs_zoned_show_stats (struct seq_file *m,struct xfs_mount *mp);#ifdef CONFIG_XFS_RT int xfs_mount_zones (struct xfs_mount *mp);
fs/xfs/xfs_zone_info.c new file +120 -0
120 lines not on this page · raw message
Signature · 1 line
2.45.2
Re: [PATCH 43/43] xfs: export zone stats in /proc/*/mountstats
Quoted 161 lines · Christoph Hellwig
From: Hans Holmberg <[email protected]>
Add the per-zone life time hint and the used block distribution for fully written zones, grouping reclaimable zones in fixed-percentage buckets spanning 0..9%, 10..19% and full zones as 100% used as well as a few statistics about the zone allocator and open and reclaimable zones in
/proc/*/mountstats.This gives good insight into data fragmentation and data placement success rate.
Signed-off-by Hans Holmberg <[email protected]>Co-developed-by Christoph Hellwig <[email protected]>Signed-off-by Christoph Hellwig <[email protected]>--- fs/xfs/Makefile | 1 + fs/xfs/xfs_super.c | 4 ++ fs/xfs/xfs_zone_alloc.h | 1 + fs/xfs/xfs_zone_info.c | 120 ++++++++++++++++++++++++++++++++++++++++ 4 files changed, 126 insertions(+) create mode 100644 fs/xfs/xfs_zone_info.cfs/xfs/Makefile +1
-0@@ -140,6 +140,7 @@ xfs-$(CONFIG_XFS_QUOTA) += xfs_dquot.o \ xfs-$(CONFIG_XFS_RT) += xfs_rtalloc.o \ xfs_zone_alloc.o \ xfs_zone_gc.o \ + xfs_zone_info.o \ xfs_zone_space_resv.o xfs-$(CONFIG_XFS_POSIX_ACL) += xfs_acl.ofs/xfs/xfs_super.c +4
-0@@ -1243,6 +1243,10 @@ xfs_fs_show_stats(struct seq_file *m, struct dentry *root) { + struct xfs_mount *mp = XFS_M(root->d_sb); + +if (xfs_has_zoned (mp) &&IS_ENABLED (CONFIG_XFS_RT )) +xfs_zoned_show_stats (m, mp);return 0 ; }fs/xfs/xfs_zone_alloc.h +1
-0@@ -34,6 +34,7 @@ void xfs_mark_rtg_boundary(struct iomap_ioend *ioend);uint64_t xfs_zoned_default_resblks (struct xfs_mount *mp,enum xfs_free_counter ctr); +void xfs_zoned_show_stats (struct seq_file *m,struct xfs_mount *mp);#ifdef CONFIG_XFS_RT int xfs_mount_zones (struct xfs_mount *mp);fs/xfs/xfs_zone_info.c new file +94
-0@@ -0,0 +1,120 @@ +// SPDX-License-Identifier: GPL-2.0 +/* +* Copyright (c) 2023-2024 Christoph Hellwig. +* Copyright (c) 2024, Western Digital Corporation or its affiliates. +*/ +#include "xfs.h" +#include "xfs_shared.h" +#include "xfs_format.h" +#include "xfs_trans_resv.h" +#include "xfs_mount.h" +#include "xfs_inode.h" +#include "xfs_rtgroup.h" +#include "xfs_zone_alloc.h" +#include "xfs_zone_priv.h" + +static const char xfs_write_hint_shorthand[6 ][16 ] = { +"NOT_SET" ,"NONE" ,"SHORT" ,"MEDIUM" ,"LONG" ,"EXTREME" }; + +static inline const char * +xfs_write_hint_to_str ( +uint8_t write_hint) +{ +if (write_hint >WRITE_LIFE_EXTREME ) +return "UNKNOWN" ; +return xfs_write_hint_shorthand[write_hint]; +} + +static void +xfs_show_open_zone ( +struct seq_file *m, +struct xfs_open_zone *oz) +{ +seq_printf (m,"\t zone %d, wp %u, written %u, used %u, hint %s\n" , +rtg_rgno (oz->oz_rtg), + oz->oz_write_pointer, oz->oz_written, +rtg_rmap (oz->oz_rtg)->i_used_blocks, +xfs_write_hint_to_str (oz->oz_write_hint)); +} + +#define XFS_USED_BUCKETS 10 +#define XFS_USED_BUCKET_PCT (100 / XFS_USED_BUCKETS) + +static unsigned int +xfs_zone_to_bucket ( +struct xfs_rtgroup *rtg) +{ +return div_u64 (rtg_rmap (rtg)->i_used_blocks *XFS_USED_BUCKETS , + rtg->rtg_extents); +} + +static void +xfs_show_full_zone_used_distribution ( +struct seq_file *m, +struct xfs_mount *mp) +{ +struct xfs_zone_info *zi = mp->m_zone_info; +XA_STATE (xas, &mp->m_groups[XG_TYPE_RTG ].xa,0 ); +unsigned int buckets[XFS_USED_BUCKETS ] = {0 }; +unsigned int reclaimable =0 , full, i; +struct xfs_rtgroup *rtg; + +lockdep_assert_held (&zi->zi_zone_list_lock); + +rcu_read_lock (); +xas_for_each_marked (&xas, rtg,ULONG_MAX ,XFS_RTG_RECLAIMABLE ) { + buckets[xfs_zone_to_bucket (rtg)]++; + reclaimable++; + } +rcu_read_unlock (); + +for (i =0 ; i <XFS_USED_BUCKETS ; i++) +seq_printf (m,"\t %2u..%2u%%: %u\n" , i *XFS_USED_BUCKET_PCT , + (i +1 ) *XFS_USED_BUCKET_PCT -1 , buckets[i]); + + full = mp->m_sb.sb_rgcount; +if (zi->zi_open_gc_zone) + full--; + full -= zi->zi_nr_open_zones; + full -=atomic_read (&zi->zi_nr_free_zones); + full -= reclaimable; + +seq_printf (m,"\t 100%%: %u\n" , full); +} + +void +xfs_zoned_show_stats ( +struct seq_file *m, +struct xfs_mount *mp) +{ +struct xfs_zone_info *zi = mp->m_zone_info; +struct xfs_open_zone *oz; + +seq_puts (m,"\n" ); +
fs/xfs/xfs_zone_info.c line 104
Quoted 10 lines
fs/xfs/xfs_zone_info.c new file +10
-0+seq_printf (m,"\tuser free blocks: %lld\n" , +xfs_sum_freecounter (mp,XC_FREE_RTEXTENTS )); +seq_printf (m,"\treserved free blocks: %lld\n" , + mp->m_resblks[XC_FREE_RTEXTENTS ].avail); +seq_printf (m,"\tuser available blocks: %lld\n" , +xfs_sum_freecounter (mp,XC_FREE_RTAVAILABLE )); +seq_printf (m,"\treserved available blocks: %lld\n" , + mp->m_resblks[XC_FREE_RTAVAILABLE ].avail); +seq_printf (m,"\treservations required: %d\n" , + !list_empty_careful (&zi->zi_reclaim_reservations));
Might want to mention that these are zoned rt stats, not for the data device.
--D
Quoted 20 lines
fs/xfs/xfs_zone_info.c new file +16
-0+seq_printf (m,"\tGC required: %d\n" , +xfs_zoned_need_gc (mp)); + +spin_lock (&zi->zi_zone_list_lock); +seq_printf (m,"\tfree zones: %d\n" ,atomic_read (&zi->zi_nr_free_zones)); +seq_puts (m,"\topen zones:\n" ); +list_for_each_entry (oz, &zi->zi_open_zones, oz_entry) +xfs_show_open_zone (m, oz); +if (zi->zi_open_gc_zone) { +seq_puts (m,"\topen gc zone:\n" ); +xfs_show_open_zone (m, zi->zi_open_gc_zone); + } +seq_puts (m,"\tused blocks distribution (fully written zones):\n" ); +xfs_show_full_zone_used_distribution (m, mp); +spin_unlock (&zi->zi_zone_list_lock); +}Signature · 1 line
2.45.2