// SPDX-License-Identifier: GPL-2.0+ /* * Copyright ( C ) 2016 Oracle . All Rights Reserved . * Author : Darrick J . Wong < darrick . wong @ oracle . com > #include "xfs.h" #include "xfs_fs.h" #include "xfs_shared.h" #include "xfs_format.h" #include "xfs_log_format.h" #include "xfs_trans_resv.h" #include "xfs_mount.h" #include "xfs_defer.h" #include "xfs_inode.h" #include "xfs_trans.h" #include "xfs_bmap.h" #include "xfs_bmap_util.h" #include "xfs_trace.h" #include "xfs_icache.h" #include "xfs_btree.h" #include "xfs_refcount_btree.h" #include "xfs_refcount.h" #include "xfs_bmap_btree.h" #include "xfs_trans_space.h" #include "xfs_bit.h" #include "xfs_alloc.h" #include "xfs_quota.h" #include "xfs_reflink.h" #include "xfs_iomap.h" #include "xfs_ag.h" #include "xfs_ag_resv.h" #include "xfs_health.h" #include "xfs_rtrefcount_btree.h" #include "xfs_rtalloc.h" #include "xfs_rtgroup.h" #include "xfs_metafile.h" /* * Copy on Write of Shared Blocks * * XFS must preserve " the usual " file semantics even when two files share * the same physical blocks . This means that a write to one file must not * alter the blocks in a different file ; the way that we ' ll do that is * through the use of a copy - on - write mechanism . At a high level , that * means that when we want to write to a shared block , we allocate a new * block , write the data to the new block , and if that succeeds we map the * new block into the file . * * XFS provides a " delayed allocation " mechanism that defers the allocation * of disk blocks to dirty - but - not - yet - mapped file blocks as long as * possible . This reduces fragmentation by enabling the filesystem to ask * for bigger chunks less often , which is exactly what we want for CoW . * * The delalloc mechanism begins when the kernel wants to make a block * writable ( write_begin or page_mkwrite ) . If the offset is not mapped , we * create a delalloc mapping , which is a regular in - core extent , but without * a real startblock . ( For delalloc mappings , the startblock encodes both * a flag that this is a delalloc mapping , and a worst - case estimate of how * many blocks might be required to put the mapping into the BMBT . ) delalloc * mappings are a reservation against the free space in the filesystem ; * adjacent mappings can also be combined into fewer larger mappings . * * As an optimization , the CoW extent size hint ( cowextsz ) creates * outsized aligned delalloc reservations in the hope of landing out of * order nearby CoW writes in a single extent on disk , thereby reducing * fragmentation and improving future performance . * * D : - - RRRRRRSSSRRRRRRRR - - - ( data fork ) * C : - - - - - - DDDDDDD - - - - - - - - - ( CoW fork ) * * When dirty pages are being written out ( typically in writepage ) , the * delalloc reservations are converted into unwritten mappings by * allocating blocks and replacing the delalloc mapping with real ones . * A delalloc mapping can be replaced by several unwritten ones if the * free space is fragmented . * * D : - - RRRRRRSSSRRRRRRRR - - - * C : - - - - - - UUUUUUU - - - - - - - - - * * We want to adapt the delalloc mechanism for copy - on - write , since the * write paths are similar . The first two steps ( creating the reservation * and allocating the blocks ) are exactly the same as delalloc except that * the mappings must be stored in a separate CoW fork because we do not want * to disturb the mapping in the data fork until we ' re sure that the write * succeeded . IO completion in this case is the process of removing the old * mapping from the data fork and moving the new mapping from the CoW fork to * the data fork . This will be discussed shortly . * * For now , unaligned directio writes will be bounced back to the page cache . * Block - aligned directio writes will use the same mechanism as buffered * writes . * * Just prior to submitting the actual disk write requests , we convert * the extents representing the range of the file actually being written * ( as opposed to extra pieces created for the cowextsize hint ) to real * extents . This will become important in the next step : * * D : - - RRRRRRSSSRRRRRRRR - - - * C : - - - - - - UUrrUUU - - - - - - - - - * * CoW remapping must be done after the data block write completes , * because we don ' t want to destroy the old data fork map until we ' re sure * the new block has been written . Since the new mappings are kept in a * separate fork , we can simply iterate these mappings to find the ones * that cover the file blocks that we just CoW ' d . For each extent , simply * unmap the corresponding range in the data fork , map the new range into * the data fork , and remove the extent from the CoW fork . Because of * the presence of the cowextsize hint , however , we must be careful * only to remap the blocks that we ' ve actually written out - - we must * never remap delalloc reservations nor CoW staging blocks that have * yet to be written . This corresponds exactly to the real extents in * the CoW fork : * * D : - - RRRRRRrrSRRRRRRRR - - - * C : - - - - - - UU - - UUU - - - - - - - - - * * Since the remapping operation can be applied to an arbitrary file * range , we record the need for the remap step as a flag in the ioend * instead of declaring a new IO type . This is required for direct io * because we only have ioend for the whole dio , and we have to be able to * remember the presence of unwritten blocks and CoW blocks with a single * ioend structure . Better yet , the more ground we can cover with one * ioend , the better . /* * Given a file mapping for the data device , find the lowest - numbered run of * shared blocks within that mapping and return it in shared_offset / shared_len . * The offset is relative to the start of irec . * * If find_end_of_shared is true , return the longest contiguous extent of shared * blocks . If there are no shared extents , shared_offset and shared_len will be * set to 0 ; static int struct xfs_mount *mp,struct xfs_trans *tp,const struct xfs_bmbt_irec *irec,bool find_end_of_shared)struct xfs_buf *agbp;struct xfs_perag *pag;struct xfs_btree_cur *cur;int error;0 , &agbp);if (error)goto out;if (!error && *shared_len)return error;/* * Given a file mapping for the rt device , find the lowest - numbered run of * shared blocks within that mapping and return it in shared_offset / shared_len . * The offset is relative to the start of irec . * * If find_end_of_shared is true , return the longest contiguous extent of shared * blocks . If there are no shared extents , shared_offset and shared_len will be * set to 0 ; static int struct xfs_mount *mp,struct xfs_trans *tp,const struct xfs_bmbt_irec *irec,bool find_end_of_shared)struct xfs_rtgroup *rtg;struct xfs_btree_cur *cur;int error;/* * Note : this uses the not quite correct xfs_agblock_t type because * xfs_refcount_find_shared is shared between the RT and data device * refcount code . if (!error && *shared_len)return error;/* * Trim the mapping to the next block where there ' s a change in the * shared / unshared status . More specifically , this means that we * find the lowest - numbered extent of shared blocks that coincides with * the given block mapping . If the shared extent overlaps the start of * the mapping , trim the mapping to the end of the shared extent . If * the shared region intersects the mapping , trim the mapping to the * start of the shared extent . If there are no shared regions that * overlap , just return the original extent . int struct xfs_inode *ip,struct xfs_bmbt_irec *irec,bool *shared)struct xfs_mount *mp = ip->i_mount;int error = 0 ;/* Holes, unwritten, and delalloc extents cannot be shared */ if (!xfs_is_reflink_inode(ip) || !xfs_bmap_is_written_extent(irec)) {false ;return 0 ;if (XFS_IS_REALTIME_INODE(ip))true );else true );if (error)return error;if (!shared_len) {/* No shared blocks at all. */ false ;else if (!shared_offset) {/* * The start of this mapping points to shared space . Truncate * the mapping at the end of the shared region so that a * subsequent iteration starts at the start of the unshared * region . true ;else {/* * There ' s a shared region that doesn ' t start at the beginning * of the mapping . Truncate the mapping at the start of the * shared extent so that a subsequent iteration starts at the * start of the shared region . false ;return 0 ;int struct xfs_inode *ip,struct xfs_bmbt_irec *imap,bool *shared)/* We can't update any real extents in always COW mode. */ if (xfs_is_always_cow_inode(ip) &&true ;return 0 ;/* Trim the mapping to the nearest shared extent boundary. */ return xfs_reflink_trim_around_shared(ip, imap, shared);int struct xfs_inode *ip,struct xfs_iext_cursor icur;struct xfs_bmbt_irec got;struct xfs_btree_cur *dummy_cur = NULL;int dummy_logflags;int error = 0 ;if (!xfs_iext_lookup_extent(ip, ip->i_cowfp, offset_fsb, &icur, &got))return 0 ;do {if (got.br_startoff >= offset_fsb + count_fsb)break ;if (got.br_state == XFS_EXT_NORM)continue ;if (WARN_ON_ONCE(isnullstartblock(got.br_startblock)))return -EIO;if (!got.br_blockcount)continue ;if (error)return error;while (xfs_iext_next_extent(ip->i_cowfp, &icur, &got));return error;/* Convert all of the unwritten CoW extents in a file's range to real ones. */ int struct xfs_inode *ip,struct xfs_mount *mp = ip->i_mount;int error;0 );return error;/* * Find the extent that maps the given range in the COW fork . Even if the extent * is not shared we might have a preallocation for it in the COW fork . If so we * use it that rather than trigger a new allocation . static int struct xfs_inode *ip,struct xfs_bmbt_irec *imap,struct xfs_bmbt_irec *cmap,bool *shared,bool *found)struct xfs_iext_cursor icur;false ;/* * If we don ' t find an overlapping extent , trim the range we need to * allocate to fit the hole we found . if (!xfs_iext_lookup_extent(ip, ip->i_cowfp, offset_fsb, &icur, cmap))if (cmap->br_startoff > offset_fsb) {return xfs_bmap_trim_cow(ip, imap, shared);true ;if (isnullstartblock(cmap->br_startblock)) {return 0 ;/* real extent found - no need to allocate */ true ;return 0 ;static int struct xfs_inode *ip,struct xfs_bmbt_irec *imap,struct xfs_bmbt_irec *cmap,bool convert_now)int error;/* * cmap might larger than imap due to cowextsize hint . /* * COW fork extents are supposed to remain unwritten until we ' re ready * to initiate a disk write . For direct I / O we are going to write the * data and need the conversion , but for buffered writes we ' re done . if (!convert_now || cmap->br_state == XFS_EXT_NORM)return 0 ;if (!error)return error;static int struct xfs_inode *ip,struct xfs_bmbt_irec *imap,struct xfs_bmbt_irec *cmap,bool *shared,bool convert_now)struct xfs_mount *mp = ip->i_mount;struct xfs_trans *tp;unsigned int dblocks = 0 , rblocks = 0 ;int nimaps;int error;bool found;if (XFS_IS_REALTIME_INODE(ip)) {0 );else {0 ;0 ;false , &tp);if (error)return error;if (error || !*shared)goto out_trans_cancel;if (found) {goto convert;/* Allocate the entire reservation as unwritten blocks. */ 1 ;0 , cmap,if (error)goto out_trans_cancel;if (error)return error;return xfs_reflink_convert_unwritten(ip, imap, cmap, convert_now);return error;static int struct xfs_inode *ip,struct xfs_bmbt_irec *imap,struct xfs_bmbt_irec *cmap,bool *shared,bool convert_now)struct xfs_mount *mp = ip->i_mount;struct xfs_trans *tp;int nimaps;int error;bool found;do {0 ;0 , 0 ,false , &tp);if (error)return error;if (error || !*shared)goto out_trans_cancel;if (found) {break ;/* * Replace delalloc reservation with an unwritten extent . 1 ;0 ,if (error)goto out_trans_cancel;if (error)return error;while (cmap->br_startoff + cmap->br_blockcount <= imap->br_startoff);return xfs_reflink_convert_unwritten(ip, imap, cmap, convert_now);return error;/* Allocate all CoW reservations covering a range of blocks in a file. */ int struct xfs_inode *ip,struct xfs_bmbt_irec *imap,struct xfs_bmbt_irec *cmap,bool *shared,bool convert_now)int error;bool found;if (!ip->i_cowfp) {if (error || !*shared)return error;/* CoW fork has a real extent */ if (found)return xfs_reflink_convert_unwritten(ip, imap, cmap,/* * CoW fork does not have an extent and data extent is shared . * Allocate a real extent in the CoW fork . if (cmap->br_startoff > imap->br_startoff)return xfs_reflink_fill_cow_hole(ip, imap, cmap, shared,/* * CoW fork has a delalloc reservation . Replace it with a real extent . * There may or may not be a data fork mapping . if (isnullstartblock(cmap->br_startblock) ||return xfs_reflink_fill_delalloc(ip, imap, cmap, shared,/* Shouldn't get here. */ 0 );return -EFSCORRUPTED;/* * Cancel CoW reservations for some block range of an inode . * * If cancel_real is true this function cancels all COW fork extents for the * inode ; if cancel_real is false , real extents are not cleared . * * Caller must have already joined the inode to the current transaction . The * inode will be joined to the transaction returned to the caller . int struct xfs_inode *ip,struct xfs_trans **tpp,bool cancel_real)struct xfs_ifork *ifp = xfs_ifork_ptr(ip, XFS_COW_FORK);struct xfs_bmbt_irec got, del;struct xfs_iext_cursor icur;bool isrt = XFS_IS_REALTIME_INODE(ip);int error = 0 ;if (!xfs_inode_has_cow_data(ip))return 0 ;if (!xfs_iext_lookup_extent_before(ip, ifp, &end_fsb, &icur, &got))return 0 ;/* Walk backwards until we're out of the I/O range... */ while (got.br_startoff + got.br_blockcount > offset_fsb) {/* Extent delete may have bumped ext forward */ if (!del.br_blockcount) {goto next_extent;if (isnullstartblock(del.br_startblock)) {0 );else if (del.br_state == XFS_EXT_UNWRITTEN || cancel_real) {/* Free the CoW orphan record. */ 0 );if (error)break ;/* Roll the transaction */ if (error)break ;/* Remove the mapping from the CoW fork. */ /* Remove the quota reservation */ else {/* Didn't do anything, push cursor back. */ if (!xfs_iext_get_extent(ifp, &icur, &got))break ;/* clear tag if cow fork is emptied */ if (!ifp->if_bytes)return error;/* * Cancel CoW reservations for some byte range of an inode . * * If cancel_real is true this function cancels all COW fork extents for the * inode ; if cancel_real is false , real extents are not cleared . int struct xfs_inode *ip,bool cancel_real)struct xfs_trans *tp;int error;if (count == NULLFILEOFF)else /* Start a rolling transaction to remove the mappings */ 0 , 0 , 0 , &tp);if (error)goto out;0 );/* Scrape out the old CoW reservations */ if (error)goto out_cancel;return error;return error;#ifdef CONFIG_XFS_QUOTA/* * Update quota accounting for a remapping operation . When we ' re remapping * something from the CoW fork to the data fork , we must update the quota * accounting for delayed allocations . For remapping from the data fork to the * data fork , use regular block accounting . static inline void struct xfs_trans *tp,struct xfs_inode *ip,bool is_cow,unsigned int qflag;if (XFS_IS_REALTIME_INODE(ip)) {else {#else # define xfs_reflink_update_quota(tp, ip, is_cow, blocks) ((void )0 )#endif /* * Remap part of the CoW fork into the data fork . * * We aim to remap the range starting at @ offset_fsb and ending at @ end_fsb * into the data fork ; this function will remap what it can ( at the end of the * range ) and update @ end_fsb appropriately . Each remap gets its own * transaction because we can end up merging and splitting bmbt blocks for * every remap operation and we ' d like to keep the block reservation * requirements as low as possible . STATIC int struct xfs_trans *tp,struct xfs_inode *ip,struct xfs_iext_cursor icur;struct xfs_bmbt_irec got, del, data;struct xfs_ifork *ifp = xfs_ifork_ptr(ip, XFS_COW_FORK);int nmaps;bool isrt = XFS_IS_REALTIME_INODE(ip);int error;/* * In case of racing , overlapping AIO writes no COW extents might be * left by the time I / O completes for the loser of the race . In that * case we are done . if (!xfs_iext_lookup_extent(ip, ifp, *offset_fsb, &icur, &got) ||return 0 ;/* * Only remap real extents that contain data . With AIO , speculative * preallocations can leak into the range we are called upon , and we * need to skip them . Preserve @ got for the eventual CoW fork * deletion ; from now on @ del represents the mapping that we ' re * actually remapping . while (!xfs_bmap_is_written_extent(&got)) {if (!xfs_iext_next_extent(ifp, &icur, &got) ||return 0 ;if (error)return error;/* Grab the corresponding mapping in the data fork. */ 1 ;0 );if (error)return error;/* We can only remap the smaller of the two extent sizes. */ if (xfs_bmap_is_real_extent(&data)) {/* * If the extent we ' re remapping is backed by storage ( written * or not ) , unmap the extent and drop its refcount . false , -data.br_blockcount);else if (data.br_startblock == DELAYSTARTBLOCK) {int done;/* * If the extent we ' re remapping is a delalloc reservation , * we can use the regular bunmapi function to release the * incore state . Dropping the delalloc reservation takes care * of the quota reservation for us . 0 , 1 , &done);if (error)return error;/* Free the CoW orphan record. */ /* Map the new blocks into the data fork. */ /* Charge this new data fork mapping to the on-disk quota. */ true , del.br_blockcount);/* Remove the mapping from the CoW fork. */ /* Update the caller about how much progress we made. */ return 0 ;/* * Remap part of the CoW fork into the data fork . * * We aim to remap the range starting at @ offset_fsb and ending at @ end_fsb * into the data fork ; this function will remap what it can ( at the end of the * range ) and update @ end_fsb appropriately . Each remap gets its own * transaction because we can end up merging and splitting bmbt blocks for * every remap operation and we ' d like to keep the block reservation * requirements as low as possible . STATIC int struct xfs_inode *ip,struct xfs_mount *mp = ip->i_mount;struct xfs_trans *tp;unsigned int resblks;int error;0 ,if (error)return error;0 );if (error)else return error;/* * Remap parts of a file ' s data fork after a successful CoW . int struct xfs_inode *ip,int error = 0 ;/* * Walk forwards until we ' ve remapped the I / O range . The loop function * repeatedly cycles the ILOCK to allocate one transaction per remapped * extent . * * If we ' re being called by writeback then the pages will still * have PageWriteback set , which prevents races with reflink remapping * and truncate . Reflink remapping prevents races with writeback by * taking the iolock and mmaplock before flushing the pages and * remapping , which means there won ' t be any further writeback or page * cache dirtying until the reflink completes . * * We should never have two threads issuing writeback for the same file * region . There are also have post - eof checks in the writeback * preparation code so that we don ' t bother writing out pages that are * about to be truncated . * * If we ' re being called as part of directio write completion , the dio * count is still elevated , which reflink and truncate will wait for . * Reflink remapping takes the iolock and mmaplock and waits for * pending dio to finish , which should prevent any directio until the * remap completes . Multiple concurrent directio writes to the same * region are handled by end_cow processing only occurring for the * threads which succeed ; the outcome of multiple overlapping direct * writes is not well defined anyway . * * It ' s possible that a buffered write and a direct write could collide * here ( the buffered write stumbles in after the dio flushes and * invalidates the page cache and immediately queues writeback ) , but we * have never supported this 100 % . If either disk write succeeds the * blocks will be remapped . while (end_fsb > offset_fsb && !error)if (error)return error;/* * Fully remap all of the file ' s data fork at once , which is the critical part * in achieving atomic behaviour . * The regular CoW end path does not use function as to keep the block * reservation per transaction as low as possible . int struct xfs_inode *ip,int error = 0 ;struct xfs_mount *mp = ip->i_mount;struct xfs_trans *tp;unsigned int resblks;/* * Each remapping operation could cause a btree split , so in the worst * case that ' s one for each block . 1 , XFS_DATA_FORK);0 ,if (error)return error;0 );while (end_fsb > offset_fsb && !error) {if (error) {goto out_cancel;return error;return error;/* Compute the largest atomic write that we can complete through software. */ struct xfs_mount *mp)/* We cannot do any atomic writes without out of place writes. */ if (!xfs_can_sw_atomic_write(mp))return 0 ;/* * Atomic write limits must always be a power - of - 2 , according to * generic_atomic_write_valid . return rounddown_pow_of_two(xfs_calc_max_atomic_write_fsblocks(mp));/* * Free all CoW staging blocks that are still referenced by the ondisk refcount * metadata . The ondisk metadata does not track which inode created the * staging extent , so callers must ensure that there are no cached inodes with * live CoW staging extents . int struct xfs_mount *mp)struct xfs_perag *pag = NULL;struct xfs_rtgroup *rtg = NULL;int error = 0 ;if (!xfs_has_reflink(mp))return 0 ;while ((pag = xfs_perag_next(mp, pag))) {if (error) {return error;while ((rtg = xfs_rtgroup_next(mp, rtg))) {if (error) {return error;return 0 ;/* * Reflinking ( Block ) Ranges of Two Files Together * * First , ensure that the reflink flag is set on both inodes . The flag is an * optimization to avoid unnecessary refcount btree lookups in the write path . * * Now we can iteratively remap the range of extents ( and holes ) in src to the * corresponding ranges in dest . Let drange and srange denote the ranges of * logical blocks in dest and src touched by the reflink operation . * * While the length of drange is greater than zero , * - Read src ' s bmbt at the start of srange ( " imap " ) * - If imap doesn ' t exist , make imap appear to start at the end of srange * with zero length . * - If imap starts before srange , advance imap to start at srange . * - If imap goes beyond srange , truncate imap to end at the end of srange . * - Punch ( imap start - srange start + imap len ) blocks from dest at * offset ( drange start ) . * - If imap points to a real range of pblks , * > Increase the refcount of the imap ' s pblks * > Map imap ' s pblks into dest at the offset * ( drange start + imap start - srange start ) * - Advance drange and srange by ( imap start - srange start + imap len ) * * Finally , if the reflink made dest longer , update both the in - core and * on - disk file sizes . * * ASCII Art Demonstration : * * Let ' s say we want to reflink this source file : * * - - - - SSSSSSS - SSSSS - - - - SSSSSS ( src file ) * < - - - - - - - - - - - - - - - - - - - - > * * into this destination file : * * - - DDDDDDDDDDDDDDDDDDD - - DDD ( dest file ) * < - - - - - - - - - - - - - - - - - - - - > * ' - ' means a hole , and ' S ' and ' D ' are written blocks in the src and dest . * Observe that the range has different logical offsets in either file . * * Consider that the first extent in the source file doesn ' t line up with our * reflink range . Unmapping and remapping are separate operations , so we can * unmap more blocks from the destination file than we remap . * * - - - - SSSSSSS - SSSSS - - - - SSSSSS * < - - - - - - - > * - - DDDDD - - - - - - - - - DDDDD - - DDD * < - - - - - - - > * * Now remap the source extent into the destination file : * * - - - - SSSSSSS - SSSSS - - - - SSSSSS * < - - - - - - - > * - - DDDDD - - SSSSSSSDDDDD - - DDD * < - - - - - - - > * * Do likewise with the second hole and extent in our range . Holes in the * unmap range don ' t affect our operation . * * - - - - SSSSSSS - SSSSS - - - - SSSSSS * < - - - - > * - - DDDDD - - SSSSSSS - SSSSS - DDD * < - - - - > * * Finally , unmap and remap part of the third extent . This will increase the * size of the destination file . * * - - - - SSSSSSS - SSSSS - - - - SSSSSS * < - - - - - > * - - DDDDD - - SSSSSSS - SSSSS - - - - SSS * < - - - - - > * * Once we update the destination file ' s i_size , we ' re done . /* * Ensure the reflink bit is set in both inodes . STATIC int struct xfs_inode *src,struct xfs_inode *dest)struct xfs_mount *mp = src->i_mount;int error;struct xfs_trans *tp;if (xfs_is_reflink_inode(src) && xfs_is_reflink_inode(dest))return 0 ;0 , 0 , 0 , &tp);if (error)goto out_error;/* Lock both files against IO */ if (src->i_ino == dest->i_ino)else if (!xfs_is_reflink_inode(src)) {else if (src->i_ino == dest->i_ino)goto commit_flags;if (!xfs_is_reflink_inode(dest)) {else if (error)goto out_error;return error;return error;/* * Update destination inode size & cowextsize hint , if necessary . int struct xfs_inode *dest,unsigned int remap_flags)struct xfs_mount *mp = dest->i_mount;struct xfs_trans *tp;int error;if (newlen <= i_size_read(VFS_I(dest)) && cowextsize == 0 )return 0 ;0 , 0 , 0 , &tp);if (error)goto out_error;if (newlen > i_size_read(VFS_I(dest))) {if (cowextsize) {if (error)goto out_error;return error;return error;/* * Do we have enough reserve in this AG to handle a reflink ? The refcount * btree already reserved all the space it needs , but the rmap btree can grow * infinitely , so we won ' t allow more reflinks when the AG is down to the * btree reserves . static int struct xfs_mount *mp,struct xfs_inode *ip,struct xfs_perag *pag;int error = 0 ;if (!xfs_has_rmapbt(mp))return 0 ;if (XFS_IS_REALTIME_INODE(ip)) {if (xfs_metafile_resv_critical(mp))return -ENOSPC;return 0 ;if (xfs_ag_resv_critical(pag, XFS_AG_RESV_RMAPBT) ||return error;/* * Remap the given extent into the file . The dmap blockcount will be set to * the number of blocks that were actually remapped . STATIC int struct xfs_inode *ip,struct xfs_bmbt_irec *dmap,struct xfs_bmbt_irec smap;struct xfs_mount *mp = ip->i_mount;struct xfs_trans *tp;0 ;unsigned int dblocks, rblocks, resblks;bool quota_reserved = true ;bool smap_real;bool dmap_written = xfs_bmap_is_written_extent(dmap);bool isrt = XFS_IS_REALTIME_INODE(ip);int iext_delta = 0 ;int nimaps;int error;/* * Start a rolling transaction to switch the mappings . * * Adding a written extent to the extent map can cause a bmbt split , * and removing a mapped extent from the extent can cause a bmbt split . * The two operations cannot both cause a split since they operate on * the same index in the bmap btree , so we only need a reservation for * one bmbt split if either thing is happening . However , we haven ' t * locked the inode yet , so we reserve assuming this is the case . * * The first allocation call tries to reserve enough space to handle * mapping dmap into a sparse part of the file plus the bmbt split . We * haven ' t locked the inode or read the existing mapping yet , so we do * not know for sure that we need the space . This should succeed most * of the time . * * If the first attempt fails , try again but reserving only enough * space to handle a bmbt split . This is the hard minimum requirement , * and we revisit quota reservations later when we know more about what * we ' re remapping . if (XFS_IS_REALTIME_INODE(ip)) {else {0 ;false , &tp);if (error == -EDQUOT || error == -ENOSPC) {false ;0 , false , &tp);if (error)goto out;/* * Read what ' s currently mapped in the destination file into smap . * If smap isn ' t a hole , we will have to remove it before we can add * dmap to the destination file . 1 ;0 );if (error)goto out_cancel;1 && smap.br_startoff == dmap->br_startoff);/* * We can only remap as many blocks as the smaller of the two extent * maps , because we can only remap one extent at a time . /* * Two extents mapped to the same physical block must not have * different states ; that ' s filesystem corruption . Move on to the next * extent if they ' re both holes or both the same physical extent . if (dmap->br_startblock == smap.br_startblock) {if (dmap->br_state != smap.br_state) {goto out_cancel;/* If both extents are unwritten, leave them alone. */ if (dmap->br_state == XFS_EXT_UNWRITTEN &&goto out_cancel;/* No reflinking if the AG of the dest mapping is low on space. */ if (dmap_written) {if (error)goto out_cancel;/* * Increase quota reservation if we think the quota block counter for * this file could increase . * * If we are mapping a written extent into the file , we need to have * enough quota block count reservation to handle the blocks in that * extent . We log only the delta to the quota block counts , so if the * extent we ' re unmapping also has blocks allocated to it , we don ' t * need a quota reservation for the extent itself . * * Note that if we ' re replacing a delalloc reservation with a written * extent , we have to take the full quota reservation because removing * the delalloc reservation gives the block count back to the quota * count . This is suboptimal , but the VFS flushed the dest range * before we started . That should have removed all the delalloc * reservations , but we code defensively . * * xfs_trans_alloc_inode above already tried to grab an even larger * quota reservation , and kicked off a blockgc scan if it couldn ' t . * If we can ' t get a potentially smaller quota reservation now , we ' re * done . if (!quota_reserved && !smap_real && dmap_written) {if (XFS_IS_REALTIME_INODE(ip)) {0 ;else {0 ;false );if (error)goto out_cancel;if (smap_real)if (dmap_written)if (error)goto out_cancel;if (smap_real) {/* * If the extent we ' re unmapping is backed by storage ( written * or not ) , unmap the extent and drop its refcount . else if (smap.br_startblock == DELAYSTARTBLOCK) {int done;/* * If the extent we ' re unmapping is a delalloc reservation , * we can use the regular bunmapi function to release the * incore state . Dropping the delalloc reservation takes care * of the quota reservation for us . 0 , 1 , &done);if (error)goto out_cancel;/* * If the extent we ' re sharing is backed by written storage , increase * its refcount and map it into the file . if (dmap_written) {false , qdelta);/* Update dest isize if needed. */ if (newlen > i_size_read(VFS_I(ip))) {/* Commit everything and unlock. */ goto out_unlock;if (error)return error;/* Remap a range of one file to the other. */ int struct xfs_inode *src,struct xfs_inode *dest,struct xfs_bmbt_irec imap;struct xfs_mount *mp = src->i_mount;0 ;int nimaps;int error = 0 ;while (len > 0 ) {unsigned int lock_mode;/* Read extent from the source file */ 1 ;0 );if (error)break ;/* * The caller supposedly flushed all dirty pages in the source * file range , which means that writeback should have allocated * or deleted all delalloc reservations in that range . If we * find one , that ' s a good sign that something is seriously * wrong here . 1 && imap.br_startoff == srcoff);if (imap.br_startblock == DELAYSTARTBLOCK) {break ;/* Remap into the destination file at the given offset. */ if (error)break ;if (fatal_signal_pending(current)) {break ;/* Advance drange/srange */ if (error)return error;/* * If we ' re reflinking to a point past the destination file ' s EOF , we must * zero any speculative post - EOF preallocations that sit between the old EOF * and the destination file offset . static int struct xfs_inode *ip,if (pos <= isize)return 0 ;return xfs_zero_range(ip, isize, pos - isize, NULL, NULL);/* * Prepare two files for range cloning . Upon a successful return both inodes * will have the iolock and mmaplock held , the page cache of the out file will * be truncated , and any leases on the out file will have been broken . This * function borrows heavily from xfs_file_aio_write_checks . * * The VFS allows partial EOF blocks to " match " for dedupe even though it hasn ' t * checked that the bytes beyond EOF physically match . Hence we cannot use the * EOF block in the source dedupe range because it ' s not a complete block match , * hence can introduce a corruption into the file that has it ' s block replaced . * * In similar fashion , the VFS file cloning also allows partial EOF blocks to be * " block aligned " for the purposes of cloning entire files . However , if the * source file range includes the EOF block and it lands within the existing EOF * of the destination file , then we can expose stale data from beyond the source * file EOF in the destination file . * * XFS doesn ' t support partial block sharing , so in both cases we have check * these cases ourselves . For dedupe , we can simply round the length to dedupe * down to the previous whole block and ignore the partial EOF block . While this * means we can ' t dedupe the last block of a file , this is an acceptible * tradeoff for simplicity on implementation . * * For cloning , we want to share the partial EOF block if it is also the new EOF * block of the destination file . If the partial EOF block lies inside the * existing destination EOF , then we have to abort the clone to avoid exposing * stale data in the destination file . Hence we reject these clone attempts with * - EINVAL in this case . int struct file *file_in,struct file *file_out,unsigned int remap_flags)struct inode *inode_in = file_inode(file_in);struct xfs_inode *src = XFS_I(inode_in);struct inode *inode_out = file_inode(file_out);struct xfs_inode *dest = XFS_I(inode_out);int ret;/* Lock both files against IO */ if (ret)return ret;/* Check file eligibility and prepare for block sharing. */ /* Can't reflink between data and rt volumes */ if (XFS_IS_REALTIME_INODE(src) != XFS_IS_REALTIME_INODE(dest))goto out_unlock;/* Don't share DAX file data with non-DAX file. */ if (IS_DAX(inode_in) != IS_DAX(inode_out))goto out_unlock;if (!IS_DAX(inode_in))else if (ret || *len == 0 )goto out_unlock;/* Attach dquots to dest inode before changing block map */ if (ret)goto out_unlock;/* * Zero existing post - eof speculative preallocations in the destination * file . if (ret)goto out_unlock;/* Set flags and remap blocks. */ if (ret)goto out_unlock;/* * If pos_out > EOF , we may have dirtied blocks between EOF and * pos_out . In that case , we need to extend the flush and unmap to cover * from EOF to the end of the copy length . if (pos_out > XFS_ISIZE(dest)) {else {if (ret)goto out_unlock;if (inode_in != inode_out)return 0 ;return ret;/* Does this inode need the reflink flag? */ int struct xfs_trans *tp,struct xfs_inode *ip,bool *has_shared)struct xfs_bmbt_irec got;struct xfs_mount *mp = ip->i_mount;struct xfs_ifork *ifp;struct xfs_iext_cursor icur;bool found;int error;if (error)return error;false ;0 , &icur, &got);while (found) {if (isnullstartblock(got.br_startblock) ||goto next;if (XFS_IS_REALTIME_INODE(ip))false );else false );if (error)return error;/* Is there still a shared block here? */ if (shared_len) {true ;return 0 ;return 0 ;/* * Clear the inode reflink flag if there are no shared extents . * * The caller is responsible for joining the inode to the transaction passed in . * The inode will be joined to the transaction that is returned to the caller . int struct xfs_inode *ip,struct xfs_trans **tpp)bool needs_flag;int error = 0 ;if (!xfs_can_free_cowblocks(ip))return 0 ;if (error || needs_flag)return error;/* * We didn ' t find any shared blocks so turn off the reflink flag . * First , get rid of any leftover CoW mappings . 0 , XFS_MAX_FILEOFF,true );if (error)return error;/* Clear the inode flag. */ return error;/* * Clear the inode reflink flag if there are no shared extents and the size * hasn ' t changed . STATIC int struct xfs_inode *ip)struct xfs_mount *mp = ip->i_mount;struct xfs_trans *tp;int error = 0 ;/* Start a rolling transaction to remove the mappings */ 0 , 0 , 0 , &tp);if (error)return error;0 );if (error)goto cancel;if (error)goto out;return 0 ;return error;/* * Pre - COW all shared blocks within a given byte range of a file and turn off * the reflink flag if we unshare all of the file ' s blocks . int struct xfs_inode *ip,struct inode *inode = VFS_I(ip);int error;if (!xfs_is_reflink_inode(ip))return 0 ;if (IS_DAX(inode))else if (error)goto out;1 );if (error)goto out;/* Turn off the reflink flag if possible. */ if (error)goto out;return 0 ;return error;/* * Can we use reflink with this realtime extent size ? Note that we don ' t check * for rblocks > 0 here because this can be called as part of attaching a new * rt section . bool struct xfs_mount *mp,unsigned int rextsize)/* reflink on the realtime device requires rtgroups */ if (!xfs_has_rtgroups(mp))return false ;/* * Reflink doesn ' t support rt extent size larger than a single fsblock * because we would have to perform CoW - around for unaligned write * requests to guarantee that we always remap entire rt extents . if (rextsize != 1 )return false ;return true ;
Messung V0.5 in Prozent C=95 H=83 G=88
¤ Diese beiden folgenden Angebotsgruppen bietet das Unternehmen0.47Angebot
(Wie Sie bei der Firma Beratungs- und Dienstleistungen beauftragen können 2026-09-28)
¤ *Eine klare Vorstellung vom Zielzustand
