// SPDX-License-Identifier: GPL-2.0 /* * Copyright ( c ) 2014 Red Hat , Inc . * All Rights Reserved . #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_bit.h" #include "xfs_mount.h" #include "xfs_sb.h" #include "xfs_defer.h" #include "xfs_btree.h" #include "xfs_trans.h" #include "xfs_alloc.h" #include "xfs_rmap.h" #include "xfs_rmap_btree.h" #include "xfs_trace.h" #include "xfs_errortag.h" #include "xfs_error.h" #include "xfs_inode.h" #include "xfs_ag.h" #include "xfs_health.h" #include "xfs_rmap_item.h" #include "xfs_rtgroup.h" #include "xfs_rtrmap_btree.h" struct kmem_cache *xfs_rmap_intent_cache;/* * Lookup the first record less than or equal to [ bno , len , owner , offset ] * in the btree given by cur . int struct xfs_btree_cur *cur,unsigned int flags,struct xfs_rmap_irec *irec,int *stat)int get_stat = 0 ;int error;0 ;if (error || !(*stat) || !irec)return error;if (error)return error;if (!get_stat) {return -EFSCORRUPTED;return 0 ;/* * Lookup the record exactly matching [ bno , len , owner , offset ] * in the btree given by cur . int struct xfs_btree_cur *cur,unsigned int flags,int *stat)return xfs_btree_lookup(cur, XFS_LOOKUP_EQ, stat);/* * Update the record referred to by cur to the value given * by [ bno , len , owner , offset ] . * This either works ( return 0 ) or gets an EFSCORRUPTED error . STATIC int struct xfs_btree_cur *cur,struct xfs_rmap_irec *irec)union xfs_btree_rec rec;int error;if (error)return error;int struct xfs_btree_cur *rcur,unsigned int flags)int i;int error;if (error)goto done;if (XFS_IS_CORRUPT(rcur->bc_mp, i != 0 )) {goto done;if (error)goto done;if (XFS_IS_CORRUPT(rcur->bc_mp, i != 1 )) {goto done;if (error)return error;STATIC int struct xfs_btree_cur *rcur,unsigned int flags)int i;int error;if (error)goto done;if (XFS_IS_CORRUPT(rcur->bc_mp, i != 1 )) {goto done;if (error)goto done;if (XFS_IS_CORRUPT(rcur->bc_mp, i != 1 )) {goto done;if (error)return error;/* Convert an internal btree record to an rmap record. */ const union xfs_btree_rec *rec,struct xfs_rmap_irec *irec)return xfs_rmap_irec_offset_unpack(be64_to_cpu(rec->rmap.rm_offset),/* Simple checks for rmap records. */ struct xfs_perag *pag,const struct xfs_rmap_irec *irec)struct xfs_mount *mp = pag_mount(pag);bool is_inode;bool is_unwritten;bool is_bmbt;bool is_attr;if (irec->rm_blockcount == 0 )return __this_address;if (irec->rm_startblock <= XFS_AGFL_BLOCK(mp)) {if (irec->rm_owner != XFS_RMAP_OWN_FS)return __this_address;if (irec->rm_blockcount != XFS_AGFL_BLOCK(mp) + 1 )return __this_address;else {/* check for valid extent range, including overflow */ if (!xfs_verify_agbext(pag, irec->rm_startblock,return __this_address;if (!(xfs_verify_ino(mp, irec->rm_owner) ||return __this_address;/* Check flags. */ if (is_bmbt && irec->rm_offset != 0 )return __this_address;if (!is_inode && irec->rm_offset != 0 )return __this_address;if (is_unwritten && (is_bmbt || !is_inode || is_attr))return __this_address;if (!is_inode && (is_bmbt || is_unwritten || is_attr))return __this_address;/* Check for a valid fork offset, if applicable. */ if (is_inode && !is_bmbt &&return __this_address;return NULL;static xfs_failaddr_tstruct xfs_rtgroup *rtg,const struct xfs_rmap_irec *irec)struct xfs_mount *mp = rtg_mount(rtg);if (irec->rm_offset != 0 )return __this_address;if (irec->rm_flags & XFS_RMAP_UNWRITTEN)return __this_address;switch (irec->rm_owner) {case XFS_RMAP_OWN_FS:if (irec->rm_startblock != 0 )return __this_address;if (irec->rm_blockcount != mp->m_sb.sb_rextsize)return __this_address;return NULL;case XFS_RMAP_OWN_COW:if (!xfs_has_rtreflink(mp))return __this_address;if (!xfs_verify_rgbext(rtg, irec->rm_startblock,return __this_address;return NULL;default :return __this_address;return NULL;static xfs_failaddr_tstruct xfs_rtgroup *rtg,const struct xfs_rmap_irec *irec)struct xfs_mount *mp = rtg_mount(rtg);if (!xfs_verify_ino(mp, irec->rm_owner))return __this_address;if (!xfs_verify_rgbext(rtg, irec->rm_startblock, irec->rm_blockcount))return __this_address;if (!xfs_verify_fileext(mp, irec->rm_offset, irec->rm_blockcount))return __this_address;return NULL;struct xfs_rtgroup *rtg,const struct xfs_rmap_irec *irec)if (irec->rm_blockcount == 0 )return __this_address;if (irec->rm_flags & (XFS_RMAP_BMBT_BLOCK | XFS_RMAP_ATTR_FORK))return __this_address;if (XFS_RMAP_NON_INODE_OWNER(irec->rm_owner))return xfs_rtrmap_check_meta_irec(rtg, irec);return xfs_rtrmap_check_inode_irec(rtg, irec);static inline xfs_failaddr_tstruct xfs_btree_cur *cur,const struct xfs_rmap_irec *irec)if (xfs_btree_is_rtrmap(cur->bc_ops) ||return xfs_rtrmap_check_irec(to_rtg(cur->bc_group), irec);return xfs_rmap_check_irec(to_perag(cur->bc_group), irec);static inline int struct xfs_btree_cur *cur,const struct xfs_rmap_irec *irec)struct xfs_mount *mp = cur->bc_mp;if (xfs_btree_is_mem_rmap(cur->bc_ops))"In-Memory Reverse Mapping BTree record corruption detected at %pS!" , fa);else if (xfs_btree_is_rtrmap(cur->bc_ops))"RT Reverse Mapping BTree record corruption in rtgroup %u detected at %pS!" ,else "Reverse Mapping BTree record corruption in AG %d detected at %pS!" ,"Owner 0x%llx, flags 0x%x, start block 0x%x block count 0x%x" ,return -EFSCORRUPTED;/* * Get the data from the pointed - to record . int struct xfs_btree_cur *cur,struct xfs_rmap_irec *irec,int *stat)union xfs_btree_rec *rec;int error;if (error || !*stat)return error;if (!fa)if (fa)return xfs_rmap_complain_bad_rec(cur, fa, irec);return 0 ;struct xfs_find_left_neighbor_info {struct xfs_rmap_irec high;struct xfs_rmap_irec *irec;/* For each rmap given, figure out if it matches the key we want. */ STATIC int struct xfs_btree_cur *cur,const struct xfs_rmap_irec *rec,void *priv)struct xfs_find_left_neighbor_info *info = priv;if (rec->rm_owner != info->high.rm_owner)return 0 ;if (!XFS_RMAP_NON_INODE_OWNER(rec->rm_owner) &&1 != info->high.rm_offset)return 0 ;return -ECANCELED;/* * Find the record to the left of the given extent , being careful only to * return a match with the same owner and adjacent physical and logical * block ranges . STATIC int struct xfs_btree_cur *cur,unsigned int flags,struct xfs_rmap_irec *irec,int *stat)struct xfs_find_left_neighbor_info info;int found = 0 ;int error;0 ;if (bno == 0 )return 0 ;1 ;if (!XFS_RMAP_NON_INODE_OWNER(owner) &&if (offset == 0 )return 0 ;1 ;else 0 ;0 ;0 , owner, offset,/* * Historically , we always used the range query to walk every reverse * mapping that could possibly overlap the key that the caller asked * for , and filter out the ones that don ' t . That is very slow when * there are a lot of records . * * However , there are two scenarios where the classic btree search can * produce correct results - - if the index contains a record that is an * exact match for the lookup key ; and if there are no other records * between the record we want and the key we supplied . * * As an optimization , try a non - overlapped lookup first . This makes * extent conversion and remap operations run a bit faster if the * physical extents aren ' t being shared . If we don ' t find what we * want , we fall back to the overlapped query . if (error)return error;if (found)if (!error)if (error != -ECANCELED)return error;1 ;return 0 ;/* For each rmap given, figure out if it matches the key we want. */ STATIC int struct xfs_btree_cur *cur,const struct xfs_rmap_irec *rec,void *priv)struct xfs_find_left_neighbor_info *info = priv;if (rec->rm_owner != info->high.rm_owner)return 0 ;if (!XFS_RMAP_NON_INODE_OWNER(rec->rm_owner) &&return 0 ;return -ECANCELED;/* * Find the record to the left of the given extent , being careful only to * return a match with the same owner and overlapping physical and logical * block ranges . This is the overlapping - interval version of * xfs_rmap_lookup_le . int struct xfs_btree_cur *cur,unsigned int flags,struct xfs_rmap_irec *irec,int *stat)struct xfs_find_left_neighbor_info info;int found = 0 ;int error;if (!XFS_RMAP_NON_INODE_OWNER(owner) && !(flags & XFS_RMAP_BMBT_BLOCK))else 0 ;0 ;0 ;0 , owner, offset, flags);/* * Historically , we always used the range query to walk every reverse * mapping that could possibly overlap the key that the caller asked * for , and filter out the ones that don ' t . That is very slow when * there are a lot of records . * * However , there are two scenarios where the classic btree search can * produce correct results - - if the index contains a record that is an * exact match for the lookup key ; and if there are no other records * between the record we want and the key we supplied . * * As an optimization , try a non - overlapped lookup first . This makes * scrub run much faster on most filesystems because bmbt records are * usually an exact match for rmap records . If we don ' t find what we * want , we fall back to the overlapped query . if (error)return error;if (found)if (!error)if (error != -ECANCELED)return error;1 ;return 0 ;/* * Perform all the relevant owner checks for a removal op . If we ' re doing an * unknown - owner removal then we have no owner information to check . static int struct xfs_btree_cur *cur,struct xfs_rmap_irec *rec,unsigned int flags)struct xfs_mount *mp = cur->bc_mp;int error = 0 ;if (owner == XFS_RMAP_OWN_UNKNOWN)return 0 ;/* Make sure the unwritten flag matches. */ if (XFS_IS_CORRUPT(mp,goto out;/* Make sure the owner matches what we expect to find in the tree. */ if (XFS_IS_CORRUPT(mp, owner != rec->rm_owner)) {goto out;/* Check the offset, if necessary. */ if (XFS_RMAP_NON_INODE_OWNER(owner))goto out;if (flags & XFS_RMAP_BMBT_BLOCK) {if (XFS_IS_CORRUPT(mp,goto out;else {if (XFS_IS_CORRUPT(mp, rec->rm_offset > offset)) {goto out;if (XFS_IS_CORRUPT(mp,goto out;return error;/* * Find the extent in the rmap btree and remove it . * * The record we find should always be an exact match for the extent that we ' re * looking for , since we insert them into the btree without modification . * * Special Case # 1 : when growing the filesystem , we " free " an extent when * growing the last AG . This extent is new space and so it is not tracked as * used space in the btree . The growfs code will pass in an owner of * XFS_RMAP_OWN_NULL to indicate that it expected that there is no owner of this * extent . We verify that - the extent lookup result in a record that does not * overlap . * * Special Case # 2 : EFIs do not record the owner of the extent , so when * recovering EFIs from the log we pass in XFS_RMAP_OWN_UNKNOWN to tell the rmap * btree to ignore the owner ( i . e . wildcard match ) so we don ' t trigger * corruption checks during log recovery . STATIC int struct xfs_btree_cur *cur,bool unwritten,const struct xfs_owner_info *oinfo)struct xfs_mount *mp = cur->bc_mp;struct xfs_rmap_irec ltrec;int error = 0 ;int i;unsigned int flags;bool ignore_off;if (unwritten)/* * We should always have a left record because there ' s a static record * for the AG headers at rm_startblock = = 0 created by mkfs / growfs that * will not ever be removed from the tree . if (error)goto out_error;if (XFS_IS_CORRUPT(mp, i != 1 )) {goto out_error;/* * For growfs , the incoming extent must be beyond the left record we * just found as it is new space and won ' t be used by anyone . This is * just a corruption check as we don ' t actually do anything with this * extent . Note that we need to use > = instead of > because it might * be the case that the " left " extent goes all the way to EOFS . if (owner == XFS_RMAP_OWN_NULL) {if (XFS_IS_CORRUPT(mp,goto out_error;goto out_done;/* * If we ' re doing an unknown - owner removal for EFI recovery , we expect * to find the full range in the rmapbt or nothing at all . If we * don ' t find any rmaps overlapping either end of the range , we ' re * done . Hopefully this means that the EFI creator already queued * ( and finished ) a RUI to remove the rmap . if (owner == XFS_RMAP_OWN_UNKNOWN &&struct xfs_rmap_irec rtrec;0 , &i);if (error)goto out_error;if (i == 0 )goto out_done;if (error)goto out_error;if (XFS_IS_CORRUPT(mp, i != 1 )) {goto out_error;if (rtrec.rm_startblock >= bno + len)goto out_done;/* Make sure the extent we found covers the entire freeing range. */ if (XFS_IS_CORRUPT(mp,goto out_error;/* Check owner information. */ if (error)goto out_error;if (ltrec.rm_startblock == bno && ltrec.rm_blockcount == len) {/* exact match, simply remove the record from rmap tree */ if (error)goto out_error;if (XFS_IS_CORRUPT(mp, i != 1 )) {goto out_error;else if (ltrec.rm_startblock == bno) {/* * overlap left hand side of extent : move the start , trim the * length and update the current record . * * ltbno ltlen * Orig : | oooooooooooooooooooo | * Freeing : | fffffffff | * Result : | rrrrrrrrrr | * bno len if (!ignore_off)if (error)goto out_error;else if (ltrec.rm_startblock + ltrec.rm_blockcount == bno + len) {/* * overlap right hand side of extent : trim the length and update * the current record . * * ltbno ltlen * Orig : | oooooooooooooooooooo | * Freeing : | fffffffff | * Result : | rrrrrrrrrr | * bno len if (error)goto out_error;else {/* * overlap middle of extent : trim the length of the existing * record to the length of the new left - extent size , increment * the insertion position so we can insert a new record * containing the remaining right - extent space . * * ltbno ltlen * Orig : | oooooooooooooooooooo | * Freeing : | fffffffff | * Result : | rrrrr | | rrrr | * bno len if (error)goto out_error;0 , &i);if (error)goto out_error;if (ignore_off)0 ;else if (error)goto out_error;if (error)return error;#ifdef CONFIG_XFS_LIVE_HOOKS/* * Use a static key here to reduce the overhead of rmapbt live updates . If * the compiler supports jump labels , the static branch will be replaced by a * nop sled when there are no hook users . Online fsck is currently the only * caller , so this is a reasonable tradeoff . * * Note : Patching the kernel code requires taking the cpu hotplug lock . Other * parts of the kernel allocate memory with that lock held , which means that * XFS callers cannot hold any locks that might be used by memory reclaim or * writeback when calling the static_branch_ { inc , dec } functions . void void )void void )/* Call downstream hooks for a reverse mapping update. */ static inline void struct xfs_trans *tp,struct xfs_group *xg,enum xfs_rmap_intent_type op,bool unwritten,const struct xfs_owner_info *oinfo)if (xfs_hooks_switched_on(&xfs_rmap_hooks_switch)) {struct xfs_rmap_update_params p = {/* struct copy */ if (xg)/* Call the specified function during a reverse mapping update. */ int struct xfs_group *xg,struct xfs_rmap_hook *hook)return xfs_hooks_add(&xg->xg_rmap_update_hooks, &hook->rmap_hook);/* Stop calling the specified function during a reverse mapping update. */ void struct xfs_group *xg,struct xfs_rmap_hook *hook)/* Configure rmap update hook functions. */ void struct xfs_rmap_hook *hook,#else # define xfs_rmap_update_hook(t, p, o, s, b, u, oi) do { } while (0 )#endif /* CONFIG_XFS_LIVE_HOOKS */ /* * Remove a reference to an extent in the rmap btree . int struct xfs_trans *tp,struct xfs_buf *agbp,struct xfs_perag *pag,const struct xfs_owner_info *oinfo)struct xfs_mount *mp = tp->t_mountp;struct xfs_btree_cur *cur;int error;if (!xfs_has_rmapbt(mp))return 0 ;false , oinfo);false , oinfo);return error;/* * A mergeable rmap must have the same owner and the same values for * the unwritten , attr_fork , and bmbt flags . The startblock and * offset are checked separately . static bool struct xfs_rmap_irec *irec,unsigned int flags)if (irec->rm_owner == XFS_RMAP_OWN_NULL)return false ;if (irec->rm_owner != owner)return false ;if ((flags & XFS_RMAP_UNWRITTEN) ^return false ;if ((flags & XFS_RMAP_ATTR_FORK) ^return false ;if ((flags & XFS_RMAP_BMBT_BLOCK) ^return false ;return true ;/* * When we allocate a new block , the first thing we do is add a reference to * the extent in the rmap btree . This takes the form of a [ agbno , length , * owner , offset ] record . Flags are encoded in the high bits of the offset * field . STATIC int struct xfs_btree_cur *cur,bool unwritten,const struct xfs_owner_info *oinfo)struct xfs_mount *mp = cur->bc_mp;struct xfs_rmap_irec ltrec;struct xfs_rmap_irec gtrec;int have_gt;int have_lt;int error = 0 ;int i;unsigned int flags = 0 ;bool ignore_off;0 );if (unwritten)/* * For the initial lookup , look for an exact match or the left - adjacent * record for our insertion point . This will also give us the record for * start block contiguity tests . if (error)goto out_error;if (have_lt) {if (!xfs_rmap_is_mergeable(<rec, owner, flags))0 ;if (XFS_IS_CORRUPT(mp,0 &&goto out_error;/* * Increment the cursor to see if we have a right - adjacent record to our * insertion point . This will give us the record for end block * contiguity tests . 0 , &have_gt);if (error)goto out_error;if (have_gt) {if (error)goto out_error;if (XFS_IS_CORRUPT(mp, have_gt != 1 )) {goto out_error;if (XFS_IS_CORRUPT(mp, bno + len > gtrec.rm_startblock)) {goto out_error;if (!xfs_rmap_is_mergeable(>rec, owner, flags))0 ;/* * Note : cursor currently points one record to the right of ltrec , even * if there is no record in the tree to the right . if (have_lt &&/* * left edge contiguous , merge into left record . * * ltbno ltlen * orig : | ooooooooo | * adding : | aaaaaaaaa | * result : | rrrrrrrrrrrrrrrrrrr | * bno len if (have_gt &&unsigned long )ltrec.rm_blockcount + len +/* * right edge also contiguous , delete right record * and merge into left record . * * ltbno ltlen gtbno gtlen * orig : | ooooooooo | | ooooooooo | * adding : | aaaaaaaaa | * result : | rrrrrrrrrrrrrrrrrrrrrrrrrrrrr | if (error)goto out_error;if (XFS_IS_CORRUPT(mp, i != 1 )) {goto out_error;/* point the cursor back to the left record and update */ 0 , &have_gt);if (error)goto out_error;if (error)goto out_error;else if (have_gt &&/* * right edge contiguous , merge into right record . * * gtbno gtlen * Orig : | ooooooooo | * adding : | aaaaaaaaa | * Result : | rrrrrrrrrrrrrrrrrrr | * bno len if (!ignore_off)if (error)goto out_error;else {/* * no contiguous edge with identical owner , insert * new record at current cursor position . if (error)goto out_error;if (XFS_IS_CORRUPT(mp, i != 1 )) {goto out_error;if (error)return error;/* * Add a reference to an extent in the rmap btree . int struct xfs_trans *tp,struct xfs_buf *agbp,struct xfs_perag *pag,const struct xfs_owner_info *oinfo)struct xfs_mount *mp = tp->t_mountp;struct xfs_btree_cur *cur;int error;if (!xfs_has_rmapbt(mp))return 0 ;false ,false , oinfo);return error;#define RMAP_LEFT_CONTIG (1 << 0 )#define RMAP_RIGHT_CONTIG (1 << 1 )#define RMAP_LEFT_FILLING (1 << 2 )#define RMAP_RIGHT_FILLING (1 << 3 )#define RMAP_LEFT_VALID (1 << 6 )#define RMAP_RIGHT_VALID (1 << 7 )#define LEFT r[0 ]#define RIGHT r[1 ]#define PREV r[2 ]#define NEW r[3 ]/* * Convert an unwritten extent to a real extent or vice versa . * Does not handle overlapping extents . STATIC int struct xfs_btree_cur *cur,bool unwritten,const struct xfs_owner_info *oinfo)struct xfs_mount *mp = cur->bc_mp;struct xfs_rmap_irec r[4 ]; /* neighbor extent entries */ /* left is 0, right is 1, */ /* prev is 2, new is 3 */ unsigned int oldext;unsigned int newext;unsigned int flags = 0 ;int i;int state = 0 ;int error;0 ;/* * For the initial lookup , look for an exact match or the left - adjacent * record for our insertion point . This will also give us the record for * start block contiguity tests . if (error)goto done;if (XFS_IS_CORRUPT(mp, i != 1 )) {goto done;/* * Set flags determining what part of the previous oldext allocation * extent is being replaced by a newext allocation . if (PREV.rm_offset == offset)if (PREV.rm_offset + PREV.rm_blockcount == new_endoff)/* * Decrement the cursor to see if we have a left - adjacent record to our * insertion point . This will give us the record for end block * contiguity tests . 0 , &i);if (error)goto done;if (i) {if (error)goto done;if (XFS_IS_CORRUPT(mp, i != 1 )) {goto done;if (XFS_IS_CORRUPT(mp,goto done;if (LEFT.rm_startblock + LEFT.rm_blockcount == bno &&/* * Increment the cursor to see if we have a right - adjacent record to our * insertion point . This will give us the record for end block * contiguity tests . 0 , &i);if (error)goto done;if (XFS_IS_CORRUPT(mp, i != 1 )) {goto done;0 , &i);if (error)goto done;if (i) {if (error)goto done;if (XFS_IS_CORRUPT(mp, i != 1 )) {goto done;if (XFS_IS_CORRUPT(mp, bno + len > RIGHT.rm_startblock)) {goto done;if (bno + len == RIGHT.rm_startblock &&/* check that left + prev + right is not too long */ if ((state & (RMAP_LEFT_FILLING | RMAP_LEFT_CONTIG |unsigned long )LEFT.rm_blockcount + len +/* reset the cursor back to PREV */ if (error)goto done;if (XFS_IS_CORRUPT(mp, i != 1 )) {goto done;/* * Switch out based on the FILLING and CONTIG state bits . switch (state & (RMAP_LEFT_FILLING | RMAP_LEFT_CONTIG |case RMAP_LEFT_FILLING | RMAP_LEFT_CONTIG |/* * Setting all of a previous oldext extent to newext . * The left and right neighbors are both contiguous with new . 0 , &i);if (error)goto done;if (XFS_IS_CORRUPT(mp, i != 1 )) {goto done;if (error)goto done;if (XFS_IS_CORRUPT(mp, i != 1 )) {goto done;0 , &i);if (error)goto done;if (XFS_IS_CORRUPT(mp, i != 1 )) {goto done;if (error)goto done;if (XFS_IS_CORRUPT(mp, i != 1 )) {goto done;0 , &i);if (error)goto done;if (XFS_IS_CORRUPT(mp, i != 1 )) {goto done;NEW = LEFT;NEW .rm_blockcount += PREV.rm_blockcount + RIGHT.rm_blockcount;NEW );if (error)goto done;break ;case RMAP_LEFT_FILLING | RMAP_RIGHT_FILLING | RMAP_LEFT_CONTIG:/* * Setting all of a previous oldext extent to newext . * The left neighbor is contiguous , the right is not . if (error)goto done;if (XFS_IS_CORRUPT(mp, i != 1 )) {goto done;0 , &i);if (error)goto done;if (XFS_IS_CORRUPT(mp, i != 1 )) {goto done;NEW = LEFT;NEW .rm_blockcount += PREV.rm_blockcount;NEW );if (error)goto done;break ;case RMAP_LEFT_FILLING | RMAP_RIGHT_FILLING | RMAP_RIGHT_CONTIG:/* * Setting all of a previous oldext extent to newext . * The right neighbor is contiguous , the left is not . 0 , &i);if (error)goto done;if (XFS_IS_CORRUPT(mp, i != 1 )) {goto done;if (error)goto done;if (XFS_IS_CORRUPT(mp, i != 1 )) {goto done;0 , &i);if (error)goto done;if (XFS_IS_CORRUPT(mp, i != 1 )) {goto done;NEW = PREV;NEW .rm_blockcount = len + RIGHT.rm_blockcount;NEW .rm_flags = newext;NEW );if (error)goto done;break ;case RMAP_LEFT_FILLING | RMAP_RIGHT_FILLING:/* * Setting all of a previous oldext extent to newext . * Neither the left nor right neighbors are contiguous with * the new one . NEW = PREV;NEW .rm_flags = newext;NEW );if (error)goto done;break ;case RMAP_LEFT_FILLING | RMAP_LEFT_CONTIG:/* * Setting the first part of a previous oldext extent to newext . * The left neighbor is contiguous . NEW = PREV;NEW .rm_offset += len;NEW .rm_startblock += len;NEW .rm_blockcount -= len;NEW );if (error)goto done;0 , &i);if (error)goto done;NEW = LEFT;NEW .rm_blockcount += len;NEW );if (error)goto done;break ;case RMAP_LEFT_FILLING:/* * Setting the first part of a previous oldext extent to newext . * The left neighbor is not contiguous . NEW = PREV;NEW .rm_startblock += len;NEW .rm_offset += len;NEW .rm_blockcount -= len;NEW );if (error)goto done;NEW .rm_startblock = bno;NEW .rm_owner = owner;NEW .rm_offset = offset;NEW .rm_blockcount = len;NEW .rm_flags = newext;NEW ;if (error)goto done;if (XFS_IS_CORRUPT(mp, i != 1 )) {goto done;break ;case RMAP_RIGHT_FILLING | RMAP_RIGHT_CONTIG:/* * Setting the last part of a previous oldext extent to newext . * The right neighbor is contiguous with the new allocation . NEW = PREV;NEW .rm_blockcount -= len;NEW );if (error)goto done;0 , &i);if (error)goto done;NEW = RIGHT;NEW .rm_offset = offset;NEW .rm_startblock = bno;NEW .rm_blockcount += len;NEW );if (error)goto done;break ;case RMAP_RIGHT_FILLING:/* * Setting the last part of a previous oldext extent to newext . * The right neighbor is not contiguous . NEW = PREV;NEW .rm_blockcount -= len;NEW );if (error)goto done;if (error)goto done;if (XFS_IS_CORRUPT(mp, i != 0 )) {goto done;NEW .rm_startblock = bno;NEW .rm_owner = owner;NEW .rm_offset = offset;NEW .rm_blockcount = len;NEW .rm_flags = newext;NEW ;if (error)goto done;if (XFS_IS_CORRUPT(mp, i != 1 )) {goto done;break ;case 0 :/* * Setting the middle part of a previous oldext extent to * newext . Contiguity is impossible here . * One extent becomes three extents . /* new right extent - oldext */ NEW .rm_startblock = bno + len;NEW .rm_owner = owner;NEW .rm_offset = new_endoff;NEW .rm_blockcount = PREV.rm_offset + PREV.rm_blockcount -NEW .rm_flags = PREV.rm_flags;NEW );if (error)goto done;/* new left extent - oldext */ NEW = PREV;NEW .rm_blockcount = offset - PREV.rm_offset;NEW ;NEW .rm_startblock,NEW .rm_blockcount, NEW .rm_owner, NEW .rm_offset,NEW .rm_flags);if (error)goto done;if (XFS_IS_CORRUPT(mp, i != 1 )) {goto done;/* * Reset the cursor to the position of the new extent * we are about to insert as we can ' t trust it after * the previous insert . if (error)goto done;if (XFS_IS_CORRUPT(mp, i != 0 )) {goto done;/* new middle extent - newext */ if (error)goto done;if (XFS_IS_CORRUPT(mp, i != 1 )) {goto done;break ;case RMAP_LEFT_FILLING | RMAP_LEFT_CONTIG | RMAP_RIGHT_CONTIG:case RMAP_RIGHT_FILLING | RMAP_LEFT_CONTIG | RMAP_RIGHT_CONTIG:case RMAP_LEFT_FILLING | RMAP_RIGHT_CONTIG:case RMAP_RIGHT_FILLING | RMAP_LEFT_CONTIG:case RMAP_LEFT_CONTIG | RMAP_RIGHT_CONTIG:case RMAP_LEFT_CONTIG:case RMAP_RIGHT_CONTIG:/* * These cases are all impossible . 0 );if (error)return error;/* * Convert an unwritten extent to a real extent or vice versa . If there is no * possibility of overlapping extents , delegate to the simpler convert * function . STATIC int struct xfs_btree_cur *cur,bool unwritten,const struct xfs_owner_info *oinfo)struct xfs_mount *mp = cur->bc_mp;struct xfs_rmap_irec r[4 ]; /* neighbor extent entries */ /* left is 0, right is 1, */ /* prev is 2, new is 3 */ unsigned int oldext;unsigned int newext;unsigned int flags = 0 ;int i;int state = 0 ;int error;0 ;/* * For the initial lookup , look for and exact match or the left - adjacent * record for our insertion point . This will also give us the record for * start block contiguity tests . if (error)goto done;if (XFS_IS_CORRUPT(mp, i != 1 )) {goto done;/* * Set flags determining what part of the previous oldext allocation * extent is being replaced by a newext allocation . if (PREV.rm_offset == offset)if (PREV.rm_offset + PREV.rm_blockcount == new_endoff)/* Is there a left record that abuts our range? */ if (error)goto done;if (i) {if (XFS_IS_CORRUPT(mp,goto done;if (xfs_rmap_is_mergeable(&LEFT, owner, newext))/* Is there a right record that abuts our range? */ if (error)goto done;if (i) {if (error)goto done;if (XFS_IS_CORRUPT(mp, i != 1 )) {goto done;if (XFS_IS_CORRUPT(mp, bno + len > RIGHT.rm_startblock)) {goto done;if (xfs_rmap_is_mergeable(&RIGHT, owner, newext))/* check that left + prev + right is not too long */ if ((state & (RMAP_LEFT_FILLING | RMAP_LEFT_CONTIG |unsigned long )LEFT.rm_blockcount + len +/* * Switch out based on the FILLING and CONTIG state bits . switch (state & (RMAP_LEFT_FILLING | RMAP_LEFT_CONTIG |case RMAP_LEFT_FILLING | RMAP_LEFT_CONTIG |/* * Setting all of a previous oldext extent to newext . * The left and right neighbors are both contiguous with new . if (error)goto done;if (error)goto done;NEW = LEFT;NEW .rm_startblock,NEW .rm_blockcount, NEW .rm_owner,NEW .rm_offset, NEW .rm_flags, &i);if (error)goto done;if (XFS_IS_CORRUPT(mp, i != 1 )) {goto done;NEW .rm_blockcount += PREV.rm_blockcount + RIGHT.rm_blockcount;NEW );if (error)goto done;break ;case RMAP_LEFT_FILLING | RMAP_RIGHT_FILLING | RMAP_LEFT_CONTIG:/* * Setting all of a previous oldext extent to newext . * The left neighbor is contiguous , the right is not . if (error)goto done;NEW = LEFT;NEW .rm_startblock,NEW .rm_blockcount, NEW .rm_owner,NEW .rm_offset, NEW .rm_flags, &i);if (error)goto done;if (XFS_IS_CORRUPT(mp, i != 1 )) {goto done;NEW .rm_blockcount += PREV.rm_blockcount;NEW );if (error)goto done;break ;case RMAP_LEFT_FILLING | RMAP_RIGHT_FILLING | RMAP_RIGHT_CONTIG:/* * Setting all of a previous oldext extent to newext . * The right neighbor is contiguous , the left is not . if (error)goto done;NEW = PREV;NEW .rm_startblock,NEW .rm_blockcount, NEW .rm_owner,NEW .rm_offset, NEW .rm_flags, &i);if (error)goto done;if (XFS_IS_CORRUPT(mp, i != 1 )) {goto done;NEW .rm_blockcount += RIGHT.rm_blockcount;NEW .rm_flags = RIGHT.rm_flags;NEW );if (error)goto done;break ;case RMAP_LEFT_FILLING | RMAP_RIGHT_FILLING:/* * Setting all of a previous oldext extent to newext . * Neither the left nor right neighbors are contiguous with * the new one . NEW = PREV;NEW .rm_startblock,NEW .rm_blockcount, NEW .rm_owner,NEW .rm_offset, NEW .rm_flags, &i);if (error)goto done;if (XFS_IS_CORRUPT(mp, i != 1 )) {goto done;NEW .rm_flags = newext;NEW );if (error)goto done;break ;case RMAP_LEFT_FILLING | RMAP_LEFT_CONTIG:/* * Setting the first part of a previous oldext extent to newext . * The left neighbor is contiguous . NEW = PREV;NEW .rm_startblock,NEW .rm_blockcount, NEW .rm_owner,NEW .rm_offset, NEW .rm_flags);if (error)goto done;NEW .rm_offset += len;NEW .rm_startblock += len;NEW .rm_blockcount -= len;NEW .rm_startblock,NEW .rm_blockcount, NEW .rm_owner,NEW .rm_offset, NEW .rm_flags);if (error)goto done;NEW = LEFT;NEW .rm_startblock,NEW .rm_blockcount, NEW .rm_owner,NEW .rm_offset, NEW .rm_flags, &i);if (error)goto done;if (XFS_IS_CORRUPT(mp, i != 1 )) {goto done;NEW .rm_blockcount += len;NEW );if (error)goto done;break ;case RMAP_LEFT_FILLING:/* * Setting the first part of a previous oldext extent to newext . * The left neighbor is not contiguous . NEW = PREV;NEW .rm_startblock,NEW .rm_blockcount, NEW .rm_owner,NEW .rm_offset, NEW .rm_flags);if (error)goto done;NEW .rm_offset += len;NEW .rm_startblock += len;NEW .rm_blockcount -= len;NEW .rm_startblock,NEW .rm_blockcount, NEW .rm_owner,NEW .rm_offset, NEW .rm_flags);if (error)goto done;if (error)goto done;break ;case RMAP_RIGHT_FILLING | RMAP_RIGHT_CONTIG:/* * Setting the last part of a previous oldext extent to newext . * The right neighbor is contiguous with the new allocation . NEW = PREV;NEW .rm_startblock,NEW .rm_blockcount, NEW .rm_owner,NEW .rm_offset, NEW .rm_flags, &i);if (error)goto done;if (XFS_IS_CORRUPT(mp, i != 1 )) {goto done;NEW .rm_blockcount = offset - NEW .rm_offset;NEW );if (error)goto done;NEW = RIGHT;NEW .rm_startblock,NEW .rm_blockcount, NEW .rm_owner,NEW .rm_offset, NEW .rm_flags);if (error)goto done;NEW .rm_offset = offset;NEW .rm_startblock = bno;NEW .rm_blockcount += len;NEW .rm_startblock,NEW .rm_blockcount, NEW .rm_owner,NEW .rm_offset, NEW .rm_flags);if (error)goto done;break ;case RMAP_RIGHT_FILLING:/* * Setting the last part of a previous oldext extent to newext . * The right neighbor is not contiguous . NEW = PREV;NEW .rm_startblock,NEW .rm_blockcount, NEW .rm_owner,NEW .rm_offset, NEW .rm_flags, &i);if (error)goto done;if (XFS_IS_CORRUPT(mp, i != 1 )) {goto done;NEW .rm_blockcount -= len;NEW );if (error)goto done;if (error)goto done;break ;case 0 :/* * Setting the middle part of a previous oldext extent to * newext . Contiguity is impossible here . * One extent becomes three extents . /* new right extent - oldext */ NEW .rm_startblock = bno + len;NEW .rm_owner = owner;NEW .rm_offset = new_endoff;NEW .rm_blockcount = PREV.rm_offset + PREV.rm_blockcount -NEW .rm_flags = PREV.rm_flags;NEW .rm_startblock,NEW .rm_blockcount, NEW .rm_owner, NEW .rm_offset,NEW .rm_flags);if (error)goto done;/* new left extent - oldext */ NEW = PREV;NEW .rm_startblock,NEW .rm_blockcount, NEW .rm_owner,NEW .rm_offset, NEW .rm_flags, &i);if (error)goto done;if (XFS_IS_CORRUPT(mp, i != 1 )) {goto done;NEW .rm_blockcount = offset - NEW .rm_offset;NEW );if (error)goto done;/* new middle extent - newext */ NEW .rm_startblock = bno;NEW .rm_blockcount = len;NEW .rm_owner = owner;NEW .rm_offset = offset;NEW .rm_flags = newext;NEW .rm_startblock,NEW .rm_blockcount, NEW .rm_owner, NEW .rm_offset,NEW .rm_flags);if (error)goto done;break ;case RMAP_LEFT_FILLING | RMAP_LEFT_CONTIG | RMAP_RIGHT_CONTIG:case RMAP_RIGHT_FILLING | RMAP_LEFT_CONTIG | RMAP_RIGHT_CONTIG:case RMAP_LEFT_FILLING | RMAP_RIGHT_CONTIG:case RMAP_RIGHT_FILLING | RMAP_LEFT_CONTIG:case RMAP_LEFT_CONTIG | RMAP_RIGHT_CONTIG:case RMAP_LEFT_CONTIG:case RMAP_RIGHT_CONTIG:/* * These cases are all impossible . 0 );if (error)return error;#undef NEW #undef LEFT#undef RIGHT#undef PREV/* * Find an extent in the rmap btree and unmap it . For rmap extent types that * can overlap ( data fork rmaps on reflink filesystems ) we must be careful * that the prev / next records in the btree might belong to another owner . * Therefore we must use delete + insert to alter any of the key fields . * * For every other situation there can only be one owner for a given extent , * so we can call the regular _ free function . STATIC int struct xfs_btree_cur *cur,bool unwritten,const struct xfs_owner_info *oinfo)struct xfs_mount *mp = cur->bc_mp;struct xfs_rmap_irec ltrec;int error = 0 ;int i;unsigned int flags;if (unwritten)/* * We should always have a left record because there ' s a static record * for the AG headers at rm_startblock = = 0 created by mkfs / growfs that * will not ever be removed from the tree . if (error)goto out_error;if (XFS_IS_CORRUPT(mp, i != 1 )) {goto out_error;/* Make sure the extent we found covers the entire freeing range. */ if (XFS_IS_CORRUPT(mp,goto out_error;/* Make sure the owner matches what we expect to find in the tree. */ if (XFS_IS_CORRUPT(mp, owner != ltrec.rm_owner)) {goto out_error;/* Make sure the unwritten flag matches. */ if (XFS_IS_CORRUPT(mp,goto out_error;/* Check the offset. */ if (XFS_IS_CORRUPT(mp, ltrec.rm_offset > offset)) {goto out_error;if (XFS_IS_CORRUPT(mp, offset > ltoff + ltrec.rm_blockcount)) {goto out_error;if (ltrec.rm_startblock == bno && ltrec.rm_blockcount == len) {/* Exact match, simply remove the record from rmap tree. */ if (error)goto out_error;else if (ltrec.rm_startblock == bno) {/* * Overlap left hand side of extent : move the start , trim the * length and update the current record . * * ltbno ltlen * Orig : | oooooooooooooooooooo | * Freeing : | fffffffff | * Result : | rrrrrrrrrr | * bno len /* Delete prev rmap. */ if (error)goto out_error;/* Add an rmap at the new offset. */ if (error)goto out_error;else if (ltrec.rm_startblock + ltrec.rm_blockcount == bno + len) {/* * Overlap right hand side of extent : trim the length and * update the current record . * * ltbno ltlen * Orig : | oooooooooooooooooooo | * Freeing : | fffffffff | * Result : | rrrrrrrrrr | * bno len if (error)goto out_error;if (XFS_IS_CORRUPT(mp, i != 1 )) {goto out_error;if (error)goto out_error;else {/* * Overlap middle of extent : trim the length of the existing * record to the length of the new left - extent size , increment * the insertion position so we can insert a new record * containing the remaining right - extent space . * * ltbno ltlen * Orig : | oooooooooooooooooooo | * Freeing : | fffffffff | * Result : | rrrrr | | rrrr | * bno len /* Shrink the left side of the rmap */ if (error)goto out_error;if (XFS_IS_CORRUPT(mp, i != 1 )) {goto out_error;if (error)goto out_error;/* Add an rmap at the new offset */ if (error)goto out_error;if (error)return error;/* * Find an extent in the rmap btree and map it . For rmap extent types that * can overlap ( data fork rmaps on reflink filesystems ) we must be careful * that the prev / next records in the btree might belong to another owner . * Therefore we must use delete + insert to alter any of the key fields . * * For every other situation there can only be one owner for a given extent , * so we can call the regular _ alloc function . STATIC int struct xfs_btree_cur *cur,bool unwritten,const struct xfs_owner_info *oinfo)struct xfs_mount *mp = cur->bc_mp;struct xfs_rmap_irec ltrec;struct xfs_rmap_irec gtrec;int have_gt;int have_lt;int error = 0 ;int i;unsigned int flags = 0 ;if (unwritten)/* Is there a left record that abuts our range? */ if (error)goto out_error;if (have_lt &&0 ;/* Is there a right record that abuts our range? */ if (error)goto out_error;if (have_gt) {if (error)goto out_error;if (XFS_IS_CORRUPT(mp, have_gt != 1 )) {goto out_error;if (!xfs_rmap_is_mergeable(>rec, owner, flags))0 ;if (have_lt &&/* * Left edge contiguous , merge into left record . * * ltbno ltlen * orig : | ooooooooo | * adding : | aaaaaaaaa | * result : | rrrrrrrrrrrrrrrrrrr | * bno len if (have_gt &&/* * Right edge also contiguous , delete right record * and merge into left record . * * ltbno ltlen gtbno gtlen * orig : | ooooooooo | | ooooooooo | * adding : | aaaaaaaaa | * result : | rrrrrrrrrrrrrrrrrrrrrrrrrrrrr | if (error)goto out_error;/* Point the cursor back to the left record and update. */ if (error)goto out_error;if (XFS_IS_CORRUPT(mp, i != 1 )) {goto out_error;if (error)goto out_error;else if (have_gt &&/* * Right edge contiguous , merge into right record . * * gtbno gtlen * Orig : | ooooooooo | * adding : | aaaaaaaaa | * Result : | rrrrrrrrrrrrrrrrrrr | * bno len /* Delete the old record. */ if (error)goto out_error;/* Move the start and re-add it. */ if (error)goto out_error;else {/* * No contiguous edge with identical owner , insert * new record at current cursor position . if (error)goto out_error;if (error)return error;/* Insert a raw rmap into the rmapbt. */ int struct xfs_btree_cur *cur,struct xfs_rmap_irec *rmap)struct xfs_owner_info oinfo;if ((rmap->rm_flags & (XFS_RMAP_ATTR_FORK | XFS_RMAP_BMBT_BLOCK |return xfs_rmap_map(cur, rmap->rm_startblock,return xfs_rmap_map_shared(cur, rmap->rm_startblock,struct xfs_rmap_query_range_info {void *priv;/* Format btree record and pass to our callback. */ STATIC int struct xfs_btree_cur *cur,const union xfs_btree_rec *rec,void *priv)struct xfs_rmap_query_range_info *query = priv;struct xfs_rmap_irec irec;if (!fa)if (fa)return xfs_rmap_complain_bad_rec(cur, fa, &irec);return query->fn(cur, &irec, query->priv);/* Find all rmaps between two keys. */ int struct xfs_btree_cur *cur,const struct xfs_rmap_irec *low_rec,const struct xfs_rmap_irec *high_rec,void *priv)union xfs_btree_irec low_brec = { .r = *low_rec };union xfs_btree_irec high_brec = { .r = *high_rec };struct xfs_rmap_query_range_info query = { .priv = priv, .fn = fn };return xfs_btree_query_range(cur, &low_brec, &high_brec,/* Find all rmaps. */ int struct xfs_btree_cur *cur,void *priv)struct xfs_rmap_query_range_info query;return xfs_btree_query_all(cur, xfs_rmap_query_range_helper, &query);/* Commit an rmap operation into the ondisk tree. */ int struct xfs_btree_cur *rcur,enum xfs_rmap_intent_type op,const struct xfs_owner_info *oinfo,bool unwritten)switch (op) {case XFS_RMAP_ALLOC:case XFS_RMAP_MAP:return xfs_rmap_map(rcur, bno, len, unwritten, oinfo);case XFS_RMAP_MAP_SHARED:return xfs_rmap_map_shared(rcur, bno, len, unwritten, oinfo);case XFS_RMAP_FREE:case XFS_RMAP_UNMAP:return xfs_rmap_unmap(rcur, bno, len, unwritten, oinfo);case XFS_RMAP_UNMAP_SHARED:return xfs_rmap_unmap_shared(rcur, bno, len, unwritten, oinfo);case XFS_RMAP_CONVERT:return xfs_rmap_convert(rcur, bno, len, !unwritten, oinfo);case XFS_RMAP_CONVERT_SHARED:return xfs_rmap_convert_shared(rcur, bno, len, !unwritten,default :0 );return -EFSCORRUPTED;static int struct xfs_trans *tp,struct xfs_rmap_intent *ri,struct xfs_btree_cur **pcur)struct xfs_perag *pag = to_perag(ri->ri_group);struct xfs_buf *agbp = NULL;int error;/* * Refresh the freelist before we start changing the rmapbt , because a * shape change could cause us to allocate blocks . if (error) {return error;if (XFS_IS_CORRUPT(tp->t_mountp, !agbp)) {return -EFSCORRUPTED;return 0 ;static int struct xfs_trans *tp,struct xfs_rmap_intent *ri,struct xfs_btree_cur **pcur)struct xfs_rtgroup *rtg = to_rtg(ri->ri_group);return 0 ;/* * Process one of the deferred rmap operations . We pass back the * btree cursor to maintain our lock on the rmapbt between calls . * This saves time and eliminates a buffer deadlock between the * superblock and the AGF because we ' ll always grab them in the same * order . int struct xfs_trans *tp,struct xfs_rmap_intent *ri,struct xfs_btree_cur **pcur)struct xfs_owner_info oinfo;struct xfs_mount *mp = tp->t_mountp;bool unwritten;int error = 0 ;if (XFS_TEST_ERROR(false , mp, XFS_ERRTAG_RMAP_FINISH_ONE))return -EIO;/* * If we haven ' t gotten a cursor or the cursor AG doesn ' t match * the startblock , get one now . if (*pcur != NULL && (*pcur)->bc_group != ri->ri_group) {0 );if (*pcur == NULL) {if (ri->ri_group->xg_type == XG_TYPE_RTG)else if (error)return error;if (error)return error;return 0 ;/* * Don ' t defer an rmap if we aren ' t an rmap filesystem . static bool struct xfs_mount *mp,int whichfork)return xfs_has_rmapbt(mp) && whichfork != XFS_COW_FORK;/* * Record a rmap intent ; the list is kept sorted first by AG and then by * increasing age . static void struct xfs_trans *tp,enum xfs_rmap_intent_type type,bool isrt,int whichfork,struct xfs_bmbt_irec *bmap)struct xfs_rmap_intent *ri;/* Map an extent into a file. */ void struct xfs_trans *tp,struct xfs_inode *ip,int whichfork,struct xfs_bmbt_irec *PREV)enum xfs_rmap_intent_type type = XFS_RMAP_MAP;bool isrt = xfs_ifork_is_realtime(ip, whichfork);if (!xfs_rmap_update_is_needed(tp->t_mountp, whichfork))return ;if (whichfork != XFS_ATTR_FORK && xfs_is_reflink_inode(ip))/* Unmap an extent out of a file. */ void struct xfs_trans *tp,struct xfs_inode *ip,int whichfork,struct xfs_bmbt_irec *PREV)enum xfs_rmap_intent_type type = XFS_RMAP_UNMAP;bool isrt = xfs_ifork_is_realtime(ip, whichfork);if (!xfs_rmap_update_is_needed(tp->t_mountp, whichfork))return ;if (whichfork != XFS_ATTR_FORK && xfs_is_reflink_inode(ip))/* * Convert a data fork extent from unwritten to real or vice versa . * * Note that tp can be NULL here as no transaction is used for COW fork * unwritten conversion . void struct xfs_mount *mp,struct xfs_trans *tp,struct xfs_inode *ip,int whichfork,struct xfs_bmbt_irec *PREV)enum xfs_rmap_intent_type type = XFS_RMAP_CONVERT;bool isrt = xfs_ifork_is_realtime(ip, whichfork);if (!xfs_rmap_update_is_needed(mp, whichfork))return ;if (whichfork != XFS_ATTR_FORK && xfs_is_reflink_inode(ip))/* Schedule the creation of an rmap for non-file data. */ void struct xfs_trans *tp,bool isrt,struct xfs_bmbt_irec bmap;if (!xfs_rmap_update_is_needed(tp->t_mountp, XFS_DATA_FORK))return ;0 ;/* Schedule the deletion of an rmap for non-file data. */ void struct xfs_trans *tp,bool isrt,struct xfs_bmbt_irec bmap;if (!xfs_rmap_update_is_needed(tp->t_mountp, XFS_DATA_FORK))return ;0 ;/* Compare rmap records. Returns -1 if a < b, 1 if a > b, and 0 if equal. */ int const struct xfs_rmap_irec *a,const struct xfs_rmap_irec *b)if (a->rm_startblock < b->rm_startblock)return -1 ;else if (a->rm_startblock > b->rm_startblock)return 1 ;else if (a->rm_owner < b->rm_owner)return -1 ;else if (a->rm_owner > b->rm_owner)return 1 ;else if (oa < ob)return -1 ;else if (oa > ob)return 1 ;else return 0 ;/* * Scan the physical storage part of the keyspace of the reverse mapping index * and tell us if the area has no records , is fully mapped by records , or is * partially filled . int struct xfs_btree_cur *cur,enum xbtree_recpacking *outcome)union xfs_btree_key mask = {1 U),union xfs_btree_irec low;union xfs_btree_irec high;0 , sizeof (low));0 xFF, sizeof (high));1 ;return xfs_btree_has_records(cur, &low, &high, &mask, outcome);struct xfs_rmap_ownercount {/* Owner that we're looking for. */ struct xfs_rmap_irec good;/* rmap search keys */ struct xfs_rmap_irec low;struct xfs_rmap_irec high;struct xfs_rmap_matches *results;/* Stop early if we find a nonmatch? */ bool stop_on_nonmatch;/* Does this rmap represent space that can have multiple owners? */ static inline bool struct xfs_mount *mp,const struct xfs_rmap_irec *rmap)if (!xfs_has_reflink(mp))return false ;if (XFS_RMAP_NON_INODE_OWNER(rmap->rm_owner))return false ;if (rmap->rm_flags & (XFS_RMAP_ATTR_FORK |return false ;return true ;static inline void struct xfs_rmap_ownercount *roc,const struct xfs_owner_info *oinfo,struct xfs_rmap_matches *results)0 , sizeof (*roc));0 xFF, sizeof (roc->high));1 ;0 , sizeof (*results));if (oinfo->oi_flags & XFS_OWNER_INFO_ATTR_FORK)if (oinfo->oi_flags & XFS_OWNER_INFO_BMBT_BLOCK)/* Figure out if this is a match for the owner. */ STATIC int struct xfs_btree_cur *cur,const struct xfs_rmap_irec *rec,void *priv)struct xfs_rmap_ownercount *roc = priv;struct xfs_rmap_irec check = *rec;unsigned int keyflags;bool filedata;/* Trim the part of check that comes before the comparison range. */ if (delta > 0 ) {if (filedata)/* Trim the part of check that comes after the comparison range. */ if (delta > 0 )/* Don't care about unwritten status for establishing ownership. */ if (check.rm_startblock == roc->good.rm_startblock &&else {if (xfs_rmap_shareable(cur->bc_mp, &roc->good) ^if (roc->results->non_owner_matches && roc->stop_on_nonmatch)return -ECANCELED;return 0 ;/* Count the number of owners and non-owners of this range of blocks. */ int struct xfs_btree_cur *cur,const struct xfs_owner_info *oinfo,struct xfs_rmap_matches *results)struct xfs_rmap_ownercount roc;int error;if (error)return error;/* * There can ' t be any non - owner rmaps that conflict with the given * owner if we didn ' t find any rmaps matching the owner . if (!results->matches)0 ;return 0 ;/* * Given an extent and some owner info , can we find records overlapping * the extent whose owner info does not match the given owner ? int struct xfs_btree_cur *cur,const struct xfs_owner_info *oinfo,bool *has_other)struct xfs_rmap_matches res;struct xfs_rmap_ownercount roc;int error;true ;if (error == -ECANCELED) {true ;return 0 ;if (error)return error;false ;return 0 ;const struct xfs_owner_info XFS_RMAP_OINFO_SKIP_UPDATE = {const struct xfs_owner_info XFS_RMAP_OINFO_ANY_OWNER = {const struct xfs_owner_info XFS_RMAP_OINFO_FS = {const struct xfs_owner_info XFS_RMAP_OINFO_LOG = {const struct xfs_owner_info XFS_RMAP_OINFO_AG = {const struct xfs_owner_info XFS_RMAP_OINFO_INOBT = {const struct xfs_owner_info XFS_RMAP_OINFO_INODES = {const struct xfs_owner_info XFS_RMAP_OINFO_REFC = {const struct xfs_owner_info XFS_RMAP_OINFO_COW = {int __initvoid )"xfs_rmap_intent" ,sizeof (struct xfs_rmap_intent),0 , 0 , NULL);return xfs_rmap_intent_cache != NULL ? 0 : -ENOMEM;void void )
Messung V0.5 in Prozent C=96 H=81 G=88
¤ Die Informationen auf dieser Webseite wurden
nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit,
noch Qualität der bereit gestellten Informationen zugesichert.0.112Bemerkung:
(vorverarbeitet am 2026-09-29)
¤ *Bot Zugriff
