130f712c9SDave Chinner /* 230f712c9SDave Chinner * Copyright (c) 2000-2006 Silicon Graphics, Inc. 330f712c9SDave Chinner * All Rights Reserved. 430f712c9SDave Chinner * 530f712c9SDave Chinner * This program is free software; you can redistribute it and/or 630f712c9SDave Chinner * modify it under the terms of the GNU General Public License as 730f712c9SDave Chinner * published by the Free Software Foundation. 830f712c9SDave Chinner * 930f712c9SDave Chinner * This program is distributed in the hope that it would be useful, 1030f712c9SDave Chinner * but WITHOUT ANY WARRANTY; without even the implied warranty of 1130f712c9SDave Chinner * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 1230f712c9SDave Chinner * GNU General Public License for more details. 1330f712c9SDave Chinner * 1430f712c9SDave Chinner * You should have received a copy of the GNU General Public License 1530f712c9SDave Chinner * along with this program; if not, write the Free Software Foundation, 1630f712c9SDave Chinner * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA 1730f712c9SDave Chinner */ 1830f712c9SDave Chinner #include "xfs.h" 1930f712c9SDave Chinner #include "xfs_fs.h" 2030f712c9SDave Chinner #include "xfs_shared.h" 2130f712c9SDave Chinner #include "xfs_format.h" 2230f712c9SDave Chinner #include "xfs_log_format.h" 2330f712c9SDave Chinner #include "xfs_trans_resv.h" 2430f712c9SDave Chinner #include "xfs_bit.h" 2530f712c9SDave Chinner #include "xfs_sb.h" 2630f712c9SDave Chinner #include "xfs_mount.h" 273ab78df2SDarrick J. Wong #include "xfs_defer.h" 2830f712c9SDave Chinner #include "xfs_da_format.h" 2930f712c9SDave Chinner #include "xfs_da_btree.h" 3030f712c9SDave Chinner #include "xfs_dir2.h" 3130f712c9SDave Chinner #include "xfs_inode.h" 3230f712c9SDave Chinner #include "xfs_btree.h" 3330f712c9SDave Chinner #include "xfs_trans.h" 3430f712c9SDave Chinner #include "xfs_inode_item.h" 3530f712c9SDave Chinner #include "xfs_extfree_item.h" 3630f712c9SDave Chinner #include "xfs_alloc.h" 3730f712c9SDave Chinner #include "xfs_bmap.h" 3830f712c9SDave Chinner #include "xfs_bmap_util.h" 3930f712c9SDave Chinner #include "xfs_bmap_btree.h" 4030f712c9SDave Chinner #include "xfs_rtalloc.h" 4130f712c9SDave Chinner #include "xfs_error.h" 4230f712c9SDave Chinner #include "xfs_quota.h" 4330f712c9SDave Chinner #include "xfs_trans_space.h" 4430f712c9SDave Chinner #include "xfs_buf_item.h" 4530f712c9SDave Chinner #include "xfs_trace.h" 4630f712c9SDave Chinner #include "xfs_symlink.h" 4730f712c9SDave Chinner #include "xfs_attr_leaf.h" 4830f712c9SDave Chinner #include "xfs_filestream.h" 49340785ccSDarrick J. Wong #include "xfs_rmap.h" 503fd129b6SDarrick J. Wong #include "xfs_ag_resv.h" 5162aab20fSDarrick J. Wong #include "xfs_refcount.h" 52974ae922SBrian Foster #include "xfs_icache.h" 5330f712c9SDave Chinner 5430f712c9SDave Chinner 5530f712c9SDave Chinner kmem_zone_t *xfs_bmap_free_item_zone; 5630f712c9SDave Chinner 5730f712c9SDave Chinner /* 5830f712c9SDave Chinner * Miscellaneous helper functions 5930f712c9SDave Chinner */ 6030f712c9SDave Chinner 6130f712c9SDave Chinner /* 6230f712c9SDave Chinner * Compute and fill in the value of the maximum depth of a bmap btree 6330f712c9SDave Chinner * in this filesystem. Done once, during mount. 6430f712c9SDave Chinner */ 6530f712c9SDave Chinner void 6630f712c9SDave Chinner xfs_bmap_compute_maxlevels( 6730f712c9SDave Chinner xfs_mount_t *mp, /* file system mount structure */ 6830f712c9SDave Chinner int whichfork) /* data or attr fork */ 6930f712c9SDave Chinner { 7030f712c9SDave Chinner int level; /* btree level */ 7130f712c9SDave Chinner uint maxblocks; /* max blocks at this level */ 7230f712c9SDave Chinner uint maxleafents; /* max leaf entries possible */ 7330f712c9SDave Chinner int maxrootrecs; /* max records in root block */ 7430f712c9SDave Chinner int minleafrecs; /* min records in leaf block */ 7530f712c9SDave Chinner int minnoderecs; /* min records in node block */ 7630f712c9SDave Chinner int sz; /* root block size */ 7730f712c9SDave Chinner 7830f712c9SDave Chinner /* 7930f712c9SDave Chinner * The maximum number of extents in a file, hence the maximum 8030f712c9SDave Chinner * number of leaf entries, is controlled by the type of di_nextents 8130f712c9SDave Chinner * (a signed 32-bit number, xfs_extnum_t), or by di_anextents 8230f712c9SDave Chinner * (a signed 16-bit number, xfs_aextnum_t). 8330f712c9SDave Chinner * 8430f712c9SDave Chinner * Note that we can no longer assume that if we are in ATTR1 that 8530f712c9SDave Chinner * the fork offset of all the inodes will be 8630f712c9SDave Chinner * (xfs_default_attroffset(ip) >> 3) because we could have mounted 8730f712c9SDave Chinner * with ATTR2 and then mounted back with ATTR1, keeping the 8830f712c9SDave Chinner * di_forkoff's fixed but probably at various positions. Therefore, 8930f712c9SDave Chinner * for both ATTR1 and ATTR2 we have to assume the worst case scenario 9030f712c9SDave Chinner * of a minimum size available. 9130f712c9SDave Chinner */ 9230f712c9SDave Chinner if (whichfork == XFS_DATA_FORK) { 9330f712c9SDave Chinner maxleafents = MAXEXTNUM; 9430f712c9SDave Chinner sz = XFS_BMDR_SPACE_CALC(MINDBTPTRS); 9530f712c9SDave Chinner } else { 9630f712c9SDave Chinner maxleafents = MAXAEXTNUM; 9730f712c9SDave Chinner sz = XFS_BMDR_SPACE_CALC(MINABTPTRS); 9830f712c9SDave Chinner } 9930f712c9SDave Chinner maxrootrecs = xfs_bmdr_maxrecs(sz, 0); 10030f712c9SDave Chinner minleafrecs = mp->m_bmap_dmnr[0]; 10130f712c9SDave Chinner minnoderecs = mp->m_bmap_dmnr[1]; 10230f712c9SDave Chinner maxblocks = (maxleafents + minleafrecs - 1) / minleafrecs; 10330f712c9SDave Chinner for (level = 1; maxblocks > 1; level++) { 10430f712c9SDave Chinner if (maxblocks <= maxrootrecs) 10530f712c9SDave Chinner maxblocks = 1; 10630f712c9SDave Chinner else 10730f712c9SDave Chinner maxblocks = (maxblocks + minnoderecs - 1) / minnoderecs; 10830f712c9SDave Chinner } 10930f712c9SDave Chinner mp->m_bm_maxlevels[whichfork] = level; 11030f712c9SDave Chinner } 11130f712c9SDave Chinner 11230f712c9SDave Chinner STATIC int /* error */ 11330f712c9SDave Chinner xfs_bmbt_lookup_eq( 11430f712c9SDave Chinner struct xfs_btree_cur *cur, 11530f712c9SDave Chinner xfs_fileoff_t off, 11630f712c9SDave Chinner xfs_fsblock_t bno, 11730f712c9SDave Chinner xfs_filblks_t len, 11830f712c9SDave Chinner int *stat) /* success/failure */ 11930f712c9SDave Chinner { 12030f712c9SDave Chinner cur->bc_rec.b.br_startoff = off; 12130f712c9SDave Chinner cur->bc_rec.b.br_startblock = bno; 12230f712c9SDave Chinner cur->bc_rec.b.br_blockcount = len; 12330f712c9SDave Chinner return xfs_btree_lookup(cur, XFS_LOOKUP_EQ, stat); 12430f712c9SDave Chinner } 12530f712c9SDave Chinner 12630f712c9SDave Chinner STATIC int /* error */ 12730f712c9SDave Chinner xfs_bmbt_lookup_ge( 12830f712c9SDave Chinner struct xfs_btree_cur *cur, 12930f712c9SDave Chinner xfs_fileoff_t off, 13030f712c9SDave Chinner xfs_fsblock_t bno, 13130f712c9SDave Chinner xfs_filblks_t len, 13230f712c9SDave Chinner int *stat) /* success/failure */ 13330f712c9SDave Chinner { 13430f712c9SDave Chinner cur->bc_rec.b.br_startoff = off; 13530f712c9SDave Chinner cur->bc_rec.b.br_startblock = bno; 13630f712c9SDave Chinner cur->bc_rec.b.br_blockcount = len; 13730f712c9SDave Chinner return xfs_btree_lookup(cur, XFS_LOOKUP_GE, stat); 13830f712c9SDave Chinner } 13930f712c9SDave Chinner 14030f712c9SDave Chinner /* 14130f712c9SDave Chinner * Check if the inode needs to be converted to btree format. 14230f712c9SDave Chinner */ 14330f712c9SDave Chinner static inline bool xfs_bmap_needs_btree(struct xfs_inode *ip, int whichfork) 14430f712c9SDave Chinner { 14560b4984fSDarrick J. Wong return whichfork != XFS_COW_FORK && 14660b4984fSDarrick J. Wong XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_EXTENTS && 14730f712c9SDave Chinner XFS_IFORK_NEXTENTS(ip, whichfork) > 14830f712c9SDave Chinner XFS_IFORK_MAXEXT(ip, whichfork); 14930f712c9SDave Chinner } 15030f712c9SDave Chinner 15130f712c9SDave Chinner /* 15230f712c9SDave Chinner * Check if the inode should be converted to extent format. 15330f712c9SDave Chinner */ 15430f712c9SDave Chinner static inline bool xfs_bmap_wants_extents(struct xfs_inode *ip, int whichfork) 15530f712c9SDave Chinner { 15660b4984fSDarrick J. Wong return whichfork != XFS_COW_FORK && 15760b4984fSDarrick J. Wong XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_BTREE && 15830f712c9SDave Chinner XFS_IFORK_NEXTENTS(ip, whichfork) <= 15930f712c9SDave Chinner XFS_IFORK_MAXEXT(ip, whichfork); 16030f712c9SDave Chinner } 16130f712c9SDave Chinner 16230f712c9SDave Chinner /* 16330f712c9SDave Chinner * Update the record referred to by cur to the value given 16430f712c9SDave Chinner * by [off, bno, len, state]. 16530f712c9SDave Chinner * This either works (return 0) or gets an EFSCORRUPTED error. 16630f712c9SDave Chinner */ 16730f712c9SDave Chinner STATIC int 16830f712c9SDave Chinner xfs_bmbt_update( 16930f712c9SDave Chinner struct xfs_btree_cur *cur, 17030f712c9SDave Chinner xfs_fileoff_t off, 17130f712c9SDave Chinner xfs_fsblock_t bno, 17230f712c9SDave Chinner xfs_filblks_t len, 17330f712c9SDave Chinner xfs_exntst_t state) 17430f712c9SDave Chinner { 17530f712c9SDave Chinner union xfs_btree_rec rec; 17630f712c9SDave Chinner 17730f712c9SDave Chinner xfs_bmbt_disk_set_allf(&rec.bmbt, off, bno, len, state); 17830f712c9SDave Chinner return xfs_btree_update(cur, &rec); 17930f712c9SDave Chinner } 18030f712c9SDave Chinner 18130f712c9SDave Chinner /* 18230f712c9SDave Chinner * Compute the worst-case number of indirect blocks that will be used 18330f712c9SDave Chinner * for ip's delayed extent of length "len". 18430f712c9SDave Chinner */ 18530f712c9SDave Chinner STATIC xfs_filblks_t 18630f712c9SDave Chinner xfs_bmap_worst_indlen( 18730f712c9SDave Chinner xfs_inode_t *ip, /* incore inode pointer */ 18830f712c9SDave Chinner xfs_filblks_t len) /* delayed extent length */ 18930f712c9SDave Chinner { 19030f712c9SDave Chinner int level; /* btree level number */ 19130f712c9SDave Chinner int maxrecs; /* maximum record count at this level */ 19230f712c9SDave Chinner xfs_mount_t *mp; /* mount structure */ 19330f712c9SDave Chinner xfs_filblks_t rval; /* return value */ 19430f712c9SDave Chinner 19530f712c9SDave Chinner mp = ip->i_mount; 19630f712c9SDave Chinner maxrecs = mp->m_bmap_dmxr[0]; 19730f712c9SDave Chinner for (level = 0, rval = 0; 19830f712c9SDave Chinner level < XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK); 19930f712c9SDave Chinner level++) { 20030f712c9SDave Chinner len += maxrecs - 1; 20130f712c9SDave Chinner do_div(len, maxrecs); 20230f712c9SDave Chinner rval += len; 2035e5c943cSDarrick J. Wong if (len == 1) 2045e5c943cSDarrick J. Wong return rval + XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK) - 20530f712c9SDave Chinner level - 1; 20630f712c9SDave Chinner if (level == 0) 20730f712c9SDave Chinner maxrecs = mp->m_bmap_dmxr[1]; 20830f712c9SDave Chinner } 20930f712c9SDave Chinner return rval; 21030f712c9SDave Chinner } 21130f712c9SDave Chinner 21230f712c9SDave Chinner /* 21330f712c9SDave Chinner * Calculate the default attribute fork offset for newly created inodes. 21430f712c9SDave Chinner */ 21530f712c9SDave Chinner uint 21630f712c9SDave Chinner xfs_default_attroffset( 21730f712c9SDave Chinner struct xfs_inode *ip) 21830f712c9SDave Chinner { 21930f712c9SDave Chinner struct xfs_mount *mp = ip->i_mount; 22030f712c9SDave Chinner uint offset; 22130f712c9SDave Chinner 22230f712c9SDave Chinner if (mp->m_sb.sb_inodesize == 256) { 22330f712c9SDave Chinner offset = XFS_LITINO(mp, ip->i_d.di_version) - 22430f712c9SDave Chinner XFS_BMDR_SPACE_CALC(MINABTPTRS); 22530f712c9SDave Chinner } else { 22630f712c9SDave Chinner offset = XFS_BMDR_SPACE_CALC(6 * MINABTPTRS); 22730f712c9SDave Chinner } 22830f712c9SDave Chinner 22930f712c9SDave Chinner ASSERT(offset < XFS_LITINO(mp, ip->i_d.di_version)); 23030f712c9SDave Chinner return offset; 23130f712c9SDave Chinner } 23230f712c9SDave Chinner 23330f712c9SDave Chinner /* 23430f712c9SDave Chinner * Helper routine to reset inode di_forkoff field when switching 23530f712c9SDave Chinner * attribute fork from local to extent format - we reset it where 23630f712c9SDave Chinner * possible to make space available for inline data fork extents. 23730f712c9SDave Chinner */ 23830f712c9SDave Chinner STATIC void 23930f712c9SDave Chinner xfs_bmap_forkoff_reset( 24030f712c9SDave Chinner xfs_inode_t *ip, 24130f712c9SDave Chinner int whichfork) 24230f712c9SDave Chinner { 24330f712c9SDave Chinner if (whichfork == XFS_ATTR_FORK && 24430f712c9SDave Chinner ip->i_d.di_format != XFS_DINODE_FMT_DEV && 24530f712c9SDave Chinner ip->i_d.di_format != XFS_DINODE_FMT_UUID && 24630f712c9SDave Chinner ip->i_d.di_format != XFS_DINODE_FMT_BTREE) { 24730f712c9SDave Chinner uint dfl_forkoff = xfs_default_attroffset(ip) >> 3; 24830f712c9SDave Chinner 24930f712c9SDave Chinner if (dfl_forkoff > ip->i_d.di_forkoff) 25030f712c9SDave Chinner ip->i_d.di_forkoff = dfl_forkoff; 25130f712c9SDave Chinner } 25230f712c9SDave Chinner } 25330f712c9SDave Chinner 25430f712c9SDave Chinner #ifdef DEBUG 25530f712c9SDave Chinner STATIC struct xfs_buf * 25630f712c9SDave Chinner xfs_bmap_get_bp( 25730f712c9SDave Chinner struct xfs_btree_cur *cur, 25830f712c9SDave Chinner xfs_fsblock_t bno) 25930f712c9SDave Chinner { 26030f712c9SDave Chinner struct xfs_log_item_desc *lidp; 26130f712c9SDave Chinner int i; 26230f712c9SDave Chinner 26330f712c9SDave Chinner if (!cur) 26430f712c9SDave Chinner return NULL; 26530f712c9SDave Chinner 26630f712c9SDave Chinner for (i = 0; i < XFS_BTREE_MAXLEVELS; i++) { 26730f712c9SDave Chinner if (!cur->bc_bufs[i]) 26830f712c9SDave Chinner break; 26930f712c9SDave Chinner if (XFS_BUF_ADDR(cur->bc_bufs[i]) == bno) 27030f712c9SDave Chinner return cur->bc_bufs[i]; 27130f712c9SDave Chinner } 27230f712c9SDave Chinner 27330f712c9SDave Chinner /* Chase down all the log items to see if the bp is there */ 27430f712c9SDave Chinner list_for_each_entry(lidp, &cur->bc_tp->t_items, lid_trans) { 27530f712c9SDave Chinner struct xfs_buf_log_item *bip; 27630f712c9SDave Chinner bip = (struct xfs_buf_log_item *)lidp->lid_item; 27730f712c9SDave Chinner if (bip->bli_item.li_type == XFS_LI_BUF && 27830f712c9SDave Chinner XFS_BUF_ADDR(bip->bli_buf) == bno) 27930f712c9SDave Chinner return bip->bli_buf; 28030f712c9SDave Chinner } 28130f712c9SDave Chinner 28230f712c9SDave Chinner return NULL; 28330f712c9SDave Chinner } 28430f712c9SDave Chinner 28530f712c9SDave Chinner STATIC void 28630f712c9SDave Chinner xfs_check_block( 28730f712c9SDave Chinner struct xfs_btree_block *block, 28830f712c9SDave Chinner xfs_mount_t *mp, 28930f712c9SDave Chinner int root, 29030f712c9SDave Chinner short sz) 29130f712c9SDave Chinner { 29230f712c9SDave Chinner int i, j, dmxr; 29330f712c9SDave Chinner __be64 *pp, *thispa; /* pointer to block address */ 29430f712c9SDave Chinner xfs_bmbt_key_t *prevp, *keyp; 29530f712c9SDave Chinner 29630f712c9SDave Chinner ASSERT(be16_to_cpu(block->bb_level) > 0); 29730f712c9SDave Chinner 29830f712c9SDave Chinner prevp = NULL; 29930f712c9SDave Chinner for( i = 1; i <= xfs_btree_get_numrecs(block); i++) { 30030f712c9SDave Chinner dmxr = mp->m_bmap_dmxr[0]; 30130f712c9SDave Chinner keyp = XFS_BMBT_KEY_ADDR(mp, block, i); 30230f712c9SDave Chinner 30330f712c9SDave Chinner if (prevp) { 30430f712c9SDave Chinner ASSERT(be64_to_cpu(prevp->br_startoff) < 30530f712c9SDave Chinner be64_to_cpu(keyp->br_startoff)); 30630f712c9SDave Chinner } 30730f712c9SDave Chinner prevp = keyp; 30830f712c9SDave Chinner 30930f712c9SDave Chinner /* 31030f712c9SDave Chinner * Compare the block numbers to see if there are dups. 31130f712c9SDave Chinner */ 31230f712c9SDave Chinner if (root) 31330f712c9SDave Chinner pp = XFS_BMAP_BROOT_PTR_ADDR(mp, block, i, sz); 31430f712c9SDave Chinner else 31530f712c9SDave Chinner pp = XFS_BMBT_PTR_ADDR(mp, block, i, dmxr); 31630f712c9SDave Chinner 31730f712c9SDave Chinner for (j = i+1; j <= be16_to_cpu(block->bb_numrecs); j++) { 31830f712c9SDave Chinner if (root) 31930f712c9SDave Chinner thispa = XFS_BMAP_BROOT_PTR_ADDR(mp, block, j, sz); 32030f712c9SDave Chinner else 32130f712c9SDave Chinner thispa = XFS_BMBT_PTR_ADDR(mp, block, j, dmxr); 32230f712c9SDave Chinner if (*thispa == *pp) { 32330f712c9SDave Chinner xfs_warn(mp, "%s: thispa(%d) == pp(%d) %Ld", 32430f712c9SDave Chinner __func__, j, i, 32530f712c9SDave Chinner (unsigned long long)be64_to_cpu(*thispa)); 32630f712c9SDave Chinner panic("%s: ptrs are equal in node\n", 32730f712c9SDave Chinner __func__); 32830f712c9SDave Chinner } 32930f712c9SDave Chinner } 33030f712c9SDave Chinner } 33130f712c9SDave Chinner } 33230f712c9SDave Chinner 33330f712c9SDave Chinner /* 33430f712c9SDave Chinner * Check that the extents for the inode ip are in the right order in all 335e3543819SDave Chinner * btree leaves. THis becomes prohibitively expensive for large extent count 336e3543819SDave Chinner * files, so don't bother with inodes that have more than 10,000 extents in 337e3543819SDave Chinner * them. The btree record ordering checks will still be done, so for such large 338e3543819SDave Chinner * bmapbt constructs that is going to catch most corruptions. 33930f712c9SDave Chinner */ 34030f712c9SDave Chinner STATIC void 34130f712c9SDave Chinner xfs_bmap_check_leaf_extents( 34230f712c9SDave Chinner xfs_btree_cur_t *cur, /* btree cursor or null */ 34330f712c9SDave Chinner xfs_inode_t *ip, /* incore inode pointer */ 34430f712c9SDave Chinner int whichfork) /* data or attr fork */ 34530f712c9SDave Chinner { 34630f712c9SDave Chinner struct xfs_btree_block *block; /* current btree block */ 34730f712c9SDave Chinner xfs_fsblock_t bno; /* block # of "block" */ 34830f712c9SDave Chinner xfs_buf_t *bp; /* buffer for "block" */ 34930f712c9SDave Chinner int error; /* error return value */ 35030f712c9SDave Chinner xfs_extnum_t i=0, j; /* index into the extents list */ 35130f712c9SDave Chinner xfs_ifork_t *ifp; /* fork structure */ 35230f712c9SDave Chinner int level; /* btree level, for checking */ 35330f712c9SDave Chinner xfs_mount_t *mp; /* file system mount structure */ 35430f712c9SDave Chinner __be64 *pp; /* pointer to block address */ 35530f712c9SDave Chinner xfs_bmbt_rec_t *ep; /* pointer to current extent */ 35630f712c9SDave Chinner xfs_bmbt_rec_t last = {0, 0}; /* last extent in prev block */ 35730f712c9SDave Chinner xfs_bmbt_rec_t *nextp; /* pointer to next extent */ 35830f712c9SDave Chinner int bp_release = 0; 35930f712c9SDave Chinner 36030f712c9SDave Chinner if (XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE) { 36130f712c9SDave Chinner return; 36230f712c9SDave Chinner } 36330f712c9SDave Chinner 364e3543819SDave Chinner /* skip large extent count inodes */ 365e3543819SDave Chinner if (ip->i_d.di_nextents > 10000) 366e3543819SDave Chinner return; 367e3543819SDave Chinner 36830f712c9SDave Chinner bno = NULLFSBLOCK; 36930f712c9SDave Chinner mp = ip->i_mount; 37030f712c9SDave Chinner ifp = XFS_IFORK_PTR(ip, whichfork); 37130f712c9SDave Chinner block = ifp->if_broot; 37230f712c9SDave Chinner /* 37330f712c9SDave Chinner * Root level must use BMAP_BROOT_PTR_ADDR macro to get ptr out. 37430f712c9SDave Chinner */ 37530f712c9SDave Chinner level = be16_to_cpu(block->bb_level); 37630f712c9SDave Chinner ASSERT(level > 0); 37730f712c9SDave Chinner xfs_check_block(block, mp, 1, ifp->if_broot_bytes); 37830f712c9SDave Chinner pp = XFS_BMAP_BROOT_PTR_ADDR(mp, block, 1, ifp->if_broot_bytes); 37930f712c9SDave Chinner bno = be64_to_cpu(*pp); 38030f712c9SDave Chinner 381d5cf09baSChristoph Hellwig ASSERT(bno != NULLFSBLOCK); 38230f712c9SDave Chinner ASSERT(XFS_FSB_TO_AGNO(mp, bno) < mp->m_sb.sb_agcount); 38330f712c9SDave Chinner ASSERT(XFS_FSB_TO_AGBNO(mp, bno) < mp->m_sb.sb_agblocks); 38430f712c9SDave Chinner 38530f712c9SDave Chinner /* 38630f712c9SDave Chinner * Go down the tree until leaf level is reached, following the first 38730f712c9SDave Chinner * pointer (leftmost) at each level. 38830f712c9SDave Chinner */ 38930f712c9SDave Chinner while (level-- > 0) { 39030f712c9SDave Chinner /* See if buf is in cur first */ 39130f712c9SDave Chinner bp_release = 0; 39230f712c9SDave Chinner bp = xfs_bmap_get_bp(cur, XFS_FSB_TO_DADDR(mp, bno)); 39330f712c9SDave Chinner if (!bp) { 39430f712c9SDave Chinner bp_release = 1; 39530f712c9SDave Chinner error = xfs_btree_read_bufl(mp, NULL, bno, 0, &bp, 39630f712c9SDave Chinner XFS_BMAP_BTREE_REF, 39730f712c9SDave Chinner &xfs_bmbt_buf_ops); 39830f712c9SDave Chinner if (error) 39930f712c9SDave Chinner goto error_norelse; 40030f712c9SDave Chinner } 40130f712c9SDave Chinner block = XFS_BUF_TO_BLOCK(bp); 40230f712c9SDave Chinner if (level == 0) 40330f712c9SDave Chinner break; 40430f712c9SDave Chinner 40530f712c9SDave Chinner /* 40630f712c9SDave Chinner * Check this block for basic sanity (increasing keys and 40730f712c9SDave Chinner * no duplicate blocks). 40830f712c9SDave Chinner */ 40930f712c9SDave Chinner 41030f712c9SDave Chinner xfs_check_block(block, mp, 0, 0); 41130f712c9SDave Chinner pp = XFS_BMBT_PTR_ADDR(mp, block, 1, mp->m_bmap_dmxr[1]); 41230f712c9SDave Chinner bno = be64_to_cpu(*pp); 413c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, 414c29aad41SEric Sandeen XFS_FSB_SANITY_CHECK(mp, bno), error0); 41530f712c9SDave Chinner if (bp_release) { 41630f712c9SDave Chinner bp_release = 0; 41730f712c9SDave Chinner xfs_trans_brelse(NULL, bp); 41830f712c9SDave Chinner } 41930f712c9SDave Chinner } 42030f712c9SDave Chinner 42130f712c9SDave Chinner /* 42230f712c9SDave Chinner * Here with bp and block set to the leftmost leaf node in the tree. 42330f712c9SDave Chinner */ 42430f712c9SDave Chinner i = 0; 42530f712c9SDave Chinner 42630f712c9SDave Chinner /* 42730f712c9SDave Chinner * Loop over all leaf nodes checking that all extents are in the right order. 42830f712c9SDave Chinner */ 42930f712c9SDave Chinner for (;;) { 43030f712c9SDave Chinner xfs_fsblock_t nextbno; 43130f712c9SDave Chinner xfs_extnum_t num_recs; 43230f712c9SDave Chinner 43330f712c9SDave Chinner 43430f712c9SDave Chinner num_recs = xfs_btree_get_numrecs(block); 43530f712c9SDave Chinner 43630f712c9SDave Chinner /* 43730f712c9SDave Chinner * Read-ahead the next leaf block, if any. 43830f712c9SDave Chinner */ 43930f712c9SDave Chinner 44030f712c9SDave Chinner nextbno = be64_to_cpu(block->bb_u.l.bb_rightsib); 44130f712c9SDave Chinner 44230f712c9SDave Chinner /* 44330f712c9SDave Chinner * Check all the extents to make sure they are OK. 44430f712c9SDave Chinner * If we had a previous block, the last entry should 44530f712c9SDave Chinner * conform with the first entry in this one. 44630f712c9SDave Chinner */ 44730f712c9SDave Chinner 44830f712c9SDave Chinner ep = XFS_BMBT_REC_ADDR(mp, block, 1); 44930f712c9SDave Chinner if (i) { 45030f712c9SDave Chinner ASSERT(xfs_bmbt_disk_get_startoff(&last) + 45130f712c9SDave Chinner xfs_bmbt_disk_get_blockcount(&last) <= 45230f712c9SDave Chinner xfs_bmbt_disk_get_startoff(ep)); 45330f712c9SDave Chinner } 45430f712c9SDave Chinner for (j = 1; j < num_recs; j++) { 45530f712c9SDave Chinner nextp = XFS_BMBT_REC_ADDR(mp, block, j + 1); 45630f712c9SDave Chinner ASSERT(xfs_bmbt_disk_get_startoff(ep) + 45730f712c9SDave Chinner xfs_bmbt_disk_get_blockcount(ep) <= 45830f712c9SDave Chinner xfs_bmbt_disk_get_startoff(nextp)); 45930f712c9SDave Chinner ep = nextp; 46030f712c9SDave Chinner } 46130f712c9SDave Chinner 46230f712c9SDave Chinner last = *ep; 46330f712c9SDave Chinner i += num_recs; 46430f712c9SDave Chinner if (bp_release) { 46530f712c9SDave Chinner bp_release = 0; 46630f712c9SDave Chinner xfs_trans_brelse(NULL, bp); 46730f712c9SDave Chinner } 46830f712c9SDave Chinner bno = nextbno; 46930f712c9SDave Chinner /* 47030f712c9SDave Chinner * If we've reached the end, stop. 47130f712c9SDave Chinner */ 47230f712c9SDave Chinner if (bno == NULLFSBLOCK) 47330f712c9SDave Chinner break; 47430f712c9SDave Chinner 47530f712c9SDave Chinner bp_release = 0; 47630f712c9SDave Chinner bp = xfs_bmap_get_bp(cur, XFS_FSB_TO_DADDR(mp, bno)); 47730f712c9SDave Chinner if (!bp) { 47830f712c9SDave Chinner bp_release = 1; 47930f712c9SDave Chinner error = xfs_btree_read_bufl(mp, NULL, bno, 0, &bp, 48030f712c9SDave Chinner XFS_BMAP_BTREE_REF, 48130f712c9SDave Chinner &xfs_bmbt_buf_ops); 48230f712c9SDave Chinner if (error) 48330f712c9SDave Chinner goto error_norelse; 48430f712c9SDave Chinner } 48530f712c9SDave Chinner block = XFS_BUF_TO_BLOCK(bp); 48630f712c9SDave Chinner } 487a5fd276bSLuis de Bethencourt 48830f712c9SDave Chinner return; 48930f712c9SDave Chinner 49030f712c9SDave Chinner error0: 49130f712c9SDave Chinner xfs_warn(mp, "%s: at error0", __func__); 49230f712c9SDave Chinner if (bp_release) 49330f712c9SDave Chinner xfs_trans_brelse(NULL, bp); 49430f712c9SDave Chinner error_norelse: 49530f712c9SDave Chinner xfs_warn(mp, "%s: BAD after btree leaves for %d extents", 49630f712c9SDave Chinner __func__, i); 49730f712c9SDave Chinner panic("%s: CORRUPTED BTREE OR SOMETHING", __func__); 49830f712c9SDave Chinner return; 49930f712c9SDave Chinner } 50030f712c9SDave Chinner 50130f712c9SDave Chinner /* 50230f712c9SDave Chinner * Add bmap trace insert entries for all the contents of the extent records. 50330f712c9SDave Chinner */ 50430f712c9SDave Chinner void 50530f712c9SDave Chinner xfs_bmap_trace_exlist( 50630f712c9SDave Chinner xfs_inode_t *ip, /* incore inode pointer */ 50730f712c9SDave Chinner xfs_extnum_t cnt, /* count of entries in the list */ 508c44a1f22SEric Sandeen int whichfork, /* data or attr or cow fork */ 50930f712c9SDave Chinner unsigned long caller_ip) 51030f712c9SDave Chinner { 51130f712c9SDave Chinner xfs_extnum_t idx; /* extent record index */ 51230f712c9SDave Chinner xfs_ifork_t *ifp; /* inode fork pointer */ 51330f712c9SDave Chinner int state = 0; 51430f712c9SDave Chinner 51530f712c9SDave Chinner if (whichfork == XFS_ATTR_FORK) 51630f712c9SDave Chinner state |= BMAP_ATTRFORK; 517c44a1f22SEric Sandeen else if (whichfork == XFS_COW_FORK) 518c44a1f22SEric Sandeen state |= BMAP_COWFORK; 51930f712c9SDave Chinner 52030f712c9SDave Chinner ifp = XFS_IFORK_PTR(ip, whichfork); 5215d829300SEric Sandeen ASSERT(cnt == xfs_iext_count(ifp)); 52230f712c9SDave Chinner for (idx = 0; idx < cnt; idx++) 5237710517fSEric Sandeen trace_xfs_extlist(ip, idx, state, caller_ip); 52430f712c9SDave Chinner } 52530f712c9SDave Chinner 52630f712c9SDave Chinner /* 52730f712c9SDave Chinner * Validate that the bmbt_irecs being returned from bmapi are valid 52830f712c9SDave Chinner * given the caller's original parameters. Specifically check the 52930f712c9SDave Chinner * ranges of the returned irecs to ensure that they only extend beyond 53030f712c9SDave Chinner * the given parameters if the XFS_BMAPI_ENTIRE flag was set. 53130f712c9SDave Chinner */ 53230f712c9SDave Chinner STATIC void 53330f712c9SDave Chinner xfs_bmap_validate_ret( 53430f712c9SDave Chinner xfs_fileoff_t bno, 53530f712c9SDave Chinner xfs_filblks_t len, 53630f712c9SDave Chinner int flags, 53730f712c9SDave Chinner xfs_bmbt_irec_t *mval, 53830f712c9SDave Chinner int nmap, 53930f712c9SDave Chinner int ret_nmap) 54030f712c9SDave Chinner { 54130f712c9SDave Chinner int i; /* index to map values */ 54230f712c9SDave Chinner 54330f712c9SDave Chinner ASSERT(ret_nmap <= nmap); 54430f712c9SDave Chinner 54530f712c9SDave Chinner for (i = 0; i < ret_nmap; i++) { 54630f712c9SDave Chinner ASSERT(mval[i].br_blockcount > 0); 54730f712c9SDave Chinner if (!(flags & XFS_BMAPI_ENTIRE)) { 54830f712c9SDave Chinner ASSERT(mval[i].br_startoff >= bno); 54930f712c9SDave Chinner ASSERT(mval[i].br_blockcount <= len); 55030f712c9SDave Chinner ASSERT(mval[i].br_startoff + mval[i].br_blockcount <= 55130f712c9SDave Chinner bno + len); 55230f712c9SDave Chinner } else { 55330f712c9SDave Chinner ASSERT(mval[i].br_startoff < bno + len); 55430f712c9SDave Chinner ASSERT(mval[i].br_startoff + mval[i].br_blockcount > 55530f712c9SDave Chinner bno); 55630f712c9SDave Chinner } 55730f712c9SDave Chinner ASSERT(i == 0 || 55830f712c9SDave Chinner mval[i - 1].br_startoff + mval[i - 1].br_blockcount == 55930f712c9SDave Chinner mval[i].br_startoff); 56030f712c9SDave Chinner ASSERT(mval[i].br_startblock != DELAYSTARTBLOCK && 56130f712c9SDave Chinner mval[i].br_startblock != HOLESTARTBLOCK); 56230f712c9SDave Chinner ASSERT(mval[i].br_state == XFS_EXT_NORM || 56330f712c9SDave Chinner mval[i].br_state == XFS_EXT_UNWRITTEN); 56430f712c9SDave Chinner } 56530f712c9SDave Chinner } 56630f712c9SDave Chinner 56730f712c9SDave Chinner #else 56830f712c9SDave Chinner #define xfs_bmap_check_leaf_extents(cur, ip, whichfork) do { } while (0) 5697bf7a193SDarrick J. Wong #define xfs_bmap_validate_ret(bno,len,flags,mval,onmap,nmap) do { } while (0) 57030f712c9SDave Chinner #endif /* DEBUG */ 57130f712c9SDave Chinner 57230f712c9SDave Chinner /* 57330f712c9SDave Chinner * bmap free list manipulation functions 57430f712c9SDave Chinner */ 57530f712c9SDave Chinner 57630f712c9SDave Chinner /* 57730f712c9SDave Chinner * Add the extent to the list of extents to be free at transaction end. 57830f712c9SDave Chinner * The list is maintained sorted (by block number). 57930f712c9SDave Chinner */ 58030f712c9SDave Chinner void 58130f712c9SDave Chinner xfs_bmap_add_free( 582340785ccSDarrick J. Wong struct xfs_mount *mp, 583340785ccSDarrick J. Wong struct xfs_defer_ops *dfops, 584340785ccSDarrick J. Wong xfs_fsblock_t bno, 585340785ccSDarrick J. Wong xfs_filblks_t len, 586340785ccSDarrick J. Wong struct xfs_owner_info *oinfo) 58730f712c9SDave Chinner { 588310a75a3SDarrick J. Wong struct xfs_extent_free_item *new; /* new element */ 58930f712c9SDave Chinner #ifdef DEBUG 59030f712c9SDave Chinner xfs_agnumber_t agno; 59130f712c9SDave Chinner xfs_agblock_t agbno; 59230f712c9SDave Chinner 59330f712c9SDave Chinner ASSERT(bno != NULLFSBLOCK); 59430f712c9SDave Chinner ASSERT(len > 0); 59530f712c9SDave Chinner ASSERT(len <= MAXEXTLEN); 59630f712c9SDave Chinner ASSERT(!isnullstartblock(bno)); 59730f712c9SDave Chinner agno = XFS_FSB_TO_AGNO(mp, bno); 59830f712c9SDave Chinner agbno = XFS_FSB_TO_AGBNO(mp, bno); 59930f712c9SDave Chinner ASSERT(agno < mp->m_sb.sb_agcount); 60030f712c9SDave Chinner ASSERT(agbno < mp->m_sb.sb_agblocks); 60130f712c9SDave Chinner ASSERT(len < mp->m_sb.sb_agblocks); 60230f712c9SDave Chinner ASSERT(agbno + len <= mp->m_sb.sb_agblocks); 60330f712c9SDave Chinner #endif 60430f712c9SDave Chinner ASSERT(xfs_bmap_free_item_zone != NULL); 605340785ccSDarrick J. Wong 60630f712c9SDave Chinner new = kmem_zone_alloc(xfs_bmap_free_item_zone, KM_SLEEP); 607310a75a3SDarrick J. Wong new->xefi_startblock = bno; 608310a75a3SDarrick J. Wong new->xefi_blockcount = (xfs_extlen_t)len; 609340785ccSDarrick J. Wong if (oinfo) 610340785ccSDarrick J. Wong new->xefi_oinfo = *oinfo; 611340785ccSDarrick J. Wong else 612340785ccSDarrick J. Wong xfs_rmap_skip_owner_update(&new->xefi_oinfo); 613ba9e7802SDarrick J. Wong trace_xfs_bmap_free_defer(mp, XFS_FSB_TO_AGNO(mp, bno), 0, 614ba9e7802SDarrick J. Wong XFS_FSB_TO_AGBNO(mp, bno), len); 6152c3234d1SDarrick J. Wong xfs_defer_add(dfops, XFS_DEFER_OPS_TYPE_FREE, &new->xefi_list); 61630f712c9SDave Chinner } 61730f712c9SDave Chinner 61830f712c9SDave Chinner /* 61930f712c9SDave Chinner * Inode fork format manipulation functions 62030f712c9SDave Chinner */ 62130f712c9SDave Chinner 62230f712c9SDave Chinner /* 62330f712c9SDave Chinner * Transform a btree format file with only one leaf node, where the 62430f712c9SDave Chinner * extents list will fit in the inode, into an extents format file. 62530f712c9SDave Chinner * Since the file extents are already in-core, all we have to do is 62630f712c9SDave Chinner * give up the space for the btree root and pitch the leaf block. 62730f712c9SDave Chinner */ 62830f712c9SDave Chinner STATIC int /* error */ 62930f712c9SDave Chinner xfs_bmap_btree_to_extents( 63030f712c9SDave Chinner xfs_trans_t *tp, /* transaction pointer */ 63130f712c9SDave Chinner xfs_inode_t *ip, /* incore inode pointer */ 63230f712c9SDave Chinner xfs_btree_cur_t *cur, /* btree cursor */ 63330f712c9SDave Chinner int *logflagsp, /* inode logging flags */ 63430f712c9SDave Chinner int whichfork) /* data or attr fork */ 63530f712c9SDave Chinner { 63630f712c9SDave Chinner /* REFERENCED */ 63730f712c9SDave Chinner struct xfs_btree_block *cblock;/* child btree block */ 63830f712c9SDave Chinner xfs_fsblock_t cbno; /* child block number */ 63930f712c9SDave Chinner xfs_buf_t *cbp; /* child block's buffer */ 64030f712c9SDave Chinner int error; /* error return value */ 64130f712c9SDave Chinner xfs_ifork_t *ifp; /* inode fork data */ 64230f712c9SDave Chinner xfs_mount_t *mp; /* mount point structure */ 64330f712c9SDave Chinner __be64 *pp; /* ptr to block address */ 64430f712c9SDave Chinner struct xfs_btree_block *rblock;/* root btree block */ 645340785ccSDarrick J. Wong struct xfs_owner_info oinfo; 64630f712c9SDave Chinner 64730f712c9SDave Chinner mp = ip->i_mount; 64830f712c9SDave Chinner ifp = XFS_IFORK_PTR(ip, whichfork); 64960b4984fSDarrick J. Wong ASSERT(whichfork != XFS_COW_FORK); 65030f712c9SDave Chinner ASSERT(ifp->if_flags & XFS_IFEXTENTS); 65130f712c9SDave Chinner ASSERT(XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_BTREE); 65230f712c9SDave Chinner rblock = ifp->if_broot; 65330f712c9SDave Chinner ASSERT(be16_to_cpu(rblock->bb_level) == 1); 65430f712c9SDave Chinner ASSERT(be16_to_cpu(rblock->bb_numrecs) == 1); 65530f712c9SDave Chinner ASSERT(xfs_bmbt_maxrecs(mp, ifp->if_broot_bytes, 0) == 1); 65630f712c9SDave Chinner pp = XFS_BMAP_BROOT_PTR_ADDR(mp, rblock, 1, ifp->if_broot_bytes); 65730f712c9SDave Chinner cbno = be64_to_cpu(*pp); 65830f712c9SDave Chinner *logflagsp = 0; 65930f712c9SDave Chinner #ifdef DEBUG 66030f712c9SDave Chinner if ((error = xfs_btree_check_lptr(cur, cbno, 1))) 66130f712c9SDave Chinner return error; 66230f712c9SDave Chinner #endif 66330f712c9SDave Chinner error = xfs_btree_read_bufl(mp, tp, cbno, 0, &cbp, XFS_BMAP_BTREE_REF, 66430f712c9SDave Chinner &xfs_bmbt_buf_ops); 66530f712c9SDave Chinner if (error) 66630f712c9SDave Chinner return error; 66730f712c9SDave Chinner cblock = XFS_BUF_TO_BLOCK(cbp); 66830f712c9SDave Chinner if ((error = xfs_btree_check_block(cur, cblock, 0, cbp))) 66930f712c9SDave Chinner return error; 670340785ccSDarrick J. Wong xfs_rmap_ino_bmbt_owner(&oinfo, ip->i_ino, whichfork); 671340785ccSDarrick J. Wong xfs_bmap_add_free(mp, cur->bc_private.b.dfops, cbno, 1, &oinfo); 67230f712c9SDave Chinner ip->i_d.di_nblocks--; 67330f712c9SDave Chinner xfs_trans_mod_dquot_byino(tp, ip, XFS_TRANS_DQ_BCOUNT, -1L); 67430f712c9SDave Chinner xfs_trans_binval(tp, cbp); 67530f712c9SDave Chinner if (cur->bc_bufs[0] == cbp) 67630f712c9SDave Chinner cur->bc_bufs[0] = NULL; 67730f712c9SDave Chinner xfs_iroot_realloc(ip, -1, whichfork); 67830f712c9SDave Chinner ASSERT(ifp->if_broot == NULL); 67930f712c9SDave Chinner ASSERT((ifp->if_flags & XFS_IFBROOT) == 0); 68030f712c9SDave Chinner XFS_IFORK_FMT_SET(ip, whichfork, XFS_DINODE_FMT_EXTENTS); 68130f712c9SDave Chinner *logflagsp = XFS_ILOG_CORE | xfs_ilog_fext(whichfork); 68230f712c9SDave Chinner return 0; 68330f712c9SDave Chinner } 68430f712c9SDave Chinner 68530f712c9SDave Chinner /* 68630f712c9SDave Chinner * Convert an extents-format file into a btree-format file. 68730f712c9SDave Chinner * The new file will have a root block (in the inode) and a single child block. 68830f712c9SDave Chinner */ 68930f712c9SDave Chinner STATIC int /* error */ 69030f712c9SDave Chinner xfs_bmap_extents_to_btree( 69130f712c9SDave Chinner xfs_trans_t *tp, /* transaction pointer */ 69230f712c9SDave Chinner xfs_inode_t *ip, /* incore inode pointer */ 69330f712c9SDave Chinner xfs_fsblock_t *firstblock, /* first-block-allocated */ 6942c3234d1SDarrick J. Wong struct xfs_defer_ops *dfops, /* blocks freed in xaction */ 69530f712c9SDave Chinner xfs_btree_cur_t **curp, /* cursor returned to caller */ 69630f712c9SDave Chinner int wasdel, /* converting a delayed alloc */ 69730f712c9SDave Chinner int *logflagsp, /* inode logging flags */ 69830f712c9SDave Chinner int whichfork) /* data or attr fork */ 69930f712c9SDave Chinner { 70030f712c9SDave Chinner struct xfs_btree_block *ablock; /* allocated (child) bt block */ 70130f712c9SDave Chinner xfs_buf_t *abp; /* buffer for ablock */ 70230f712c9SDave Chinner xfs_alloc_arg_t args; /* allocation arguments */ 70330f712c9SDave Chinner xfs_bmbt_rec_t *arp; /* child record pointer */ 70430f712c9SDave Chinner struct xfs_btree_block *block; /* btree root block */ 70530f712c9SDave Chinner xfs_btree_cur_t *cur; /* bmap btree cursor */ 70630f712c9SDave Chinner xfs_bmbt_rec_host_t *ep; /* extent record pointer */ 70730f712c9SDave Chinner int error; /* error return value */ 70830f712c9SDave Chinner xfs_extnum_t i, cnt; /* extent record index */ 70930f712c9SDave Chinner xfs_ifork_t *ifp; /* inode fork pointer */ 71030f712c9SDave Chinner xfs_bmbt_key_t *kp; /* root block key pointer */ 71130f712c9SDave Chinner xfs_mount_t *mp; /* mount structure */ 71230f712c9SDave Chinner xfs_extnum_t nextents; /* number of file extents */ 71330f712c9SDave Chinner xfs_bmbt_ptr_t *pp; /* root block address pointer */ 71430f712c9SDave Chinner 71530f712c9SDave Chinner mp = ip->i_mount; 71660b4984fSDarrick J. Wong ASSERT(whichfork != XFS_COW_FORK); 71730f712c9SDave Chinner ifp = XFS_IFORK_PTR(ip, whichfork); 71830f712c9SDave Chinner ASSERT(XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_EXTENTS); 71930f712c9SDave Chinner 72030f712c9SDave Chinner /* 72130f712c9SDave Chinner * Make space in the inode incore. 72230f712c9SDave Chinner */ 72330f712c9SDave Chinner xfs_iroot_realloc(ip, 1, whichfork); 72430f712c9SDave Chinner ifp->if_flags |= XFS_IFBROOT; 72530f712c9SDave Chinner 72630f712c9SDave Chinner /* 72730f712c9SDave Chinner * Fill in the root. 72830f712c9SDave Chinner */ 72930f712c9SDave Chinner block = ifp->if_broot; 73030f712c9SDave Chinner xfs_btree_init_block_int(mp, block, XFS_BUF_DADDR_NULL, 731b6f41e44SEric Sandeen XFS_BTNUM_BMAP, 1, 1, ip->i_ino, 732f88ae46bSEric Sandeen XFS_BTREE_LONG_PTRS); 73330f712c9SDave Chinner /* 73430f712c9SDave Chinner * Need a cursor. Can't allocate until bb_level is filled in. 73530f712c9SDave Chinner */ 73630f712c9SDave Chinner cur = xfs_bmbt_init_cursor(mp, tp, ip, whichfork); 73730f712c9SDave Chinner cur->bc_private.b.firstblock = *firstblock; 7382c3234d1SDarrick J. Wong cur->bc_private.b.dfops = dfops; 73930f712c9SDave Chinner cur->bc_private.b.flags = wasdel ? XFS_BTCUR_BPRV_WASDEL : 0; 74030f712c9SDave Chinner /* 74130f712c9SDave Chinner * Convert to a btree with two levels, one record in root. 74230f712c9SDave Chinner */ 74330f712c9SDave Chinner XFS_IFORK_FMT_SET(ip, whichfork, XFS_DINODE_FMT_BTREE); 74430f712c9SDave Chinner memset(&args, 0, sizeof(args)); 74530f712c9SDave Chinner args.tp = tp; 74630f712c9SDave Chinner args.mp = mp; 747340785ccSDarrick J. Wong xfs_rmap_ino_bmbt_owner(&args.oinfo, ip->i_ino, whichfork); 74830f712c9SDave Chinner args.firstblock = *firstblock; 74930f712c9SDave Chinner if (*firstblock == NULLFSBLOCK) { 75030f712c9SDave Chinner args.type = XFS_ALLOCTYPE_START_BNO; 75130f712c9SDave Chinner args.fsbno = XFS_INO_TO_FSB(mp, ip->i_ino); 7522c3234d1SDarrick J. Wong } else if (dfops->dop_low) { 75330f712c9SDave Chinner args.type = XFS_ALLOCTYPE_START_BNO; 75430f712c9SDave Chinner args.fsbno = *firstblock; 75530f712c9SDave Chinner } else { 75630f712c9SDave Chinner args.type = XFS_ALLOCTYPE_NEAR_BNO; 75730f712c9SDave Chinner args.fsbno = *firstblock; 75830f712c9SDave Chinner } 75930f712c9SDave Chinner args.minlen = args.maxlen = args.prod = 1; 76030f712c9SDave Chinner args.wasdel = wasdel; 76130f712c9SDave Chinner *logflagsp = 0; 76230f712c9SDave Chinner if ((error = xfs_alloc_vextent(&args))) { 76330f712c9SDave Chinner xfs_iroot_realloc(ip, -1, whichfork); 76430f712c9SDave Chinner xfs_btree_del_cursor(cur, XFS_BTREE_ERROR); 76530f712c9SDave Chinner return error; 76630f712c9SDave Chinner } 76790e2056dSDarrick J. Wong 7682fcc319dSChristoph Hellwig if (WARN_ON_ONCE(args.fsbno == NULLFSBLOCK)) { 7692fcc319dSChristoph Hellwig xfs_iroot_realloc(ip, -1, whichfork); 7702fcc319dSChristoph Hellwig xfs_btree_del_cursor(cur, XFS_BTREE_ERROR); 7712fcc319dSChristoph Hellwig return -ENOSPC; 7722fcc319dSChristoph Hellwig } 77330f712c9SDave Chinner /* 77430f712c9SDave Chinner * Allocation can't fail, the space was reserved. 77530f712c9SDave Chinner */ 77630f712c9SDave Chinner ASSERT(*firstblock == NULLFSBLOCK || 777410d17f6SChristoph Hellwig args.agno >= XFS_FSB_TO_AGNO(mp, *firstblock)); 77830f712c9SDave Chinner *firstblock = cur->bc_private.b.firstblock = args.fsbno; 77930f712c9SDave Chinner cur->bc_private.b.allocated++; 78030f712c9SDave Chinner ip->i_d.di_nblocks++; 78130f712c9SDave Chinner xfs_trans_mod_dquot_byino(tp, ip, XFS_TRANS_DQ_BCOUNT, 1L); 78230f712c9SDave Chinner abp = xfs_btree_get_bufl(mp, tp, args.fsbno, 0); 78330f712c9SDave Chinner /* 78430f712c9SDave Chinner * Fill in the child block. 78530f712c9SDave Chinner */ 78630f712c9SDave Chinner abp->b_ops = &xfs_bmbt_buf_ops; 78730f712c9SDave Chinner ablock = XFS_BUF_TO_BLOCK(abp); 78830f712c9SDave Chinner xfs_btree_init_block_int(mp, ablock, abp->b_bn, 789b6f41e44SEric Sandeen XFS_BTNUM_BMAP, 0, 0, ip->i_ino, 79030f712c9SDave Chinner XFS_BTREE_LONG_PTRS); 79130f712c9SDave Chinner 79230f712c9SDave Chinner arp = XFS_BMBT_REC_ADDR(mp, ablock, 1); 7935d829300SEric Sandeen nextents = xfs_iext_count(ifp); 79430f712c9SDave Chinner for (cnt = i = 0; i < nextents; i++) { 79530f712c9SDave Chinner ep = xfs_iext_get_ext(ifp, i); 79630f712c9SDave Chinner if (!isnullstartblock(xfs_bmbt_get_startblock(ep))) { 79730f712c9SDave Chinner arp->l0 = cpu_to_be64(ep->l0); 79830f712c9SDave Chinner arp->l1 = cpu_to_be64(ep->l1); 79930f712c9SDave Chinner arp++; cnt++; 80030f712c9SDave Chinner } 80130f712c9SDave Chinner } 80230f712c9SDave Chinner ASSERT(cnt == XFS_IFORK_NEXTENTS(ip, whichfork)); 80330f712c9SDave Chinner xfs_btree_set_numrecs(ablock, cnt); 80430f712c9SDave Chinner 80530f712c9SDave Chinner /* 80630f712c9SDave Chinner * Fill in the root key and pointer. 80730f712c9SDave Chinner */ 80830f712c9SDave Chinner kp = XFS_BMBT_KEY_ADDR(mp, block, 1); 80930f712c9SDave Chinner arp = XFS_BMBT_REC_ADDR(mp, ablock, 1); 81030f712c9SDave Chinner kp->br_startoff = cpu_to_be64(xfs_bmbt_disk_get_startoff(arp)); 81130f712c9SDave Chinner pp = XFS_BMBT_PTR_ADDR(mp, block, 1, xfs_bmbt_get_maxrecs(cur, 81230f712c9SDave Chinner be16_to_cpu(block->bb_level))); 81330f712c9SDave Chinner *pp = cpu_to_be64(args.fsbno); 81430f712c9SDave Chinner 81530f712c9SDave Chinner /* 81630f712c9SDave Chinner * Do all this logging at the end so that 81730f712c9SDave Chinner * the root is at the right level. 81830f712c9SDave Chinner */ 81930f712c9SDave Chinner xfs_btree_log_block(cur, abp, XFS_BB_ALL_BITS); 82030f712c9SDave Chinner xfs_btree_log_recs(cur, abp, 1, be16_to_cpu(ablock->bb_numrecs)); 82130f712c9SDave Chinner ASSERT(*curp == NULL); 82230f712c9SDave Chinner *curp = cur; 82330f712c9SDave Chinner *logflagsp = XFS_ILOG_CORE | xfs_ilog_fbroot(whichfork); 82430f712c9SDave Chinner return 0; 82530f712c9SDave Chinner } 82630f712c9SDave Chinner 82730f712c9SDave Chinner /* 82830f712c9SDave Chinner * Convert a local file to an extents file. 82930f712c9SDave Chinner * This code is out of bounds for data forks of regular files, 83030f712c9SDave Chinner * since the file data needs to get logged so things will stay consistent. 83130f712c9SDave Chinner * (The bmap-level manipulations are ok, though). 83230f712c9SDave Chinner */ 83330f712c9SDave Chinner void 83430f712c9SDave Chinner xfs_bmap_local_to_extents_empty( 83530f712c9SDave Chinner struct xfs_inode *ip, 83630f712c9SDave Chinner int whichfork) 83730f712c9SDave Chinner { 83830f712c9SDave Chinner struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, whichfork); 83930f712c9SDave Chinner 84060b4984fSDarrick J. Wong ASSERT(whichfork != XFS_COW_FORK); 84130f712c9SDave Chinner ASSERT(XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_LOCAL); 84230f712c9SDave Chinner ASSERT(ifp->if_bytes == 0); 84330f712c9SDave Chinner ASSERT(XFS_IFORK_NEXTENTS(ip, whichfork) == 0); 84430f712c9SDave Chinner 84530f712c9SDave Chinner xfs_bmap_forkoff_reset(ip, whichfork); 84630f712c9SDave Chinner ifp->if_flags &= ~XFS_IFINLINE; 84730f712c9SDave Chinner ifp->if_flags |= XFS_IFEXTENTS; 84830f712c9SDave Chinner XFS_IFORK_FMT_SET(ip, whichfork, XFS_DINODE_FMT_EXTENTS); 84930f712c9SDave Chinner } 85030f712c9SDave Chinner 85130f712c9SDave Chinner 85230f712c9SDave Chinner STATIC int /* error */ 85330f712c9SDave Chinner xfs_bmap_local_to_extents( 85430f712c9SDave Chinner xfs_trans_t *tp, /* transaction pointer */ 85530f712c9SDave Chinner xfs_inode_t *ip, /* incore inode pointer */ 85630f712c9SDave Chinner xfs_fsblock_t *firstblock, /* first block allocated in xaction */ 85730f712c9SDave Chinner xfs_extlen_t total, /* total blocks needed by transaction */ 85830f712c9SDave Chinner int *logflagsp, /* inode logging flags */ 85930f712c9SDave Chinner int whichfork, 86030f712c9SDave Chinner void (*init_fn)(struct xfs_trans *tp, 86130f712c9SDave Chinner struct xfs_buf *bp, 86230f712c9SDave Chinner struct xfs_inode *ip, 86330f712c9SDave Chinner struct xfs_ifork *ifp)) 86430f712c9SDave Chinner { 86530f712c9SDave Chinner int error = 0; 86630f712c9SDave Chinner int flags; /* logging flags returned */ 86730f712c9SDave Chinner xfs_ifork_t *ifp; /* inode fork pointer */ 86830f712c9SDave Chinner xfs_alloc_arg_t args; /* allocation arguments */ 86930f712c9SDave Chinner xfs_buf_t *bp; /* buffer for extent block */ 87050bb44c2SChristoph Hellwig struct xfs_bmbt_irec rec; 87130f712c9SDave Chinner 87230f712c9SDave Chinner /* 87330f712c9SDave Chinner * We don't want to deal with the case of keeping inode data inline yet. 87430f712c9SDave Chinner * So sending the data fork of a regular inode is invalid. 87530f712c9SDave Chinner */ 876c19b3b05SDave Chinner ASSERT(!(S_ISREG(VFS_I(ip)->i_mode) && whichfork == XFS_DATA_FORK)); 87730f712c9SDave Chinner ifp = XFS_IFORK_PTR(ip, whichfork); 87830f712c9SDave Chinner ASSERT(XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_LOCAL); 87930f712c9SDave Chinner 88030f712c9SDave Chinner if (!ifp->if_bytes) { 88130f712c9SDave Chinner xfs_bmap_local_to_extents_empty(ip, whichfork); 88230f712c9SDave Chinner flags = XFS_ILOG_CORE; 88330f712c9SDave Chinner goto done; 88430f712c9SDave Chinner } 88530f712c9SDave Chinner 88630f712c9SDave Chinner flags = 0; 88730f712c9SDave Chinner error = 0; 88830f712c9SDave Chinner ASSERT((ifp->if_flags & (XFS_IFINLINE|XFS_IFEXTENTS|XFS_IFEXTIREC)) == 88930f712c9SDave Chinner XFS_IFINLINE); 89030f712c9SDave Chinner memset(&args, 0, sizeof(args)); 89130f712c9SDave Chinner args.tp = tp; 89230f712c9SDave Chinner args.mp = ip->i_mount; 893340785ccSDarrick J. Wong xfs_rmap_ino_owner(&args.oinfo, ip->i_ino, whichfork, 0); 89430f712c9SDave Chinner args.firstblock = *firstblock; 89530f712c9SDave Chinner /* 89630f712c9SDave Chinner * Allocate a block. We know we need only one, since the 89730f712c9SDave Chinner * file currently fits in an inode. 89830f712c9SDave Chinner */ 89930f712c9SDave Chinner if (*firstblock == NULLFSBLOCK) { 90030f712c9SDave Chinner args.fsbno = XFS_INO_TO_FSB(args.mp, ip->i_ino); 90130f712c9SDave Chinner args.type = XFS_ALLOCTYPE_START_BNO; 90230f712c9SDave Chinner } else { 90330f712c9SDave Chinner args.fsbno = *firstblock; 90430f712c9SDave Chinner args.type = XFS_ALLOCTYPE_NEAR_BNO; 90530f712c9SDave Chinner } 90630f712c9SDave Chinner args.total = total; 90730f712c9SDave Chinner args.minlen = args.maxlen = args.prod = 1; 90830f712c9SDave Chinner error = xfs_alloc_vextent(&args); 90930f712c9SDave Chinner if (error) 91030f712c9SDave Chinner goto done; 91130f712c9SDave Chinner 91230f712c9SDave Chinner /* Can't fail, the space was reserved. */ 91330f712c9SDave Chinner ASSERT(args.fsbno != NULLFSBLOCK); 91430f712c9SDave Chinner ASSERT(args.len == 1); 91530f712c9SDave Chinner *firstblock = args.fsbno; 91630f712c9SDave Chinner bp = xfs_btree_get_bufl(args.mp, tp, args.fsbno, 0); 91730f712c9SDave Chinner 918fe22d552SDave Chinner /* 919b7cdc66bSBrian Foster * Initialize the block, copy the data and log the remote buffer. 920fe22d552SDave Chinner * 921b7cdc66bSBrian Foster * The callout is responsible for logging because the remote format 922b7cdc66bSBrian Foster * might differ from the local format and thus we don't know how much to 923b7cdc66bSBrian Foster * log here. Note that init_fn must also set the buffer log item type 924b7cdc66bSBrian Foster * correctly. 925fe22d552SDave Chinner */ 92630f712c9SDave Chinner init_fn(tp, bp, ip, ifp); 92730f712c9SDave Chinner 928b7cdc66bSBrian Foster /* account for the change in fork size */ 92930f712c9SDave Chinner xfs_idata_realloc(ip, -ifp->if_bytes, whichfork); 93030f712c9SDave Chinner xfs_bmap_local_to_extents_empty(ip, whichfork); 93130f712c9SDave Chinner flags |= XFS_ILOG_CORE; 93230f712c9SDave Chinner 93350bb44c2SChristoph Hellwig rec.br_startoff = 0; 93450bb44c2SChristoph Hellwig rec.br_startblock = args.fsbno; 93550bb44c2SChristoph Hellwig rec.br_blockcount = 1; 93650bb44c2SChristoph Hellwig rec.br_state = XFS_EXT_NORM; 93750bb44c2SChristoph Hellwig xfs_iext_insert(ip, 0, 1, &rec, 0); 93850bb44c2SChristoph Hellwig 93930f712c9SDave Chinner trace_xfs_bmap_post_update(ip, 0, 94030f712c9SDave Chinner whichfork == XFS_ATTR_FORK ? BMAP_ATTRFORK : 0, 94130f712c9SDave Chinner _THIS_IP_); 94230f712c9SDave Chinner XFS_IFORK_NEXT_SET(ip, whichfork, 1); 94330f712c9SDave Chinner ip->i_d.di_nblocks = 1; 94430f712c9SDave Chinner xfs_trans_mod_dquot_byino(tp, ip, 94530f712c9SDave Chinner XFS_TRANS_DQ_BCOUNT, 1L); 94630f712c9SDave Chinner flags |= xfs_ilog_fext(whichfork); 94730f712c9SDave Chinner 94830f712c9SDave Chinner done: 94930f712c9SDave Chinner *logflagsp = flags; 95030f712c9SDave Chinner return error; 95130f712c9SDave Chinner } 95230f712c9SDave Chinner 95330f712c9SDave Chinner /* 95430f712c9SDave Chinner * Called from xfs_bmap_add_attrfork to handle btree format files. 95530f712c9SDave Chinner */ 95630f712c9SDave Chinner STATIC int /* error */ 95730f712c9SDave Chinner xfs_bmap_add_attrfork_btree( 95830f712c9SDave Chinner xfs_trans_t *tp, /* transaction pointer */ 95930f712c9SDave Chinner xfs_inode_t *ip, /* incore inode pointer */ 96030f712c9SDave Chinner xfs_fsblock_t *firstblock, /* first block allocated */ 9612c3234d1SDarrick J. Wong struct xfs_defer_ops *dfops, /* blocks to free at commit */ 96230f712c9SDave Chinner int *flags) /* inode logging flags */ 96330f712c9SDave Chinner { 96430f712c9SDave Chinner xfs_btree_cur_t *cur; /* btree cursor */ 96530f712c9SDave Chinner int error; /* error return value */ 96630f712c9SDave Chinner xfs_mount_t *mp; /* file system mount struct */ 96730f712c9SDave Chinner int stat; /* newroot status */ 96830f712c9SDave Chinner 96930f712c9SDave Chinner mp = ip->i_mount; 97030f712c9SDave Chinner if (ip->i_df.if_broot_bytes <= XFS_IFORK_DSIZE(ip)) 97130f712c9SDave Chinner *flags |= XFS_ILOG_DBROOT; 97230f712c9SDave Chinner else { 97330f712c9SDave Chinner cur = xfs_bmbt_init_cursor(mp, tp, ip, XFS_DATA_FORK); 9742c3234d1SDarrick J. Wong cur->bc_private.b.dfops = dfops; 97530f712c9SDave Chinner cur->bc_private.b.firstblock = *firstblock; 97630f712c9SDave Chinner if ((error = xfs_bmbt_lookup_ge(cur, 0, 0, 0, &stat))) 97730f712c9SDave Chinner goto error0; 97830f712c9SDave Chinner /* must be at least one entry */ 979c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, stat == 1, error0); 98030f712c9SDave Chinner if ((error = xfs_btree_new_iroot(cur, flags, &stat))) 98130f712c9SDave Chinner goto error0; 98230f712c9SDave Chinner if (stat == 0) { 98330f712c9SDave Chinner xfs_btree_del_cursor(cur, XFS_BTREE_NOERROR); 9842451337dSDave Chinner return -ENOSPC; 98530f712c9SDave Chinner } 98630f712c9SDave Chinner *firstblock = cur->bc_private.b.firstblock; 98730f712c9SDave Chinner cur->bc_private.b.allocated = 0; 98830f712c9SDave Chinner xfs_btree_del_cursor(cur, XFS_BTREE_NOERROR); 98930f712c9SDave Chinner } 99030f712c9SDave Chinner return 0; 99130f712c9SDave Chinner error0: 99230f712c9SDave Chinner xfs_btree_del_cursor(cur, XFS_BTREE_ERROR); 99330f712c9SDave Chinner return error; 99430f712c9SDave Chinner } 99530f712c9SDave Chinner 99630f712c9SDave Chinner /* 99730f712c9SDave Chinner * Called from xfs_bmap_add_attrfork to handle extents format files. 99830f712c9SDave Chinner */ 99930f712c9SDave Chinner STATIC int /* error */ 100030f712c9SDave Chinner xfs_bmap_add_attrfork_extents( 100130f712c9SDave Chinner xfs_trans_t *tp, /* transaction pointer */ 100230f712c9SDave Chinner xfs_inode_t *ip, /* incore inode pointer */ 100330f712c9SDave Chinner xfs_fsblock_t *firstblock, /* first block allocated */ 10042c3234d1SDarrick J. Wong struct xfs_defer_ops *dfops, /* blocks to free at commit */ 100530f712c9SDave Chinner int *flags) /* inode logging flags */ 100630f712c9SDave Chinner { 100730f712c9SDave Chinner xfs_btree_cur_t *cur; /* bmap btree cursor */ 100830f712c9SDave Chinner int error; /* error return value */ 100930f712c9SDave Chinner 101030f712c9SDave Chinner if (ip->i_d.di_nextents * sizeof(xfs_bmbt_rec_t) <= XFS_IFORK_DSIZE(ip)) 101130f712c9SDave Chinner return 0; 101230f712c9SDave Chinner cur = NULL; 10132c3234d1SDarrick J. Wong error = xfs_bmap_extents_to_btree(tp, ip, firstblock, dfops, &cur, 0, 101430f712c9SDave Chinner flags, XFS_DATA_FORK); 101530f712c9SDave Chinner if (cur) { 101630f712c9SDave Chinner cur->bc_private.b.allocated = 0; 101730f712c9SDave Chinner xfs_btree_del_cursor(cur, 101830f712c9SDave Chinner error ? XFS_BTREE_ERROR : XFS_BTREE_NOERROR); 101930f712c9SDave Chinner } 102030f712c9SDave Chinner return error; 102130f712c9SDave Chinner } 102230f712c9SDave Chinner 102330f712c9SDave Chinner /* 102430f712c9SDave Chinner * Called from xfs_bmap_add_attrfork to handle local format files. Each 102530f712c9SDave Chinner * different data fork content type needs a different callout to do the 102630f712c9SDave Chinner * conversion. Some are basic and only require special block initialisation 102730f712c9SDave Chinner * callouts for the data formating, others (directories) are so specialised they 102830f712c9SDave Chinner * handle everything themselves. 102930f712c9SDave Chinner * 103030f712c9SDave Chinner * XXX (dgc): investigate whether directory conversion can use the generic 103130f712c9SDave Chinner * formatting callout. It should be possible - it's just a very complex 103230f712c9SDave Chinner * formatter. 103330f712c9SDave Chinner */ 103430f712c9SDave Chinner STATIC int /* error */ 103530f712c9SDave Chinner xfs_bmap_add_attrfork_local( 103630f712c9SDave Chinner xfs_trans_t *tp, /* transaction pointer */ 103730f712c9SDave Chinner xfs_inode_t *ip, /* incore inode pointer */ 103830f712c9SDave Chinner xfs_fsblock_t *firstblock, /* first block allocated */ 10392c3234d1SDarrick J. Wong struct xfs_defer_ops *dfops, /* blocks to free at commit */ 104030f712c9SDave Chinner int *flags) /* inode logging flags */ 104130f712c9SDave Chinner { 104230f712c9SDave Chinner xfs_da_args_t dargs; /* args for dir/attr code */ 104330f712c9SDave Chinner 104430f712c9SDave Chinner if (ip->i_df.if_bytes <= XFS_IFORK_DSIZE(ip)) 104530f712c9SDave Chinner return 0; 104630f712c9SDave Chinner 1047c19b3b05SDave Chinner if (S_ISDIR(VFS_I(ip)->i_mode)) { 104830f712c9SDave Chinner memset(&dargs, 0, sizeof(dargs)); 104930f712c9SDave Chinner dargs.geo = ip->i_mount->m_dir_geo; 105030f712c9SDave Chinner dargs.dp = ip; 105130f712c9SDave Chinner dargs.firstblock = firstblock; 10522c3234d1SDarrick J. Wong dargs.dfops = dfops; 105330f712c9SDave Chinner dargs.total = dargs.geo->fsbcount; 105430f712c9SDave Chinner dargs.whichfork = XFS_DATA_FORK; 105530f712c9SDave Chinner dargs.trans = tp; 105630f712c9SDave Chinner return xfs_dir2_sf_to_block(&dargs); 105730f712c9SDave Chinner } 105830f712c9SDave Chinner 1059c19b3b05SDave Chinner if (S_ISLNK(VFS_I(ip)->i_mode)) 106030f712c9SDave Chinner return xfs_bmap_local_to_extents(tp, ip, firstblock, 1, 106130f712c9SDave Chinner flags, XFS_DATA_FORK, 106230f712c9SDave Chinner xfs_symlink_local_to_remote); 106330f712c9SDave Chinner 106430f712c9SDave Chinner /* should only be called for types that support local format data */ 106530f712c9SDave Chinner ASSERT(0); 10662451337dSDave Chinner return -EFSCORRUPTED; 106730f712c9SDave Chinner } 106830f712c9SDave Chinner 106930f712c9SDave Chinner /* 107030f712c9SDave Chinner * Convert inode from non-attributed to attributed. 107130f712c9SDave Chinner * Must not be in a transaction, ip must not be locked. 107230f712c9SDave Chinner */ 107330f712c9SDave Chinner int /* error code */ 107430f712c9SDave Chinner xfs_bmap_add_attrfork( 107530f712c9SDave Chinner xfs_inode_t *ip, /* incore inode pointer */ 107630f712c9SDave Chinner int size, /* space new attribute needs */ 107730f712c9SDave Chinner int rsvd) /* xact may use reserved blks */ 107830f712c9SDave Chinner { 107930f712c9SDave Chinner xfs_fsblock_t firstblock; /* 1st block/ag allocated */ 10802c3234d1SDarrick J. Wong struct xfs_defer_ops dfops; /* freed extent records */ 108130f712c9SDave Chinner xfs_mount_t *mp; /* mount structure */ 108230f712c9SDave Chinner xfs_trans_t *tp; /* transaction pointer */ 108330f712c9SDave Chinner int blks; /* space reservation */ 108430f712c9SDave Chinner int version = 1; /* superblock attr version */ 108530f712c9SDave Chinner int logflags; /* logging flags */ 108630f712c9SDave Chinner int error; /* error return value */ 108730f712c9SDave Chinner 108830f712c9SDave Chinner ASSERT(XFS_IFORK_Q(ip) == 0); 108930f712c9SDave Chinner 109030f712c9SDave Chinner mp = ip->i_mount; 109130f712c9SDave Chinner ASSERT(!XFS_NOT_DQATTACHED(mp, ip)); 1092253f4911SChristoph Hellwig 109330f712c9SDave Chinner blks = XFS_ADDAFORK_SPACE_RES(mp); 1094253f4911SChristoph Hellwig 1095253f4911SChristoph Hellwig error = xfs_trans_alloc(mp, &M_RES(mp)->tr_addafork, blks, 0, 1096253f4911SChristoph Hellwig rsvd ? XFS_TRANS_RESERVE : 0, &tp); 1097253f4911SChristoph Hellwig if (error) 109830f712c9SDave Chinner return error; 1099253f4911SChristoph Hellwig 110030f712c9SDave Chinner xfs_ilock(ip, XFS_ILOCK_EXCL); 110130f712c9SDave Chinner error = xfs_trans_reserve_quota_nblks(tp, ip, blks, 0, rsvd ? 110230f712c9SDave Chinner XFS_QMOPT_RES_REGBLKS | XFS_QMOPT_FORCE_RES : 110330f712c9SDave Chinner XFS_QMOPT_RES_REGBLKS); 110430f712c9SDave Chinner if (error) 110530f712c9SDave Chinner goto trans_cancel; 110630f712c9SDave Chinner if (XFS_IFORK_Q(ip)) 110730f712c9SDave Chinner goto trans_cancel; 11080f352f8eSDarrick J. Wong if (ip->i_d.di_anextents != 0) { 11090f352f8eSDarrick J. Wong error = -EFSCORRUPTED; 11100f352f8eSDarrick J. Wong goto trans_cancel; 11110f352f8eSDarrick J. Wong } 111230f712c9SDave Chinner if (ip->i_d.di_aformat != XFS_DINODE_FMT_EXTENTS) { 111330f712c9SDave Chinner /* 111430f712c9SDave Chinner * For inodes coming from pre-6.2 filesystems. 111530f712c9SDave Chinner */ 111630f712c9SDave Chinner ASSERT(ip->i_d.di_aformat == 0); 111730f712c9SDave Chinner ip->i_d.di_aformat = XFS_DINODE_FMT_EXTENTS; 111830f712c9SDave Chinner } 111930f712c9SDave Chinner 112030f712c9SDave Chinner xfs_trans_ijoin(tp, ip, 0); 112130f712c9SDave Chinner xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE); 112230f712c9SDave Chinner 112330f712c9SDave Chinner switch (ip->i_d.di_format) { 112430f712c9SDave Chinner case XFS_DINODE_FMT_DEV: 112530f712c9SDave Chinner ip->i_d.di_forkoff = roundup(sizeof(xfs_dev_t), 8) >> 3; 112630f712c9SDave Chinner break; 112730f712c9SDave Chinner case XFS_DINODE_FMT_UUID: 112830f712c9SDave Chinner ip->i_d.di_forkoff = roundup(sizeof(uuid_t), 8) >> 3; 112930f712c9SDave Chinner break; 113030f712c9SDave Chinner case XFS_DINODE_FMT_LOCAL: 113130f712c9SDave Chinner case XFS_DINODE_FMT_EXTENTS: 113230f712c9SDave Chinner case XFS_DINODE_FMT_BTREE: 113330f712c9SDave Chinner ip->i_d.di_forkoff = xfs_attr_shortform_bytesfit(ip, size); 113430f712c9SDave Chinner if (!ip->i_d.di_forkoff) 113530f712c9SDave Chinner ip->i_d.di_forkoff = xfs_default_attroffset(ip) >> 3; 113630f712c9SDave Chinner else if (mp->m_flags & XFS_MOUNT_ATTR2) 113730f712c9SDave Chinner version = 2; 113830f712c9SDave Chinner break; 113930f712c9SDave Chinner default: 114030f712c9SDave Chinner ASSERT(0); 11412451337dSDave Chinner error = -EINVAL; 114230f712c9SDave Chinner goto trans_cancel; 114330f712c9SDave Chinner } 114430f712c9SDave Chinner 114530f712c9SDave Chinner ASSERT(ip->i_afp == NULL); 114630f712c9SDave Chinner ip->i_afp = kmem_zone_zalloc(xfs_ifork_zone, KM_SLEEP); 114730f712c9SDave Chinner ip->i_afp->if_flags = XFS_IFEXTENTS; 114830f712c9SDave Chinner logflags = 0; 11492c3234d1SDarrick J. Wong xfs_defer_init(&dfops, &firstblock); 115030f712c9SDave Chinner switch (ip->i_d.di_format) { 115130f712c9SDave Chinner case XFS_DINODE_FMT_LOCAL: 11522c3234d1SDarrick J. Wong error = xfs_bmap_add_attrfork_local(tp, ip, &firstblock, &dfops, 115330f712c9SDave Chinner &logflags); 115430f712c9SDave Chinner break; 115530f712c9SDave Chinner case XFS_DINODE_FMT_EXTENTS: 115630f712c9SDave Chinner error = xfs_bmap_add_attrfork_extents(tp, ip, &firstblock, 11572c3234d1SDarrick J. Wong &dfops, &logflags); 115830f712c9SDave Chinner break; 115930f712c9SDave Chinner case XFS_DINODE_FMT_BTREE: 11602c3234d1SDarrick J. Wong error = xfs_bmap_add_attrfork_btree(tp, ip, &firstblock, &dfops, 116130f712c9SDave Chinner &logflags); 116230f712c9SDave Chinner break; 116330f712c9SDave Chinner default: 116430f712c9SDave Chinner error = 0; 116530f712c9SDave Chinner break; 116630f712c9SDave Chinner } 116730f712c9SDave Chinner if (logflags) 116830f712c9SDave Chinner xfs_trans_log_inode(tp, ip, logflags); 116930f712c9SDave Chinner if (error) 117030f712c9SDave Chinner goto bmap_cancel; 117130f712c9SDave Chinner if (!xfs_sb_version_hasattr(&mp->m_sb) || 117230f712c9SDave Chinner (!xfs_sb_version_hasattr2(&mp->m_sb) && version == 2)) { 117361e63ecbSDave Chinner bool log_sb = false; 117430f712c9SDave Chinner 117530f712c9SDave Chinner spin_lock(&mp->m_sb_lock); 117630f712c9SDave Chinner if (!xfs_sb_version_hasattr(&mp->m_sb)) { 117730f712c9SDave Chinner xfs_sb_version_addattr(&mp->m_sb); 117861e63ecbSDave Chinner log_sb = true; 117930f712c9SDave Chinner } 118030f712c9SDave Chinner if (!xfs_sb_version_hasattr2(&mp->m_sb) && version == 2) { 118130f712c9SDave Chinner xfs_sb_version_addattr2(&mp->m_sb); 118261e63ecbSDave Chinner log_sb = true; 118330f712c9SDave Chinner } 118430f712c9SDave Chinner spin_unlock(&mp->m_sb_lock); 118561e63ecbSDave Chinner if (log_sb) 118661e63ecbSDave Chinner xfs_log_sb(tp); 118730f712c9SDave Chinner } 118830f712c9SDave Chinner 11898ad7c629SChristoph Hellwig error = xfs_defer_finish(&tp, &dfops); 119030f712c9SDave Chinner if (error) 119130f712c9SDave Chinner goto bmap_cancel; 119270393313SChristoph Hellwig error = xfs_trans_commit(tp); 119330f712c9SDave Chinner xfs_iunlock(ip, XFS_ILOCK_EXCL); 119430f712c9SDave Chinner return error; 119530f712c9SDave Chinner 119630f712c9SDave Chinner bmap_cancel: 11972c3234d1SDarrick J. Wong xfs_defer_cancel(&dfops); 119830f712c9SDave Chinner trans_cancel: 11994906e215SChristoph Hellwig xfs_trans_cancel(tp); 120030f712c9SDave Chinner xfs_iunlock(ip, XFS_ILOCK_EXCL); 120130f712c9SDave Chinner return error; 120230f712c9SDave Chinner } 120330f712c9SDave Chinner 120430f712c9SDave Chinner /* 120530f712c9SDave Chinner * Internal and external extent tree search functions. 120630f712c9SDave Chinner */ 120730f712c9SDave Chinner 120830f712c9SDave Chinner /* 120930f712c9SDave Chinner * Read in the extents to if_extents. 121030f712c9SDave Chinner * All inode fields are set up by caller, we just traverse the btree 121130f712c9SDave Chinner * and copy the records in. If the file system cannot contain unwritten 121230f712c9SDave Chinner * extents, the records are checked for no "state" flags. 121330f712c9SDave Chinner */ 121430f712c9SDave Chinner int /* error */ 121530f712c9SDave Chinner xfs_bmap_read_extents( 121630f712c9SDave Chinner xfs_trans_t *tp, /* transaction pointer */ 121730f712c9SDave Chinner xfs_inode_t *ip, /* incore inode */ 121830f712c9SDave Chinner int whichfork) /* data or attr fork */ 121930f712c9SDave Chinner { 122030f712c9SDave Chinner struct xfs_btree_block *block; /* current btree block */ 122130f712c9SDave Chinner xfs_fsblock_t bno; /* block # of "block" */ 122230f712c9SDave Chinner xfs_buf_t *bp; /* buffer for "block" */ 122330f712c9SDave Chinner int error; /* error return value */ 122430f712c9SDave Chinner xfs_extnum_t i, j; /* index into the extents list */ 122530f712c9SDave Chinner xfs_ifork_t *ifp; /* fork structure */ 122630f712c9SDave Chinner int level; /* btree level, for checking */ 122730f712c9SDave Chinner xfs_mount_t *mp; /* file system mount structure */ 122830f712c9SDave Chinner __be64 *pp; /* pointer to block address */ 122930f712c9SDave Chinner /* REFERENCED */ 123030f712c9SDave Chinner xfs_extnum_t room; /* number of entries there's room for */ 123130f712c9SDave Chinner 123230f712c9SDave Chinner mp = ip->i_mount; 123330f712c9SDave Chinner ifp = XFS_IFORK_PTR(ip, whichfork); 123430f712c9SDave Chinner block = ifp->if_broot; 123530f712c9SDave Chinner /* 123630f712c9SDave Chinner * Root level must use BMAP_BROOT_PTR_ADDR macro to get ptr out. 123730f712c9SDave Chinner */ 123830f712c9SDave Chinner level = be16_to_cpu(block->bb_level); 123930f712c9SDave Chinner ASSERT(level > 0); 124030f712c9SDave Chinner pp = XFS_BMAP_BROOT_PTR_ADDR(mp, block, 1, ifp->if_broot_bytes); 124130f712c9SDave Chinner bno = be64_to_cpu(*pp); 1242d5a91baeSDarrick J. Wong 124330f712c9SDave Chinner /* 124430f712c9SDave Chinner * Go down the tree until leaf level is reached, following the first 124530f712c9SDave Chinner * pointer (leftmost) at each level. 124630f712c9SDave Chinner */ 124730f712c9SDave Chinner while (level-- > 0) { 124830f712c9SDave Chinner error = xfs_btree_read_bufl(mp, tp, bno, 0, &bp, 124930f712c9SDave Chinner XFS_BMAP_BTREE_REF, &xfs_bmbt_buf_ops); 125030f712c9SDave Chinner if (error) 125130f712c9SDave Chinner return error; 125230f712c9SDave Chinner block = XFS_BUF_TO_BLOCK(bp); 125330f712c9SDave Chinner if (level == 0) 125430f712c9SDave Chinner break; 125530f712c9SDave Chinner pp = XFS_BMBT_PTR_ADDR(mp, block, 1, mp->m_bmap_dmxr[1]); 125630f712c9SDave Chinner bno = be64_to_cpu(*pp); 1257c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, 1258c29aad41SEric Sandeen XFS_FSB_SANITY_CHECK(mp, bno), error0); 125930f712c9SDave Chinner xfs_trans_brelse(tp, bp); 126030f712c9SDave Chinner } 126130f712c9SDave Chinner /* 126230f712c9SDave Chinner * Here with bp and block set to the leftmost leaf node in the tree. 126330f712c9SDave Chinner */ 12645d829300SEric Sandeen room = xfs_iext_count(ifp); 126530f712c9SDave Chinner i = 0; 126630f712c9SDave Chinner /* 126730f712c9SDave Chinner * Loop over all leaf nodes. Copy information to the extent records. 126830f712c9SDave Chinner */ 126930f712c9SDave Chinner for (;;) { 127030f712c9SDave Chinner xfs_bmbt_rec_t *frp; 127130f712c9SDave Chinner xfs_fsblock_t nextbno; 127230f712c9SDave Chinner xfs_extnum_t num_recs; 127330f712c9SDave Chinner 127430f712c9SDave Chinner num_recs = xfs_btree_get_numrecs(block); 127530f712c9SDave Chinner if (unlikely(i + num_recs > room)) { 127630f712c9SDave Chinner ASSERT(i + num_recs <= room); 127730f712c9SDave Chinner xfs_warn(ip->i_mount, 127830f712c9SDave Chinner "corrupt dinode %Lu, (btree extents).", 127930f712c9SDave Chinner (unsigned long long) ip->i_ino); 128030f712c9SDave Chinner XFS_CORRUPTION_ERROR("xfs_bmap_read_extents(1)", 128130f712c9SDave Chinner XFS_ERRLEVEL_LOW, ip->i_mount, block); 128230f712c9SDave Chinner goto error0; 128330f712c9SDave Chinner } 128430f712c9SDave Chinner /* 128530f712c9SDave Chinner * Read-ahead the next leaf block, if any. 128630f712c9SDave Chinner */ 128730f712c9SDave Chinner nextbno = be64_to_cpu(block->bb_u.l.bb_rightsib); 128830f712c9SDave Chinner if (nextbno != NULLFSBLOCK) 128930f712c9SDave Chinner xfs_btree_reada_bufl(mp, nextbno, 1, 129030f712c9SDave Chinner &xfs_bmbt_buf_ops); 129130f712c9SDave Chinner /* 129230f712c9SDave Chinner * Copy records into the extent records. 129330f712c9SDave Chinner */ 129430f712c9SDave Chinner frp = XFS_BMBT_REC_ADDR(mp, block, 1); 129530f712c9SDave Chinner for (j = 0; j < num_recs; j++, i++, frp++) { 129630f712c9SDave Chinner xfs_bmbt_rec_host_t *trp = xfs_iext_get_ext(ifp, i); 129730f712c9SDave Chinner trp->l0 = be64_to_cpu(frp->l0); 129830f712c9SDave Chinner trp->l1 = be64_to_cpu(frp->l1); 12990c1d9e4aSChristoph Hellwig if (!xfs_bmbt_validate_extent(mp, whichfork, trp)) { 130030f712c9SDave Chinner XFS_ERROR_REPORT("xfs_bmap_read_extents(2)", 13010c1d9e4aSChristoph Hellwig XFS_ERRLEVEL_LOW, mp); 130230f712c9SDave Chinner goto error0; 130330f712c9SDave Chinner } 130430f712c9SDave Chinner } 130530f712c9SDave Chinner xfs_trans_brelse(tp, bp); 130630f712c9SDave Chinner bno = nextbno; 130730f712c9SDave Chinner /* 130830f712c9SDave Chinner * If we've reached the end, stop. 130930f712c9SDave Chinner */ 131030f712c9SDave Chinner if (bno == NULLFSBLOCK) 131130f712c9SDave Chinner break; 131230f712c9SDave Chinner error = xfs_btree_read_bufl(mp, tp, bno, 0, &bp, 131330f712c9SDave Chinner XFS_BMAP_BTREE_REF, &xfs_bmbt_buf_ops); 131430f712c9SDave Chinner if (error) 131530f712c9SDave Chinner return error; 131630f712c9SDave Chinner block = XFS_BUF_TO_BLOCK(bp); 131730f712c9SDave Chinner } 1318356a3225SDarrick J. Wong if (i != XFS_IFORK_NEXTENTS(ip, whichfork)) 1319356a3225SDarrick J. Wong return -EFSCORRUPTED; 13205d829300SEric Sandeen ASSERT(i == xfs_iext_count(ifp)); 132130f712c9SDave Chinner XFS_BMAP_TRACE_EXLIST(ip, i, whichfork); 132230f712c9SDave Chinner return 0; 132330f712c9SDave Chinner error0: 132430f712c9SDave Chinner xfs_trans_brelse(tp, bp); 13252451337dSDave Chinner return -EFSCORRUPTED; 132630f712c9SDave Chinner } 132730f712c9SDave Chinner 132830f712c9SDave Chinner /* 132930f712c9SDave Chinner * Returns the file-relative block number of the first unused block(s) 133030f712c9SDave Chinner * in the file with at least "len" logically contiguous blocks free. 133130f712c9SDave Chinner * This is the lowest-address hole if the file has holes, else the first block 133230f712c9SDave Chinner * past the end of file. 133330f712c9SDave Chinner * Return 0 if the file is currently local (in-inode). 133430f712c9SDave Chinner */ 133530f712c9SDave Chinner int /* error */ 133630f712c9SDave Chinner xfs_bmap_first_unused( 133730f712c9SDave Chinner xfs_trans_t *tp, /* transaction pointer */ 133830f712c9SDave Chinner xfs_inode_t *ip, /* incore inode */ 133930f712c9SDave Chinner xfs_extlen_t len, /* size of hole to find */ 134030f712c9SDave Chinner xfs_fileoff_t *first_unused, /* unused block */ 134130f712c9SDave Chinner int whichfork) /* data or attr fork */ 134230f712c9SDave Chinner { 134330f712c9SDave Chinner int error; /* error return value */ 134430f712c9SDave Chinner int idx; /* extent record index */ 134530f712c9SDave Chinner xfs_ifork_t *ifp; /* inode fork pointer */ 134630f712c9SDave Chinner xfs_fileoff_t lastaddr; /* last block number seen */ 134730f712c9SDave Chinner xfs_fileoff_t lowest; /* lowest useful block */ 134830f712c9SDave Chinner xfs_fileoff_t max; /* starting useful block */ 134930f712c9SDave Chinner xfs_extnum_t nextents; /* number of extent entries */ 135030f712c9SDave Chinner 135130f712c9SDave Chinner ASSERT(XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_BTREE || 135230f712c9SDave Chinner XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_EXTENTS || 135330f712c9SDave Chinner XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_LOCAL); 135430f712c9SDave Chinner if (XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_LOCAL) { 135530f712c9SDave Chinner *first_unused = 0; 135630f712c9SDave Chinner return 0; 135730f712c9SDave Chinner } 135830f712c9SDave Chinner ifp = XFS_IFORK_PTR(ip, whichfork); 135930f712c9SDave Chinner if (!(ifp->if_flags & XFS_IFEXTENTS) && 136030f712c9SDave Chinner (error = xfs_iread_extents(tp, ip, whichfork))) 136130f712c9SDave Chinner return error; 136230f712c9SDave Chinner lowest = *first_unused; 13635d829300SEric Sandeen nextents = xfs_iext_count(ifp); 136430f712c9SDave Chinner for (idx = 0, lastaddr = 0, max = lowest; idx < nextents; idx++) { 1365f2285c14SChristoph Hellwig struct xfs_bmbt_irec got; 1366f2285c14SChristoph Hellwig 1367f2285c14SChristoph Hellwig xfs_iext_get_extent(ifp, idx, &got); 1368f2285c14SChristoph Hellwig 136930f712c9SDave Chinner /* 137030f712c9SDave Chinner * See if the hole before this extent will work. 137130f712c9SDave Chinner */ 1372f2285c14SChristoph Hellwig if (got.br_startoff >= lowest + len && 1373f2285c14SChristoph Hellwig got.br_startoff - max >= len) { 137430f712c9SDave Chinner *first_unused = max; 137530f712c9SDave Chinner return 0; 137630f712c9SDave Chinner } 1377f2285c14SChristoph Hellwig lastaddr = got.br_startoff + got.br_blockcount; 137830f712c9SDave Chinner max = XFS_FILEOFF_MAX(lastaddr, lowest); 137930f712c9SDave Chinner } 138030f712c9SDave Chinner *first_unused = max; 138130f712c9SDave Chinner return 0; 138230f712c9SDave Chinner } 138330f712c9SDave Chinner 138430f712c9SDave Chinner /* 138530f712c9SDave Chinner * Returns the file-relative block number of the last block - 1 before 138630f712c9SDave Chinner * last_block (input value) in the file. 138730f712c9SDave Chinner * This is not based on i_size, it is based on the extent records. 138830f712c9SDave Chinner * Returns 0 for local files, as they do not have extent records. 138930f712c9SDave Chinner */ 139030f712c9SDave Chinner int /* error */ 139130f712c9SDave Chinner xfs_bmap_last_before( 139286685f7bSChristoph Hellwig struct xfs_trans *tp, /* transaction pointer */ 139386685f7bSChristoph Hellwig struct xfs_inode *ip, /* incore inode */ 139430f712c9SDave Chinner xfs_fileoff_t *last_block, /* last block */ 139530f712c9SDave Chinner int whichfork) /* data or attr fork */ 139630f712c9SDave Chinner { 139786685f7bSChristoph Hellwig struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, whichfork); 139886685f7bSChristoph Hellwig struct xfs_bmbt_irec got; 139986685f7bSChristoph Hellwig xfs_extnum_t idx; 140086685f7bSChristoph Hellwig int error; 140130f712c9SDave Chinner 140286685f7bSChristoph Hellwig switch (XFS_IFORK_FORMAT(ip, whichfork)) { 140386685f7bSChristoph Hellwig case XFS_DINODE_FMT_LOCAL: 140430f712c9SDave Chinner *last_block = 0; 140530f712c9SDave Chinner return 0; 140686685f7bSChristoph Hellwig case XFS_DINODE_FMT_BTREE: 140786685f7bSChristoph Hellwig case XFS_DINODE_FMT_EXTENTS: 140886685f7bSChristoph Hellwig break; 140986685f7bSChristoph Hellwig default: 141086685f7bSChristoph Hellwig return -EIO; 141130f712c9SDave Chinner } 141286685f7bSChristoph Hellwig 141386685f7bSChristoph Hellwig if (!(ifp->if_flags & XFS_IFEXTENTS)) { 141486685f7bSChristoph Hellwig error = xfs_iread_extents(tp, ip, whichfork); 141586685f7bSChristoph Hellwig if (error) 141630f712c9SDave Chinner return error; 141730f712c9SDave Chinner } 141886685f7bSChristoph Hellwig 141986685f7bSChristoph Hellwig if (xfs_iext_lookup_extent(ip, ifp, *last_block - 1, &idx, &got)) { 142086685f7bSChristoph Hellwig if (got.br_startoff <= *last_block - 1) 142186685f7bSChristoph Hellwig return 0; 142286685f7bSChristoph Hellwig } 142386685f7bSChristoph Hellwig 142486685f7bSChristoph Hellwig if (xfs_iext_get_extent(ifp, idx - 1, &got)) { 142586685f7bSChristoph Hellwig *last_block = got.br_startoff + got.br_blockcount; 142686685f7bSChristoph Hellwig return 0; 142786685f7bSChristoph Hellwig } 142886685f7bSChristoph Hellwig 142986685f7bSChristoph Hellwig *last_block = 0; 143030f712c9SDave Chinner return 0; 143130f712c9SDave Chinner } 143230f712c9SDave Chinner 143330f712c9SDave Chinner int 143430f712c9SDave Chinner xfs_bmap_last_extent( 143530f712c9SDave Chinner struct xfs_trans *tp, 143630f712c9SDave Chinner struct xfs_inode *ip, 143730f712c9SDave Chinner int whichfork, 143830f712c9SDave Chinner struct xfs_bmbt_irec *rec, 143930f712c9SDave Chinner int *is_empty) 144030f712c9SDave Chinner { 144130f712c9SDave Chinner struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, whichfork); 144230f712c9SDave Chinner int error; 144330f712c9SDave Chinner int nextents; 144430f712c9SDave Chinner 144530f712c9SDave Chinner if (!(ifp->if_flags & XFS_IFEXTENTS)) { 144630f712c9SDave Chinner error = xfs_iread_extents(tp, ip, whichfork); 144730f712c9SDave Chinner if (error) 144830f712c9SDave Chinner return error; 144930f712c9SDave Chinner } 145030f712c9SDave Chinner 14515d829300SEric Sandeen nextents = xfs_iext_count(ifp); 145230f712c9SDave Chinner if (nextents == 0) { 145330f712c9SDave Chinner *is_empty = 1; 145430f712c9SDave Chinner return 0; 145530f712c9SDave Chinner } 145630f712c9SDave Chinner 145730f712c9SDave Chinner xfs_bmbt_get_all(xfs_iext_get_ext(ifp, nextents - 1), rec); 145830f712c9SDave Chinner *is_empty = 0; 145930f712c9SDave Chinner return 0; 146030f712c9SDave Chinner } 146130f712c9SDave Chinner 146230f712c9SDave Chinner /* 146330f712c9SDave Chinner * Check the last inode extent to determine whether this allocation will result 146430f712c9SDave Chinner * in blocks being allocated at the end of the file. When we allocate new data 146530f712c9SDave Chinner * blocks at the end of the file which do not start at the previous data block, 146630f712c9SDave Chinner * we will try to align the new blocks at stripe unit boundaries. 146730f712c9SDave Chinner * 146830f712c9SDave Chinner * Returns 1 in bma->aeof if the file (fork) is empty as any new write will be 146930f712c9SDave Chinner * at, or past the EOF. 147030f712c9SDave Chinner */ 147130f712c9SDave Chinner STATIC int 147230f712c9SDave Chinner xfs_bmap_isaeof( 147330f712c9SDave Chinner struct xfs_bmalloca *bma, 147430f712c9SDave Chinner int whichfork) 147530f712c9SDave Chinner { 147630f712c9SDave Chinner struct xfs_bmbt_irec rec; 147730f712c9SDave Chinner int is_empty; 147830f712c9SDave Chinner int error; 147930f712c9SDave Chinner 1480749f24f3SThomas Meyer bma->aeof = false; 148130f712c9SDave Chinner error = xfs_bmap_last_extent(NULL, bma->ip, whichfork, &rec, 148230f712c9SDave Chinner &is_empty); 148330f712c9SDave Chinner if (error) 148430f712c9SDave Chinner return error; 148530f712c9SDave Chinner 148630f712c9SDave Chinner if (is_empty) { 1487749f24f3SThomas Meyer bma->aeof = true; 148830f712c9SDave Chinner return 0; 148930f712c9SDave Chinner } 149030f712c9SDave Chinner 149130f712c9SDave Chinner /* 149230f712c9SDave Chinner * Check if we are allocation or past the last extent, or at least into 149330f712c9SDave Chinner * the last delayed allocated extent. 149430f712c9SDave Chinner */ 149530f712c9SDave Chinner bma->aeof = bma->offset >= rec.br_startoff + rec.br_blockcount || 149630f712c9SDave Chinner (bma->offset >= rec.br_startoff && 149730f712c9SDave Chinner isnullstartblock(rec.br_startblock)); 149830f712c9SDave Chinner return 0; 149930f712c9SDave Chinner } 150030f712c9SDave Chinner 150130f712c9SDave Chinner /* 150230f712c9SDave Chinner * Returns the file-relative block number of the first block past eof in 150330f712c9SDave Chinner * the file. This is not based on i_size, it is based on the extent records. 150430f712c9SDave Chinner * Returns 0 for local files, as they do not have extent records. 150530f712c9SDave Chinner */ 150630f712c9SDave Chinner int 150730f712c9SDave Chinner xfs_bmap_last_offset( 150830f712c9SDave Chinner struct xfs_inode *ip, 150930f712c9SDave Chinner xfs_fileoff_t *last_block, 151030f712c9SDave Chinner int whichfork) 151130f712c9SDave Chinner { 151230f712c9SDave Chinner struct xfs_bmbt_irec rec; 151330f712c9SDave Chinner int is_empty; 151430f712c9SDave Chinner int error; 151530f712c9SDave Chinner 151630f712c9SDave Chinner *last_block = 0; 151730f712c9SDave Chinner 151830f712c9SDave Chinner if (XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_LOCAL) 151930f712c9SDave Chinner return 0; 152030f712c9SDave Chinner 152130f712c9SDave Chinner if (XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE && 152230f712c9SDave Chinner XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS) 15232451337dSDave Chinner return -EIO; 152430f712c9SDave Chinner 152530f712c9SDave Chinner error = xfs_bmap_last_extent(NULL, ip, whichfork, &rec, &is_empty); 152630f712c9SDave Chinner if (error || is_empty) 152730f712c9SDave Chinner return error; 152830f712c9SDave Chinner 152930f712c9SDave Chinner *last_block = rec.br_startoff + rec.br_blockcount; 153030f712c9SDave Chinner return 0; 153130f712c9SDave Chinner } 153230f712c9SDave Chinner 153330f712c9SDave Chinner /* 153430f712c9SDave Chinner * Returns whether the selected fork of the inode has exactly one 153530f712c9SDave Chinner * block or not. For the data fork we check this matches di_size, 153630f712c9SDave Chinner * implying the file's range is 0..bsize-1. 153730f712c9SDave Chinner */ 153830f712c9SDave Chinner int /* 1=>1 block, 0=>otherwise */ 153930f712c9SDave Chinner xfs_bmap_one_block( 154030f712c9SDave Chinner xfs_inode_t *ip, /* incore inode */ 154130f712c9SDave Chinner int whichfork) /* data or attr fork */ 154230f712c9SDave Chinner { 154330f712c9SDave Chinner xfs_bmbt_rec_host_t *ep; /* ptr to fork's extent */ 154430f712c9SDave Chinner xfs_ifork_t *ifp; /* inode fork pointer */ 154530f712c9SDave Chinner int rval; /* return value */ 154630f712c9SDave Chinner xfs_bmbt_irec_t s; /* internal version of extent */ 154730f712c9SDave Chinner 154830f712c9SDave Chinner #ifndef DEBUG 154930f712c9SDave Chinner if (whichfork == XFS_DATA_FORK) 155030f712c9SDave Chinner return XFS_ISIZE(ip) == ip->i_mount->m_sb.sb_blocksize; 155130f712c9SDave Chinner #endif /* !DEBUG */ 155230f712c9SDave Chinner if (XFS_IFORK_NEXTENTS(ip, whichfork) != 1) 155330f712c9SDave Chinner return 0; 155430f712c9SDave Chinner if (XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS) 155530f712c9SDave Chinner return 0; 155630f712c9SDave Chinner ifp = XFS_IFORK_PTR(ip, whichfork); 155730f712c9SDave Chinner ASSERT(ifp->if_flags & XFS_IFEXTENTS); 155830f712c9SDave Chinner ep = xfs_iext_get_ext(ifp, 0); 155930f712c9SDave Chinner xfs_bmbt_get_all(ep, &s); 156030f712c9SDave Chinner rval = s.br_startoff == 0 && s.br_blockcount == 1; 156130f712c9SDave Chinner if (rval && whichfork == XFS_DATA_FORK) 156230f712c9SDave Chinner ASSERT(XFS_ISIZE(ip) == ip->i_mount->m_sb.sb_blocksize); 156330f712c9SDave Chinner return rval; 156430f712c9SDave Chinner } 156530f712c9SDave Chinner 156630f712c9SDave Chinner /* 156730f712c9SDave Chinner * Extent tree manipulation functions used during allocation. 156830f712c9SDave Chinner */ 156930f712c9SDave Chinner 157030f712c9SDave Chinner /* 157130f712c9SDave Chinner * Convert a delayed allocation to a real allocation. 157230f712c9SDave Chinner */ 157330f712c9SDave Chinner STATIC int /* error */ 157430f712c9SDave Chinner xfs_bmap_add_extent_delay_real( 157560b4984fSDarrick J. Wong struct xfs_bmalloca *bma, 157660b4984fSDarrick J. Wong int whichfork) 157730f712c9SDave Chinner { 157830f712c9SDave Chinner struct xfs_bmbt_irec *new = &bma->got; 157930f712c9SDave Chinner int diff; /* temp value */ 158030f712c9SDave Chinner xfs_bmbt_rec_host_t *ep; /* extent entry for idx */ 158130f712c9SDave Chinner int error; /* error return value */ 158230f712c9SDave Chinner int i; /* temp state */ 158330f712c9SDave Chinner xfs_ifork_t *ifp; /* inode fork pointer */ 158430f712c9SDave Chinner xfs_fileoff_t new_endoff; /* end offset of new entry */ 158530f712c9SDave Chinner xfs_bmbt_irec_t r[3]; /* neighbor extent entries */ 158630f712c9SDave Chinner /* left is 0, right is 1, prev is 2 */ 158730f712c9SDave Chinner int rval=0; /* return value (logging flags) */ 158830f712c9SDave Chinner int state = 0;/* state bits, accessed thru macros */ 158930f712c9SDave Chinner xfs_filblks_t da_new; /* new count del alloc blocks used */ 159030f712c9SDave Chinner xfs_filblks_t da_old; /* old count del alloc blocks used */ 159130f712c9SDave Chinner xfs_filblks_t temp=0; /* value for da_new calculations */ 159230f712c9SDave Chinner xfs_filblks_t temp2=0;/* value for da_new calculations */ 159330f712c9SDave Chinner int tmp_rval; /* partial logging flags */ 1594c29aad41SEric Sandeen struct xfs_mount *mp; 159560b4984fSDarrick J. Wong xfs_extnum_t *nextents; 159630f712c9SDave Chinner 1597f1f96c49SEric Sandeen mp = bma->ip->i_mount; 15986d3eb1ecSDarrick J. Wong ifp = XFS_IFORK_PTR(bma->ip, whichfork); 159960b4984fSDarrick J. Wong ASSERT(whichfork != XFS_ATTR_FORK); 160060b4984fSDarrick J. Wong nextents = (whichfork == XFS_COW_FORK ? &bma->ip->i_cnextents : 160160b4984fSDarrick J. Wong &bma->ip->i_d.di_nextents); 160230f712c9SDave Chinner 160330f712c9SDave Chinner ASSERT(bma->idx >= 0); 16045d829300SEric Sandeen ASSERT(bma->idx <= xfs_iext_count(ifp)); 160530f712c9SDave Chinner ASSERT(!isnullstartblock(new->br_startblock)); 160630f712c9SDave Chinner ASSERT(!bma->cur || 160730f712c9SDave Chinner (bma->cur->bc_private.b.flags & XFS_BTCUR_BPRV_WASDEL)); 160830f712c9SDave Chinner 1609ff6d6af2SBill O'Donnell XFS_STATS_INC(mp, xs_add_exlist); 161030f712c9SDave Chinner 161130f712c9SDave Chinner #define LEFT r[0] 161230f712c9SDave Chinner #define RIGHT r[1] 161330f712c9SDave Chinner #define PREV r[2] 161430f712c9SDave Chinner 161560b4984fSDarrick J. Wong if (whichfork == XFS_COW_FORK) 161660b4984fSDarrick J. Wong state |= BMAP_COWFORK; 161760b4984fSDarrick J. Wong 161830f712c9SDave Chinner /* 161930f712c9SDave Chinner * Set up a bunch of variables to make the tests simpler. 162030f712c9SDave Chinner */ 162130f712c9SDave Chinner ep = xfs_iext_get_ext(ifp, bma->idx); 162230f712c9SDave Chinner xfs_bmbt_get_all(ep, &PREV); 162330f712c9SDave Chinner new_endoff = new->br_startoff + new->br_blockcount; 162430f712c9SDave Chinner ASSERT(PREV.br_startoff <= new->br_startoff); 162530f712c9SDave Chinner ASSERT(PREV.br_startoff + PREV.br_blockcount >= new_endoff); 162630f712c9SDave Chinner 162730f712c9SDave Chinner da_old = startblockval(PREV.br_startblock); 162830f712c9SDave Chinner da_new = 0; 162930f712c9SDave Chinner 163030f712c9SDave Chinner /* 163130f712c9SDave Chinner * Set flags determining what part of the previous delayed allocation 163230f712c9SDave Chinner * extent is being replaced by a real allocation. 163330f712c9SDave Chinner */ 163430f712c9SDave Chinner if (PREV.br_startoff == new->br_startoff) 163530f712c9SDave Chinner state |= BMAP_LEFT_FILLING; 163630f712c9SDave Chinner if (PREV.br_startoff + PREV.br_blockcount == new_endoff) 163730f712c9SDave Chinner state |= BMAP_RIGHT_FILLING; 163830f712c9SDave Chinner 163930f712c9SDave Chinner /* 164030f712c9SDave Chinner * Check and set flags if this segment has a left neighbor. 164130f712c9SDave Chinner * Don't set contiguous if the combined extent would be too large. 164230f712c9SDave Chinner */ 164330f712c9SDave Chinner if (bma->idx > 0) { 164430f712c9SDave Chinner state |= BMAP_LEFT_VALID; 164530f712c9SDave Chinner xfs_bmbt_get_all(xfs_iext_get_ext(ifp, bma->idx - 1), &LEFT); 164630f712c9SDave Chinner 164730f712c9SDave Chinner if (isnullstartblock(LEFT.br_startblock)) 164830f712c9SDave Chinner state |= BMAP_LEFT_DELAY; 164930f712c9SDave Chinner } 165030f712c9SDave Chinner 165130f712c9SDave Chinner if ((state & BMAP_LEFT_VALID) && !(state & BMAP_LEFT_DELAY) && 165230f712c9SDave Chinner LEFT.br_startoff + LEFT.br_blockcount == new->br_startoff && 165330f712c9SDave Chinner LEFT.br_startblock + LEFT.br_blockcount == new->br_startblock && 165430f712c9SDave Chinner LEFT.br_state == new->br_state && 165530f712c9SDave Chinner LEFT.br_blockcount + new->br_blockcount <= MAXEXTLEN) 165630f712c9SDave Chinner state |= BMAP_LEFT_CONTIG; 165730f712c9SDave Chinner 165830f712c9SDave Chinner /* 165930f712c9SDave Chinner * Check and set flags if this segment has a right neighbor. 166030f712c9SDave Chinner * Don't set contiguous if the combined extent would be too large. 166130f712c9SDave Chinner * Also check for all-three-contiguous being too large. 166230f712c9SDave Chinner */ 16635d829300SEric Sandeen if (bma->idx < xfs_iext_count(ifp) - 1) { 166430f712c9SDave Chinner state |= BMAP_RIGHT_VALID; 166530f712c9SDave Chinner xfs_bmbt_get_all(xfs_iext_get_ext(ifp, bma->idx + 1), &RIGHT); 166630f712c9SDave Chinner 166730f712c9SDave Chinner if (isnullstartblock(RIGHT.br_startblock)) 166830f712c9SDave Chinner state |= BMAP_RIGHT_DELAY; 166930f712c9SDave Chinner } 167030f712c9SDave Chinner 167130f712c9SDave Chinner if ((state & BMAP_RIGHT_VALID) && !(state & BMAP_RIGHT_DELAY) && 167230f712c9SDave Chinner new_endoff == RIGHT.br_startoff && 167330f712c9SDave Chinner new->br_startblock + new->br_blockcount == RIGHT.br_startblock && 167430f712c9SDave Chinner new->br_state == RIGHT.br_state && 167530f712c9SDave Chinner new->br_blockcount + RIGHT.br_blockcount <= MAXEXTLEN && 167630f712c9SDave Chinner ((state & (BMAP_LEFT_CONTIG | BMAP_LEFT_FILLING | 167730f712c9SDave Chinner BMAP_RIGHT_FILLING)) != 167830f712c9SDave Chinner (BMAP_LEFT_CONTIG | BMAP_LEFT_FILLING | 167930f712c9SDave Chinner BMAP_RIGHT_FILLING) || 168030f712c9SDave Chinner LEFT.br_blockcount + new->br_blockcount + RIGHT.br_blockcount 168130f712c9SDave Chinner <= MAXEXTLEN)) 168230f712c9SDave Chinner state |= BMAP_RIGHT_CONTIG; 168330f712c9SDave Chinner 168430f712c9SDave Chinner error = 0; 168530f712c9SDave Chinner /* 168630f712c9SDave Chinner * Switch out based on the FILLING and CONTIG state bits. 168730f712c9SDave Chinner */ 168830f712c9SDave Chinner switch (state & (BMAP_LEFT_FILLING | BMAP_LEFT_CONTIG | 168930f712c9SDave Chinner BMAP_RIGHT_FILLING | BMAP_RIGHT_CONTIG)) { 169030f712c9SDave Chinner case BMAP_LEFT_FILLING | BMAP_LEFT_CONTIG | 169130f712c9SDave Chinner BMAP_RIGHT_FILLING | BMAP_RIGHT_CONTIG: 169230f712c9SDave Chinner /* 169330f712c9SDave Chinner * Filling in all of a previously delayed allocation extent. 169430f712c9SDave Chinner * The left and right neighbors are both contiguous with new. 169530f712c9SDave Chinner */ 169630f712c9SDave Chinner bma->idx--; 169730f712c9SDave Chinner trace_xfs_bmap_pre_update(bma->ip, bma->idx, state, _THIS_IP_); 169830f712c9SDave Chinner xfs_bmbt_set_blockcount(xfs_iext_get_ext(ifp, bma->idx), 169930f712c9SDave Chinner LEFT.br_blockcount + PREV.br_blockcount + 170030f712c9SDave Chinner RIGHT.br_blockcount); 170130f712c9SDave Chinner trace_xfs_bmap_post_update(bma->ip, bma->idx, state, _THIS_IP_); 170230f712c9SDave Chinner 170330f712c9SDave Chinner xfs_iext_remove(bma->ip, bma->idx + 1, 2, state); 170460b4984fSDarrick J. Wong (*nextents)--; 170530f712c9SDave Chinner if (bma->cur == NULL) 170630f712c9SDave Chinner rval = XFS_ILOG_CORE | XFS_ILOG_DEXT; 170730f712c9SDave Chinner else { 170830f712c9SDave Chinner rval = XFS_ILOG_CORE; 170930f712c9SDave Chinner error = xfs_bmbt_lookup_eq(bma->cur, RIGHT.br_startoff, 171030f712c9SDave Chinner RIGHT.br_startblock, 171130f712c9SDave Chinner RIGHT.br_blockcount, &i); 171230f712c9SDave Chinner if (error) 171330f712c9SDave Chinner goto done; 1714c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 171530f712c9SDave Chinner error = xfs_btree_delete(bma->cur, &i); 171630f712c9SDave Chinner if (error) 171730f712c9SDave Chinner goto done; 1718c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 171930f712c9SDave Chinner error = xfs_btree_decrement(bma->cur, 0, &i); 172030f712c9SDave Chinner if (error) 172130f712c9SDave Chinner goto done; 1722c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 172330f712c9SDave Chinner error = xfs_bmbt_update(bma->cur, LEFT.br_startoff, 172430f712c9SDave Chinner LEFT.br_startblock, 172530f712c9SDave Chinner LEFT.br_blockcount + 172630f712c9SDave Chinner PREV.br_blockcount + 172730f712c9SDave Chinner RIGHT.br_blockcount, LEFT.br_state); 172830f712c9SDave Chinner if (error) 172930f712c9SDave Chinner goto done; 173030f712c9SDave Chinner } 173130f712c9SDave Chinner break; 173230f712c9SDave Chinner 173330f712c9SDave Chinner case BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING | BMAP_LEFT_CONTIG: 173430f712c9SDave Chinner /* 173530f712c9SDave Chinner * Filling in all of a previously delayed allocation extent. 173630f712c9SDave Chinner * The left neighbor is contiguous, the right is not. 173730f712c9SDave Chinner */ 173830f712c9SDave Chinner bma->idx--; 173930f712c9SDave Chinner 174030f712c9SDave Chinner trace_xfs_bmap_pre_update(bma->ip, bma->idx, state, _THIS_IP_); 174130f712c9SDave Chinner xfs_bmbt_set_blockcount(xfs_iext_get_ext(ifp, bma->idx), 174230f712c9SDave Chinner LEFT.br_blockcount + PREV.br_blockcount); 174330f712c9SDave Chinner trace_xfs_bmap_post_update(bma->ip, bma->idx, state, _THIS_IP_); 174430f712c9SDave Chinner 174530f712c9SDave Chinner xfs_iext_remove(bma->ip, bma->idx + 1, 1, state); 174630f712c9SDave Chinner if (bma->cur == NULL) 174730f712c9SDave Chinner rval = XFS_ILOG_DEXT; 174830f712c9SDave Chinner else { 174930f712c9SDave Chinner rval = 0; 175030f712c9SDave Chinner error = xfs_bmbt_lookup_eq(bma->cur, LEFT.br_startoff, 175130f712c9SDave Chinner LEFT.br_startblock, LEFT.br_blockcount, 175230f712c9SDave Chinner &i); 175330f712c9SDave Chinner if (error) 175430f712c9SDave Chinner goto done; 1755c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 175630f712c9SDave Chinner error = xfs_bmbt_update(bma->cur, LEFT.br_startoff, 175730f712c9SDave Chinner LEFT.br_startblock, 175830f712c9SDave Chinner LEFT.br_blockcount + 175930f712c9SDave Chinner PREV.br_blockcount, LEFT.br_state); 176030f712c9SDave Chinner if (error) 176130f712c9SDave Chinner goto done; 176230f712c9SDave Chinner } 176330f712c9SDave Chinner break; 176430f712c9SDave Chinner 176530f712c9SDave Chinner case BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING | BMAP_RIGHT_CONTIG: 176630f712c9SDave Chinner /* 176730f712c9SDave Chinner * Filling in all of a previously delayed allocation extent. 176830f712c9SDave Chinner * The right neighbor is contiguous, the left is not. 176930f712c9SDave Chinner */ 177030f712c9SDave Chinner trace_xfs_bmap_pre_update(bma->ip, bma->idx, state, _THIS_IP_); 177130f712c9SDave Chinner xfs_bmbt_set_startblock(ep, new->br_startblock); 177230f712c9SDave Chinner xfs_bmbt_set_blockcount(ep, 177330f712c9SDave Chinner PREV.br_blockcount + RIGHT.br_blockcount); 177430f712c9SDave Chinner trace_xfs_bmap_post_update(bma->ip, bma->idx, state, _THIS_IP_); 177530f712c9SDave Chinner 177630f712c9SDave Chinner xfs_iext_remove(bma->ip, bma->idx + 1, 1, state); 177730f712c9SDave Chinner if (bma->cur == NULL) 177830f712c9SDave Chinner rval = XFS_ILOG_DEXT; 177930f712c9SDave Chinner else { 178030f712c9SDave Chinner rval = 0; 178130f712c9SDave Chinner error = xfs_bmbt_lookup_eq(bma->cur, RIGHT.br_startoff, 178230f712c9SDave Chinner RIGHT.br_startblock, 178330f712c9SDave Chinner RIGHT.br_blockcount, &i); 178430f712c9SDave Chinner if (error) 178530f712c9SDave Chinner goto done; 1786c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 178730f712c9SDave Chinner error = xfs_bmbt_update(bma->cur, PREV.br_startoff, 178830f712c9SDave Chinner new->br_startblock, 178930f712c9SDave Chinner PREV.br_blockcount + 179030f712c9SDave Chinner RIGHT.br_blockcount, PREV.br_state); 179130f712c9SDave Chinner if (error) 179230f712c9SDave Chinner goto done; 179330f712c9SDave Chinner } 179430f712c9SDave Chinner break; 179530f712c9SDave Chinner 179630f712c9SDave Chinner case BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING: 179730f712c9SDave Chinner /* 179830f712c9SDave Chinner * Filling in all of a previously delayed allocation extent. 179930f712c9SDave Chinner * Neither the left nor right neighbors are contiguous with 180030f712c9SDave Chinner * the new one. 180130f712c9SDave Chinner */ 180230f712c9SDave Chinner trace_xfs_bmap_pre_update(bma->ip, bma->idx, state, _THIS_IP_); 180330f712c9SDave Chinner xfs_bmbt_set_startblock(ep, new->br_startblock); 180405a630d7SDarrick J. Wong xfs_bmbt_set_state(ep, new->br_state); 180530f712c9SDave Chinner trace_xfs_bmap_post_update(bma->ip, bma->idx, state, _THIS_IP_); 180630f712c9SDave Chinner 180760b4984fSDarrick J. Wong (*nextents)++; 180830f712c9SDave Chinner if (bma->cur == NULL) 180930f712c9SDave Chinner rval = XFS_ILOG_CORE | XFS_ILOG_DEXT; 181030f712c9SDave Chinner else { 181130f712c9SDave Chinner rval = XFS_ILOG_CORE; 181230f712c9SDave Chinner error = xfs_bmbt_lookup_eq(bma->cur, new->br_startoff, 181330f712c9SDave Chinner new->br_startblock, new->br_blockcount, 181430f712c9SDave Chinner &i); 181530f712c9SDave Chinner if (error) 181630f712c9SDave Chinner goto done; 1817c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 0, done); 181830f712c9SDave Chinner bma->cur->bc_rec.b.br_state = XFS_EXT_NORM; 181930f712c9SDave Chinner error = xfs_btree_insert(bma->cur, &i); 182030f712c9SDave Chinner if (error) 182130f712c9SDave Chinner goto done; 1822c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 182330f712c9SDave Chinner } 182430f712c9SDave Chinner break; 182530f712c9SDave Chinner 182630f712c9SDave Chinner case BMAP_LEFT_FILLING | BMAP_LEFT_CONTIG: 182730f712c9SDave Chinner /* 182830f712c9SDave Chinner * Filling in the first part of a previous delayed allocation. 182930f712c9SDave Chinner * The left neighbor is contiguous. 183030f712c9SDave Chinner */ 183130f712c9SDave Chinner trace_xfs_bmap_pre_update(bma->ip, bma->idx - 1, state, _THIS_IP_); 183230f712c9SDave Chinner xfs_bmbt_set_blockcount(xfs_iext_get_ext(ifp, bma->idx - 1), 183330f712c9SDave Chinner LEFT.br_blockcount + new->br_blockcount); 183430f712c9SDave Chinner xfs_bmbt_set_startoff(ep, 183530f712c9SDave Chinner PREV.br_startoff + new->br_blockcount); 183630f712c9SDave Chinner trace_xfs_bmap_post_update(bma->ip, bma->idx - 1, state, _THIS_IP_); 183730f712c9SDave Chinner 183830f712c9SDave Chinner temp = PREV.br_blockcount - new->br_blockcount; 183930f712c9SDave Chinner trace_xfs_bmap_pre_update(bma->ip, bma->idx, state, _THIS_IP_); 184030f712c9SDave Chinner xfs_bmbt_set_blockcount(ep, temp); 184130f712c9SDave Chinner if (bma->cur == NULL) 184230f712c9SDave Chinner rval = XFS_ILOG_DEXT; 184330f712c9SDave Chinner else { 184430f712c9SDave Chinner rval = 0; 184530f712c9SDave Chinner error = xfs_bmbt_lookup_eq(bma->cur, LEFT.br_startoff, 184630f712c9SDave Chinner LEFT.br_startblock, LEFT.br_blockcount, 184730f712c9SDave Chinner &i); 184830f712c9SDave Chinner if (error) 184930f712c9SDave Chinner goto done; 1850c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 185130f712c9SDave Chinner error = xfs_bmbt_update(bma->cur, LEFT.br_startoff, 185230f712c9SDave Chinner LEFT.br_startblock, 185330f712c9SDave Chinner LEFT.br_blockcount + 185430f712c9SDave Chinner new->br_blockcount, 185530f712c9SDave Chinner LEFT.br_state); 185630f712c9SDave Chinner if (error) 185730f712c9SDave Chinner goto done; 185830f712c9SDave Chinner } 185930f712c9SDave Chinner da_new = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(bma->ip, temp), 186030f712c9SDave Chinner startblockval(PREV.br_startblock)); 186130f712c9SDave Chinner xfs_bmbt_set_startblock(ep, nullstartblock(da_new)); 186230f712c9SDave Chinner trace_xfs_bmap_post_update(bma->ip, bma->idx, state, _THIS_IP_); 186330f712c9SDave Chinner 186430f712c9SDave Chinner bma->idx--; 186530f712c9SDave Chinner break; 186630f712c9SDave Chinner 186730f712c9SDave Chinner case BMAP_LEFT_FILLING: 186830f712c9SDave Chinner /* 186930f712c9SDave Chinner * Filling in the first part of a previous delayed allocation. 187030f712c9SDave Chinner * The left neighbor is not contiguous. 187130f712c9SDave Chinner */ 187230f712c9SDave Chinner trace_xfs_bmap_pre_update(bma->ip, bma->idx, state, _THIS_IP_); 187330f712c9SDave Chinner xfs_bmbt_set_startoff(ep, new_endoff); 187430f712c9SDave Chinner temp = PREV.br_blockcount - new->br_blockcount; 187530f712c9SDave Chinner xfs_bmbt_set_blockcount(ep, temp); 187630f712c9SDave Chinner xfs_iext_insert(bma->ip, bma->idx, 1, new, state); 187760b4984fSDarrick J. Wong (*nextents)++; 187830f712c9SDave Chinner if (bma->cur == NULL) 187930f712c9SDave Chinner rval = XFS_ILOG_CORE | XFS_ILOG_DEXT; 188030f712c9SDave Chinner else { 188130f712c9SDave Chinner rval = XFS_ILOG_CORE; 188230f712c9SDave Chinner error = xfs_bmbt_lookup_eq(bma->cur, new->br_startoff, 188330f712c9SDave Chinner new->br_startblock, new->br_blockcount, 188430f712c9SDave Chinner &i); 188530f712c9SDave Chinner if (error) 188630f712c9SDave Chinner goto done; 1887c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 0, done); 188830f712c9SDave Chinner bma->cur->bc_rec.b.br_state = XFS_EXT_NORM; 188930f712c9SDave Chinner error = xfs_btree_insert(bma->cur, &i); 189030f712c9SDave Chinner if (error) 189130f712c9SDave Chinner goto done; 1892c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 189330f712c9SDave Chinner } 189430f712c9SDave Chinner 18956d3eb1ecSDarrick J. Wong if (xfs_bmap_needs_btree(bma->ip, whichfork)) { 189630f712c9SDave Chinner error = xfs_bmap_extents_to_btree(bma->tp, bma->ip, 18972c3234d1SDarrick J. Wong bma->firstblock, bma->dfops, 18986d3eb1ecSDarrick J. Wong &bma->cur, 1, &tmp_rval, whichfork); 189930f712c9SDave Chinner rval |= tmp_rval; 190030f712c9SDave Chinner if (error) 190130f712c9SDave Chinner goto done; 190230f712c9SDave Chinner } 190330f712c9SDave Chinner da_new = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(bma->ip, temp), 190430f712c9SDave Chinner startblockval(PREV.br_startblock) - 190530f712c9SDave Chinner (bma->cur ? bma->cur->bc_private.b.allocated : 0)); 190630f712c9SDave Chinner ep = xfs_iext_get_ext(ifp, bma->idx + 1); 190730f712c9SDave Chinner xfs_bmbt_set_startblock(ep, nullstartblock(da_new)); 190830f712c9SDave Chinner trace_xfs_bmap_post_update(bma->ip, bma->idx + 1, state, _THIS_IP_); 190930f712c9SDave Chinner break; 191030f712c9SDave Chinner 191130f712c9SDave Chinner case BMAP_RIGHT_FILLING | BMAP_RIGHT_CONTIG: 191230f712c9SDave Chinner /* 191330f712c9SDave Chinner * Filling in the last part of a previous delayed allocation. 191430f712c9SDave Chinner * The right neighbor is contiguous with the new allocation. 191530f712c9SDave Chinner */ 191630f712c9SDave Chinner temp = PREV.br_blockcount - new->br_blockcount; 191730f712c9SDave Chinner trace_xfs_bmap_pre_update(bma->ip, bma->idx + 1, state, _THIS_IP_); 191830f712c9SDave Chinner xfs_bmbt_set_blockcount(ep, temp); 191930f712c9SDave Chinner xfs_bmbt_set_allf(xfs_iext_get_ext(ifp, bma->idx + 1), 192030f712c9SDave Chinner new->br_startoff, new->br_startblock, 192130f712c9SDave Chinner new->br_blockcount + RIGHT.br_blockcount, 192230f712c9SDave Chinner RIGHT.br_state); 192330f712c9SDave Chinner trace_xfs_bmap_post_update(bma->ip, bma->idx + 1, state, _THIS_IP_); 192430f712c9SDave Chinner if (bma->cur == NULL) 192530f712c9SDave Chinner rval = XFS_ILOG_DEXT; 192630f712c9SDave Chinner else { 192730f712c9SDave Chinner rval = 0; 192830f712c9SDave Chinner error = xfs_bmbt_lookup_eq(bma->cur, RIGHT.br_startoff, 192930f712c9SDave Chinner RIGHT.br_startblock, 193030f712c9SDave Chinner RIGHT.br_blockcount, &i); 193130f712c9SDave Chinner if (error) 193230f712c9SDave Chinner goto done; 1933c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 193430f712c9SDave Chinner error = xfs_bmbt_update(bma->cur, new->br_startoff, 193530f712c9SDave Chinner new->br_startblock, 193630f712c9SDave Chinner new->br_blockcount + 193730f712c9SDave Chinner RIGHT.br_blockcount, 193830f712c9SDave Chinner RIGHT.br_state); 193930f712c9SDave Chinner if (error) 194030f712c9SDave Chinner goto done; 194130f712c9SDave Chinner } 194230f712c9SDave Chinner 194330f712c9SDave Chinner da_new = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(bma->ip, temp), 194430f712c9SDave Chinner startblockval(PREV.br_startblock)); 194530f712c9SDave Chinner trace_xfs_bmap_pre_update(bma->ip, bma->idx, state, _THIS_IP_); 194630f712c9SDave Chinner xfs_bmbt_set_startblock(ep, nullstartblock(da_new)); 194730f712c9SDave Chinner trace_xfs_bmap_post_update(bma->ip, bma->idx, state, _THIS_IP_); 194830f712c9SDave Chinner 194930f712c9SDave Chinner bma->idx++; 195030f712c9SDave Chinner break; 195130f712c9SDave Chinner 195230f712c9SDave Chinner case BMAP_RIGHT_FILLING: 195330f712c9SDave Chinner /* 195430f712c9SDave Chinner * Filling in the last part of a previous delayed allocation. 195530f712c9SDave Chinner * The right neighbor is not contiguous. 195630f712c9SDave Chinner */ 195730f712c9SDave Chinner temp = PREV.br_blockcount - new->br_blockcount; 195830f712c9SDave Chinner trace_xfs_bmap_pre_update(bma->ip, bma->idx, state, _THIS_IP_); 195930f712c9SDave Chinner xfs_bmbt_set_blockcount(ep, temp); 196030f712c9SDave Chinner xfs_iext_insert(bma->ip, bma->idx + 1, 1, new, state); 196160b4984fSDarrick J. Wong (*nextents)++; 196230f712c9SDave Chinner if (bma->cur == NULL) 196330f712c9SDave Chinner rval = XFS_ILOG_CORE | XFS_ILOG_DEXT; 196430f712c9SDave Chinner else { 196530f712c9SDave Chinner rval = XFS_ILOG_CORE; 196630f712c9SDave Chinner error = xfs_bmbt_lookup_eq(bma->cur, new->br_startoff, 196730f712c9SDave Chinner new->br_startblock, new->br_blockcount, 196830f712c9SDave Chinner &i); 196930f712c9SDave Chinner if (error) 197030f712c9SDave Chinner goto done; 1971c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 0, done); 197230f712c9SDave Chinner bma->cur->bc_rec.b.br_state = XFS_EXT_NORM; 197330f712c9SDave Chinner error = xfs_btree_insert(bma->cur, &i); 197430f712c9SDave Chinner if (error) 197530f712c9SDave Chinner goto done; 1976c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 197730f712c9SDave Chinner } 197830f712c9SDave Chinner 19796d3eb1ecSDarrick J. Wong if (xfs_bmap_needs_btree(bma->ip, whichfork)) { 198030f712c9SDave Chinner error = xfs_bmap_extents_to_btree(bma->tp, bma->ip, 19812c3234d1SDarrick J. Wong bma->firstblock, bma->dfops, &bma->cur, 1, 19826d3eb1ecSDarrick J. Wong &tmp_rval, whichfork); 198330f712c9SDave Chinner rval |= tmp_rval; 198430f712c9SDave Chinner if (error) 198530f712c9SDave Chinner goto done; 198630f712c9SDave Chinner } 198730f712c9SDave Chinner da_new = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(bma->ip, temp), 198830f712c9SDave Chinner startblockval(PREV.br_startblock) - 198930f712c9SDave Chinner (bma->cur ? bma->cur->bc_private.b.allocated : 0)); 199030f712c9SDave Chinner ep = xfs_iext_get_ext(ifp, bma->idx); 199130f712c9SDave Chinner xfs_bmbt_set_startblock(ep, nullstartblock(da_new)); 199230f712c9SDave Chinner trace_xfs_bmap_post_update(bma->ip, bma->idx, state, _THIS_IP_); 199330f712c9SDave Chinner 199430f712c9SDave Chinner bma->idx++; 199530f712c9SDave Chinner break; 199630f712c9SDave Chinner 199730f712c9SDave Chinner case 0: 199830f712c9SDave Chinner /* 199930f712c9SDave Chinner * Filling in the middle part of a previous delayed allocation. 200030f712c9SDave Chinner * Contiguity is impossible here. 200130f712c9SDave Chinner * This case is avoided almost all the time. 200230f712c9SDave Chinner * 200330f712c9SDave Chinner * We start with a delayed allocation: 200430f712c9SDave Chinner * 200530f712c9SDave Chinner * +ddddddddddddddddddddddddddddddddddddddddddddddddddddddd+ 200630f712c9SDave Chinner * PREV @ idx 200730f712c9SDave Chinner * 200830f712c9SDave Chinner * and we are allocating: 200930f712c9SDave Chinner * +rrrrrrrrrrrrrrrrr+ 201030f712c9SDave Chinner * new 201130f712c9SDave Chinner * 201230f712c9SDave Chinner * and we set it up for insertion as: 201330f712c9SDave Chinner * +ddddddddddddddddddd+rrrrrrrrrrrrrrrrr+ddddddddddddddddd+ 201430f712c9SDave Chinner * new 201530f712c9SDave Chinner * PREV @ idx LEFT RIGHT 201630f712c9SDave Chinner * inserted at idx + 1 201730f712c9SDave Chinner */ 201830f712c9SDave Chinner temp = new->br_startoff - PREV.br_startoff; 201930f712c9SDave Chinner temp2 = PREV.br_startoff + PREV.br_blockcount - new_endoff; 202030f712c9SDave Chinner trace_xfs_bmap_pre_update(bma->ip, bma->idx, 0, _THIS_IP_); 202130f712c9SDave Chinner xfs_bmbt_set_blockcount(ep, temp); /* truncate PREV */ 202230f712c9SDave Chinner LEFT = *new; 202330f712c9SDave Chinner RIGHT.br_state = PREV.br_state; 202430f712c9SDave Chinner RIGHT.br_startblock = nullstartblock( 202530f712c9SDave Chinner (int)xfs_bmap_worst_indlen(bma->ip, temp2)); 202630f712c9SDave Chinner RIGHT.br_startoff = new_endoff; 202730f712c9SDave Chinner RIGHT.br_blockcount = temp2; 202830f712c9SDave Chinner /* insert LEFT (r[0]) and RIGHT (r[1]) at the same time */ 202930f712c9SDave Chinner xfs_iext_insert(bma->ip, bma->idx + 1, 2, &LEFT, state); 203060b4984fSDarrick J. Wong (*nextents)++; 203130f712c9SDave Chinner if (bma->cur == NULL) 203230f712c9SDave Chinner rval = XFS_ILOG_CORE | XFS_ILOG_DEXT; 203330f712c9SDave Chinner else { 203430f712c9SDave Chinner rval = XFS_ILOG_CORE; 203530f712c9SDave Chinner error = xfs_bmbt_lookup_eq(bma->cur, new->br_startoff, 203630f712c9SDave Chinner new->br_startblock, new->br_blockcount, 203730f712c9SDave Chinner &i); 203830f712c9SDave Chinner if (error) 203930f712c9SDave Chinner goto done; 2040c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 0, done); 204130f712c9SDave Chinner bma->cur->bc_rec.b.br_state = XFS_EXT_NORM; 204230f712c9SDave Chinner error = xfs_btree_insert(bma->cur, &i); 204330f712c9SDave Chinner if (error) 204430f712c9SDave Chinner goto done; 2045c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 204630f712c9SDave Chinner } 204730f712c9SDave Chinner 20486d3eb1ecSDarrick J. Wong if (xfs_bmap_needs_btree(bma->ip, whichfork)) { 204930f712c9SDave Chinner error = xfs_bmap_extents_to_btree(bma->tp, bma->ip, 20502c3234d1SDarrick J. Wong bma->firstblock, bma->dfops, &bma->cur, 20516d3eb1ecSDarrick J. Wong 1, &tmp_rval, whichfork); 205230f712c9SDave Chinner rval |= tmp_rval; 205330f712c9SDave Chinner if (error) 205430f712c9SDave Chinner goto done; 205530f712c9SDave Chinner } 205630f712c9SDave Chinner temp = xfs_bmap_worst_indlen(bma->ip, temp); 205730f712c9SDave Chinner temp2 = xfs_bmap_worst_indlen(bma->ip, temp2); 20580daaecacSBrian Foster diff = (int)(temp + temp2 - 20590daaecacSBrian Foster (startblockval(PREV.br_startblock) - 20600daaecacSBrian Foster (bma->cur ? 20610daaecacSBrian Foster bma->cur->bc_private.b.allocated : 0))); 206230f712c9SDave Chinner if (diff > 0) { 20630d485adaSDave Chinner error = xfs_mod_fdblocks(bma->ip->i_mount, 20640d485adaSDave Chinner -((int64_t)diff), false); 206530f712c9SDave Chinner ASSERT(!error); 206630f712c9SDave Chinner if (error) 206730f712c9SDave Chinner goto done; 206830f712c9SDave Chinner } 206930f712c9SDave Chinner 207030f712c9SDave Chinner ep = xfs_iext_get_ext(ifp, bma->idx); 207130f712c9SDave Chinner xfs_bmbt_set_startblock(ep, nullstartblock((int)temp)); 207230f712c9SDave Chinner trace_xfs_bmap_post_update(bma->ip, bma->idx, state, _THIS_IP_); 207330f712c9SDave Chinner trace_xfs_bmap_pre_update(bma->ip, bma->idx + 2, state, _THIS_IP_); 207430f712c9SDave Chinner xfs_bmbt_set_startblock(xfs_iext_get_ext(ifp, bma->idx + 2), 207530f712c9SDave Chinner nullstartblock((int)temp2)); 207630f712c9SDave Chinner trace_xfs_bmap_post_update(bma->ip, bma->idx + 2, state, _THIS_IP_); 207730f712c9SDave Chinner 207830f712c9SDave Chinner bma->idx++; 207930f712c9SDave Chinner da_new = temp + temp2; 208030f712c9SDave Chinner break; 208130f712c9SDave Chinner 208230f712c9SDave Chinner case BMAP_LEFT_FILLING | BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG: 208330f712c9SDave Chinner case BMAP_RIGHT_FILLING | BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG: 208430f712c9SDave Chinner case BMAP_LEFT_FILLING | BMAP_RIGHT_CONTIG: 208530f712c9SDave Chinner case BMAP_RIGHT_FILLING | BMAP_LEFT_CONTIG: 208630f712c9SDave Chinner case BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG: 208730f712c9SDave Chinner case BMAP_LEFT_CONTIG: 208830f712c9SDave Chinner case BMAP_RIGHT_CONTIG: 208930f712c9SDave Chinner /* 209030f712c9SDave Chinner * These cases are all impossible. 209130f712c9SDave Chinner */ 209230f712c9SDave Chinner ASSERT(0); 209330f712c9SDave Chinner } 209430f712c9SDave Chinner 20959c194644SDarrick J. Wong /* add reverse mapping */ 20969c194644SDarrick J. Wong error = xfs_rmap_map_extent(mp, bma->dfops, bma->ip, whichfork, new); 20979c194644SDarrick J. Wong if (error) 20989c194644SDarrick J. Wong goto done; 20999c194644SDarrick J. Wong 210030f712c9SDave Chinner /* convert to a btree if necessary */ 21016d3eb1ecSDarrick J. Wong if (xfs_bmap_needs_btree(bma->ip, whichfork)) { 210230f712c9SDave Chinner int tmp_logflags; /* partial log flag return val */ 210330f712c9SDave Chinner 210430f712c9SDave Chinner ASSERT(bma->cur == NULL); 210530f712c9SDave Chinner error = xfs_bmap_extents_to_btree(bma->tp, bma->ip, 21062c3234d1SDarrick J. Wong bma->firstblock, bma->dfops, &bma->cur, 21076d3eb1ecSDarrick J. Wong da_old > 0, &tmp_logflags, whichfork); 210830f712c9SDave Chinner bma->logflags |= tmp_logflags; 210930f712c9SDave Chinner if (error) 211030f712c9SDave Chinner goto done; 211130f712c9SDave Chinner } 211230f712c9SDave Chinner 211330f712c9SDave Chinner /* adjust for changes in reserved delayed indirect blocks */ 211430f712c9SDave Chinner if (da_old || da_new) { 211530f712c9SDave Chinner temp = da_new; 211630f712c9SDave Chinner if (bma->cur) 211730f712c9SDave Chinner temp += bma->cur->bc_private.b.allocated; 211830f712c9SDave Chinner if (temp < da_old) 21190d485adaSDave Chinner xfs_mod_fdblocks(bma->ip->i_mount, 21200d485adaSDave Chinner (int64_t)(da_old - temp), false); 212130f712c9SDave Chinner } 212230f712c9SDave Chinner 212330f712c9SDave Chinner /* clear out the allocated field, done with it now in any case. */ 212430f712c9SDave Chinner if (bma->cur) 212530f712c9SDave Chinner bma->cur->bc_private.b.allocated = 0; 212630f712c9SDave Chinner 21276d3eb1ecSDarrick J. Wong xfs_bmap_check_leaf_extents(bma->cur, bma->ip, whichfork); 212830f712c9SDave Chinner done: 212960b4984fSDarrick J. Wong if (whichfork != XFS_COW_FORK) 213030f712c9SDave Chinner bma->logflags |= rval; 213130f712c9SDave Chinner return error; 213230f712c9SDave Chinner #undef LEFT 213330f712c9SDave Chinner #undef RIGHT 213430f712c9SDave Chinner #undef PREV 213530f712c9SDave Chinner } 213630f712c9SDave Chinner 213730f712c9SDave Chinner /* 213830f712c9SDave Chinner * Convert an unwritten allocation to a real allocation or vice versa. 213930f712c9SDave Chinner */ 214030f712c9SDave Chinner STATIC int /* error */ 214130f712c9SDave Chinner xfs_bmap_add_extent_unwritten_real( 214230f712c9SDave Chinner struct xfs_trans *tp, 214330f712c9SDave Chinner xfs_inode_t *ip, /* incore inode pointer */ 214405a630d7SDarrick J. Wong int whichfork, 214530f712c9SDave Chinner xfs_extnum_t *idx, /* extent number to update/insert */ 214630f712c9SDave Chinner xfs_btree_cur_t **curp, /* if *curp is null, not a btree */ 214730f712c9SDave Chinner xfs_bmbt_irec_t *new, /* new data to add to file extents */ 214830f712c9SDave Chinner xfs_fsblock_t *first, /* pointer to firstblock variable */ 21492c3234d1SDarrick J. Wong struct xfs_defer_ops *dfops, /* list of extents to be freed */ 215030f712c9SDave Chinner int *logflagsp) /* inode logging flags */ 215130f712c9SDave Chinner { 215230f712c9SDave Chinner xfs_btree_cur_t *cur; /* btree cursor */ 215330f712c9SDave Chinner xfs_bmbt_rec_host_t *ep; /* extent entry for idx */ 215430f712c9SDave Chinner int error; /* error return value */ 215530f712c9SDave Chinner int i; /* temp state */ 215630f712c9SDave Chinner xfs_ifork_t *ifp; /* inode fork pointer */ 215730f712c9SDave Chinner xfs_fileoff_t new_endoff; /* end offset of new entry */ 215830f712c9SDave Chinner xfs_exntst_t newext; /* new extent state */ 215930f712c9SDave Chinner xfs_exntst_t oldext; /* old extent state */ 216030f712c9SDave Chinner xfs_bmbt_irec_t r[3]; /* neighbor extent entries */ 216130f712c9SDave Chinner /* left is 0, right is 1, prev is 2 */ 216230f712c9SDave Chinner int rval=0; /* return value (logging flags) */ 216330f712c9SDave Chinner int state = 0;/* state bits, accessed thru macros */ 216405a630d7SDarrick J. Wong struct xfs_mount *mp = ip->i_mount; 216530f712c9SDave Chinner 216630f712c9SDave Chinner *logflagsp = 0; 216730f712c9SDave Chinner 216830f712c9SDave Chinner cur = *curp; 216905a630d7SDarrick J. Wong ifp = XFS_IFORK_PTR(ip, whichfork); 217005a630d7SDarrick J. Wong if (whichfork == XFS_COW_FORK) 217105a630d7SDarrick J. Wong state |= BMAP_COWFORK; 217230f712c9SDave Chinner 217330f712c9SDave Chinner ASSERT(*idx >= 0); 21745d829300SEric Sandeen ASSERT(*idx <= xfs_iext_count(ifp)); 217530f712c9SDave Chinner ASSERT(!isnullstartblock(new->br_startblock)); 217630f712c9SDave Chinner 2177ff6d6af2SBill O'Donnell XFS_STATS_INC(mp, xs_add_exlist); 217830f712c9SDave Chinner 217930f712c9SDave Chinner #define LEFT r[0] 218030f712c9SDave Chinner #define RIGHT r[1] 218130f712c9SDave Chinner #define PREV r[2] 218230f712c9SDave Chinner 218330f712c9SDave Chinner /* 218430f712c9SDave Chinner * Set up a bunch of variables to make the tests simpler. 218530f712c9SDave Chinner */ 218630f712c9SDave Chinner error = 0; 218730f712c9SDave Chinner ep = xfs_iext_get_ext(ifp, *idx); 218830f712c9SDave Chinner xfs_bmbt_get_all(ep, &PREV); 218930f712c9SDave Chinner newext = new->br_state; 219030f712c9SDave Chinner oldext = (newext == XFS_EXT_UNWRITTEN) ? 219130f712c9SDave Chinner XFS_EXT_NORM : XFS_EXT_UNWRITTEN; 219230f712c9SDave Chinner ASSERT(PREV.br_state == oldext); 219330f712c9SDave Chinner new_endoff = new->br_startoff + new->br_blockcount; 219430f712c9SDave Chinner ASSERT(PREV.br_startoff <= new->br_startoff); 219530f712c9SDave Chinner ASSERT(PREV.br_startoff + PREV.br_blockcount >= new_endoff); 219630f712c9SDave Chinner 219730f712c9SDave Chinner /* 219830f712c9SDave Chinner * Set flags determining what part of the previous oldext allocation 219930f712c9SDave Chinner * extent is being replaced by a newext allocation. 220030f712c9SDave Chinner */ 220130f712c9SDave Chinner if (PREV.br_startoff == new->br_startoff) 220230f712c9SDave Chinner state |= BMAP_LEFT_FILLING; 220330f712c9SDave Chinner if (PREV.br_startoff + PREV.br_blockcount == new_endoff) 220430f712c9SDave Chinner state |= BMAP_RIGHT_FILLING; 220530f712c9SDave Chinner 220630f712c9SDave Chinner /* 220730f712c9SDave Chinner * Check and set flags if this segment has a left neighbor. 220830f712c9SDave Chinner * Don't set contiguous if the combined extent would be too large. 220930f712c9SDave Chinner */ 221030f712c9SDave Chinner if (*idx > 0) { 221130f712c9SDave Chinner state |= BMAP_LEFT_VALID; 221230f712c9SDave Chinner xfs_bmbt_get_all(xfs_iext_get_ext(ifp, *idx - 1), &LEFT); 221330f712c9SDave Chinner 221430f712c9SDave Chinner if (isnullstartblock(LEFT.br_startblock)) 221530f712c9SDave Chinner state |= BMAP_LEFT_DELAY; 221630f712c9SDave Chinner } 221730f712c9SDave Chinner 221830f712c9SDave Chinner if ((state & BMAP_LEFT_VALID) && !(state & BMAP_LEFT_DELAY) && 221930f712c9SDave Chinner LEFT.br_startoff + LEFT.br_blockcount == new->br_startoff && 222030f712c9SDave Chinner LEFT.br_startblock + LEFT.br_blockcount == new->br_startblock && 222130f712c9SDave Chinner LEFT.br_state == newext && 222230f712c9SDave Chinner LEFT.br_blockcount + new->br_blockcount <= MAXEXTLEN) 222330f712c9SDave Chinner state |= BMAP_LEFT_CONTIG; 222430f712c9SDave Chinner 222530f712c9SDave Chinner /* 222630f712c9SDave Chinner * Check and set flags if this segment has a right neighbor. 222730f712c9SDave Chinner * Don't set contiguous if the combined extent would be too large. 222830f712c9SDave Chinner * Also check for all-three-contiguous being too large. 222930f712c9SDave Chinner */ 223005a630d7SDarrick J. Wong if (*idx < xfs_iext_count(ifp) - 1) { 223130f712c9SDave Chinner state |= BMAP_RIGHT_VALID; 223230f712c9SDave Chinner xfs_bmbt_get_all(xfs_iext_get_ext(ifp, *idx + 1), &RIGHT); 223330f712c9SDave Chinner if (isnullstartblock(RIGHT.br_startblock)) 223430f712c9SDave Chinner state |= BMAP_RIGHT_DELAY; 223530f712c9SDave Chinner } 223630f712c9SDave Chinner 223730f712c9SDave Chinner if ((state & BMAP_RIGHT_VALID) && !(state & BMAP_RIGHT_DELAY) && 223830f712c9SDave Chinner new_endoff == RIGHT.br_startoff && 223930f712c9SDave Chinner new->br_startblock + new->br_blockcount == RIGHT.br_startblock && 224030f712c9SDave Chinner newext == RIGHT.br_state && 224130f712c9SDave Chinner new->br_blockcount + RIGHT.br_blockcount <= MAXEXTLEN && 224230f712c9SDave Chinner ((state & (BMAP_LEFT_CONTIG | BMAP_LEFT_FILLING | 224330f712c9SDave Chinner BMAP_RIGHT_FILLING)) != 224430f712c9SDave Chinner (BMAP_LEFT_CONTIG | BMAP_LEFT_FILLING | 224530f712c9SDave Chinner BMAP_RIGHT_FILLING) || 224630f712c9SDave Chinner LEFT.br_blockcount + new->br_blockcount + RIGHT.br_blockcount 224730f712c9SDave Chinner <= MAXEXTLEN)) 224830f712c9SDave Chinner state |= BMAP_RIGHT_CONTIG; 224930f712c9SDave Chinner 225030f712c9SDave Chinner /* 225130f712c9SDave Chinner * Switch out based on the FILLING and CONTIG state bits. 225230f712c9SDave Chinner */ 225330f712c9SDave Chinner switch (state & (BMAP_LEFT_FILLING | BMAP_LEFT_CONTIG | 225430f712c9SDave Chinner BMAP_RIGHT_FILLING | BMAP_RIGHT_CONTIG)) { 225530f712c9SDave Chinner case BMAP_LEFT_FILLING | BMAP_LEFT_CONTIG | 225630f712c9SDave Chinner BMAP_RIGHT_FILLING | BMAP_RIGHT_CONTIG: 225730f712c9SDave Chinner /* 225830f712c9SDave Chinner * Setting all of a previous oldext extent to newext. 225930f712c9SDave Chinner * The left and right neighbors are both contiguous with new. 226030f712c9SDave Chinner */ 226130f712c9SDave Chinner --*idx; 226230f712c9SDave Chinner 226330f712c9SDave Chinner trace_xfs_bmap_pre_update(ip, *idx, state, _THIS_IP_); 226430f712c9SDave Chinner xfs_bmbt_set_blockcount(xfs_iext_get_ext(ifp, *idx), 226530f712c9SDave Chinner LEFT.br_blockcount + PREV.br_blockcount + 226630f712c9SDave Chinner RIGHT.br_blockcount); 226730f712c9SDave Chinner trace_xfs_bmap_post_update(ip, *idx, state, _THIS_IP_); 226830f712c9SDave Chinner 226930f712c9SDave Chinner xfs_iext_remove(ip, *idx + 1, 2, state); 227005a630d7SDarrick J. Wong XFS_IFORK_NEXT_SET(ip, whichfork, 227105a630d7SDarrick J. Wong XFS_IFORK_NEXTENTS(ip, whichfork) - 2); 227230f712c9SDave Chinner if (cur == NULL) 227330f712c9SDave Chinner rval = XFS_ILOG_CORE | XFS_ILOG_DEXT; 227430f712c9SDave Chinner else { 227530f712c9SDave Chinner rval = XFS_ILOG_CORE; 227630f712c9SDave Chinner if ((error = xfs_bmbt_lookup_eq(cur, RIGHT.br_startoff, 227730f712c9SDave Chinner RIGHT.br_startblock, 227830f712c9SDave Chinner RIGHT.br_blockcount, &i))) 227930f712c9SDave Chinner goto done; 2280c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 228130f712c9SDave Chinner if ((error = xfs_btree_delete(cur, &i))) 228230f712c9SDave Chinner goto done; 2283c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 228430f712c9SDave Chinner if ((error = xfs_btree_decrement(cur, 0, &i))) 228530f712c9SDave Chinner goto done; 2286c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 228730f712c9SDave Chinner if ((error = xfs_btree_delete(cur, &i))) 228830f712c9SDave Chinner goto done; 2289c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 229030f712c9SDave Chinner if ((error = xfs_btree_decrement(cur, 0, &i))) 229130f712c9SDave Chinner goto done; 2292c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 229330f712c9SDave Chinner if ((error = xfs_bmbt_update(cur, LEFT.br_startoff, 229430f712c9SDave Chinner LEFT.br_startblock, 229530f712c9SDave Chinner LEFT.br_blockcount + PREV.br_blockcount + 229630f712c9SDave Chinner RIGHT.br_blockcount, LEFT.br_state))) 229730f712c9SDave Chinner goto done; 229830f712c9SDave Chinner } 229930f712c9SDave Chinner break; 230030f712c9SDave Chinner 230130f712c9SDave Chinner case BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING | BMAP_LEFT_CONTIG: 230230f712c9SDave Chinner /* 230330f712c9SDave Chinner * Setting all of a previous oldext extent to newext. 230430f712c9SDave Chinner * The left neighbor is contiguous, the right is not. 230530f712c9SDave Chinner */ 230630f712c9SDave Chinner --*idx; 230730f712c9SDave Chinner 230830f712c9SDave Chinner trace_xfs_bmap_pre_update(ip, *idx, state, _THIS_IP_); 230930f712c9SDave Chinner xfs_bmbt_set_blockcount(xfs_iext_get_ext(ifp, *idx), 231030f712c9SDave Chinner LEFT.br_blockcount + PREV.br_blockcount); 231130f712c9SDave Chinner trace_xfs_bmap_post_update(ip, *idx, state, _THIS_IP_); 231230f712c9SDave Chinner 231330f712c9SDave Chinner xfs_iext_remove(ip, *idx + 1, 1, state); 231405a630d7SDarrick J. Wong XFS_IFORK_NEXT_SET(ip, whichfork, 231505a630d7SDarrick J. Wong XFS_IFORK_NEXTENTS(ip, whichfork) - 1); 231630f712c9SDave Chinner if (cur == NULL) 231730f712c9SDave Chinner rval = XFS_ILOG_CORE | XFS_ILOG_DEXT; 231830f712c9SDave Chinner else { 231930f712c9SDave Chinner rval = XFS_ILOG_CORE; 232030f712c9SDave Chinner if ((error = xfs_bmbt_lookup_eq(cur, PREV.br_startoff, 232130f712c9SDave Chinner PREV.br_startblock, PREV.br_blockcount, 232230f712c9SDave Chinner &i))) 232330f712c9SDave Chinner goto done; 2324c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 232530f712c9SDave Chinner if ((error = xfs_btree_delete(cur, &i))) 232630f712c9SDave Chinner goto done; 2327c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 232830f712c9SDave Chinner if ((error = xfs_btree_decrement(cur, 0, &i))) 232930f712c9SDave Chinner goto done; 2330c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 233130f712c9SDave Chinner if ((error = xfs_bmbt_update(cur, LEFT.br_startoff, 233230f712c9SDave Chinner LEFT.br_startblock, 233330f712c9SDave Chinner LEFT.br_blockcount + PREV.br_blockcount, 233430f712c9SDave Chinner LEFT.br_state))) 233530f712c9SDave Chinner goto done; 233630f712c9SDave Chinner } 233730f712c9SDave Chinner break; 233830f712c9SDave Chinner 233930f712c9SDave Chinner case BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING | BMAP_RIGHT_CONTIG: 234030f712c9SDave Chinner /* 234130f712c9SDave Chinner * Setting all of a previous oldext extent to newext. 234230f712c9SDave Chinner * The right neighbor is contiguous, the left is not. 234330f712c9SDave Chinner */ 234430f712c9SDave Chinner trace_xfs_bmap_pre_update(ip, *idx, state, _THIS_IP_); 234530f712c9SDave Chinner xfs_bmbt_set_blockcount(ep, 234630f712c9SDave Chinner PREV.br_blockcount + RIGHT.br_blockcount); 234730f712c9SDave Chinner xfs_bmbt_set_state(ep, newext); 234830f712c9SDave Chinner trace_xfs_bmap_post_update(ip, *idx, state, _THIS_IP_); 234930f712c9SDave Chinner xfs_iext_remove(ip, *idx + 1, 1, state); 235005a630d7SDarrick J. Wong XFS_IFORK_NEXT_SET(ip, whichfork, 235105a630d7SDarrick J. Wong XFS_IFORK_NEXTENTS(ip, whichfork) - 1); 235230f712c9SDave Chinner if (cur == NULL) 235330f712c9SDave Chinner rval = XFS_ILOG_CORE | XFS_ILOG_DEXT; 235430f712c9SDave Chinner else { 235530f712c9SDave Chinner rval = XFS_ILOG_CORE; 235630f712c9SDave Chinner if ((error = xfs_bmbt_lookup_eq(cur, RIGHT.br_startoff, 235730f712c9SDave Chinner RIGHT.br_startblock, 235830f712c9SDave Chinner RIGHT.br_blockcount, &i))) 235930f712c9SDave Chinner goto done; 2360c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 236130f712c9SDave Chinner if ((error = xfs_btree_delete(cur, &i))) 236230f712c9SDave Chinner goto done; 2363c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 236430f712c9SDave Chinner if ((error = xfs_btree_decrement(cur, 0, &i))) 236530f712c9SDave Chinner goto done; 2366c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 236730f712c9SDave Chinner if ((error = xfs_bmbt_update(cur, new->br_startoff, 236830f712c9SDave Chinner new->br_startblock, 236930f712c9SDave Chinner new->br_blockcount + RIGHT.br_blockcount, 237030f712c9SDave Chinner newext))) 237130f712c9SDave Chinner goto done; 237230f712c9SDave Chinner } 237330f712c9SDave Chinner break; 237430f712c9SDave Chinner 237530f712c9SDave Chinner case BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING: 237630f712c9SDave Chinner /* 237730f712c9SDave Chinner * Setting all of a previous oldext extent to newext. 237830f712c9SDave Chinner * Neither the left nor right neighbors are contiguous with 237930f712c9SDave Chinner * the new one. 238030f712c9SDave Chinner */ 238130f712c9SDave Chinner trace_xfs_bmap_pre_update(ip, *idx, state, _THIS_IP_); 238230f712c9SDave Chinner xfs_bmbt_set_state(ep, newext); 238330f712c9SDave Chinner trace_xfs_bmap_post_update(ip, *idx, state, _THIS_IP_); 238430f712c9SDave Chinner 238530f712c9SDave Chinner if (cur == NULL) 238630f712c9SDave Chinner rval = XFS_ILOG_DEXT; 238730f712c9SDave Chinner else { 238830f712c9SDave Chinner rval = 0; 238930f712c9SDave Chinner if ((error = xfs_bmbt_lookup_eq(cur, new->br_startoff, 239030f712c9SDave Chinner new->br_startblock, new->br_blockcount, 239130f712c9SDave Chinner &i))) 239230f712c9SDave Chinner goto done; 2393c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 239430f712c9SDave Chinner if ((error = xfs_bmbt_update(cur, new->br_startoff, 239530f712c9SDave Chinner new->br_startblock, new->br_blockcount, 239630f712c9SDave Chinner newext))) 239730f712c9SDave Chinner goto done; 239830f712c9SDave Chinner } 239930f712c9SDave Chinner break; 240030f712c9SDave Chinner 240130f712c9SDave Chinner case BMAP_LEFT_FILLING | BMAP_LEFT_CONTIG: 240230f712c9SDave Chinner /* 240330f712c9SDave Chinner * Setting the first part of a previous oldext extent to newext. 240430f712c9SDave Chinner * The left neighbor is contiguous. 240530f712c9SDave Chinner */ 240630f712c9SDave Chinner trace_xfs_bmap_pre_update(ip, *idx - 1, state, _THIS_IP_); 240730f712c9SDave Chinner xfs_bmbt_set_blockcount(xfs_iext_get_ext(ifp, *idx - 1), 240830f712c9SDave Chinner LEFT.br_blockcount + new->br_blockcount); 240930f712c9SDave Chinner xfs_bmbt_set_startoff(ep, 241030f712c9SDave Chinner PREV.br_startoff + new->br_blockcount); 241130f712c9SDave Chinner trace_xfs_bmap_post_update(ip, *idx - 1, state, _THIS_IP_); 241230f712c9SDave Chinner 241330f712c9SDave Chinner trace_xfs_bmap_pre_update(ip, *idx, state, _THIS_IP_); 241430f712c9SDave Chinner xfs_bmbt_set_startblock(ep, 241530f712c9SDave Chinner new->br_startblock + new->br_blockcount); 241630f712c9SDave Chinner xfs_bmbt_set_blockcount(ep, 241730f712c9SDave Chinner PREV.br_blockcount - new->br_blockcount); 241830f712c9SDave Chinner trace_xfs_bmap_post_update(ip, *idx, state, _THIS_IP_); 241930f712c9SDave Chinner 242030f712c9SDave Chinner --*idx; 242130f712c9SDave Chinner 242230f712c9SDave Chinner if (cur == NULL) 242330f712c9SDave Chinner rval = XFS_ILOG_DEXT; 242430f712c9SDave Chinner else { 242530f712c9SDave Chinner rval = 0; 242630f712c9SDave Chinner if ((error = xfs_bmbt_lookup_eq(cur, PREV.br_startoff, 242730f712c9SDave Chinner PREV.br_startblock, PREV.br_blockcount, 242830f712c9SDave Chinner &i))) 242930f712c9SDave Chinner goto done; 2430c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 243130f712c9SDave Chinner if ((error = xfs_bmbt_update(cur, 243230f712c9SDave Chinner PREV.br_startoff + new->br_blockcount, 243330f712c9SDave Chinner PREV.br_startblock + new->br_blockcount, 243430f712c9SDave Chinner PREV.br_blockcount - new->br_blockcount, 243530f712c9SDave Chinner oldext))) 243630f712c9SDave Chinner goto done; 243730f712c9SDave Chinner if ((error = xfs_btree_decrement(cur, 0, &i))) 243830f712c9SDave Chinner goto done; 243930f712c9SDave Chinner error = xfs_bmbt_update(cur, LEFT.br_startoff, 244030f712c9SDave Chinner LEFT.br_startblock, 244130f712c9SDave Chinner LEFT.br_blockcount + new->br_blockcount, 244230f712c9SDave Chinner LEFT.br_state); 244330f712c9SDave Chinner if (error) 244430f712c9SDave Chinner goto done; 244530f712c9SDave Chinner } 244630f712c9SDave Chinner break; 244730f712c9SDave Chinner 244830f712c9SDave Chinner case BMAP_LEFT_FILLING: 244930f712c9SDave Chinner /* 245030f712c9SDave Chinner * Setting the first part of a previous oldext extent to newext. 245130f712c9SDave Chinner * The left neighbor is not contiguous. 245230f712c9SDave Chinner */ 245330f712c9SDave Chinner trace_xfs_bmap_pre_update(ip, *idx, state, _THIS_IP_); 245430f712c9SDave Chinner ASSERT(ep && xfs_bmbt_get_state(ep) == oldext); 245530f712c9SDave Chinner xfs_bmbt_set_startoff(ep, new_endoff); 245630f712c9SDave Chinner xfs_bmbt_set_blockcount(ep, 245730f712c9SDave Chinner PREV.br_blockcount - new->br_blockcount); 245830f712c9SDave Chinner xfs_bmbt_set_startblock(ep, 245930f712c9SDave Chinner new->br_startblock + new->br_blockcount); 246030f712c9SDave Chinner trace_xfs_bmap_post_update(ip, *idx, state, _THIS_IP_); 246130f712c9SDave Chinner 246230f712c9SDave Chinner xfs_iext_insert(ip, *idx, 1, new, state); 246305a630d7SDarrick J. Wong XFS_IFORK_NEXT_SET(ip, whichfork, 246405a630d7SDarrick J. Wong XFS_IFORK_NEXTENTS(ip, whichfork) + 1); 246530f712c9SDave Chinner if (cur == NULL) 246630f712c9SDave Chinner rval = XFS_ILOG_CORE | XFS_ILOG_DEXT; 246730f712c9SDave Chinner else { 246830f712c9SDave Chinner rval = XFS_ILOG_CORE; 246930f712c9SDave Chinner if ((error = xfs_bmbt_lookup_eq(cur, PREV.br_startoff, 247030f712c9SDave Chinner PREV.br_startblock, PREV.br_blockcount, 247130f712c9SDave Chinner &i))) 247230f712c9SDave Chinner goto done; 2473c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 247430f712c9SDave Chinner if ((error = xfs_bmbt_update(cur, 247530f712c9SDave Chinner PREV.br_startoff + new->br_blockcount, 247630f712c9SDave Chinner PREV.br_startblock + new->br_blockcount, 247730f712c9SDave Chinner PREV.br_blockcount - new->br_blockcount, 247830f712c9SDave Chinner oldext))) 247930f712c9SDave Chinner goto done; 248030f712c9SDave Chinner cur->bc_rec.b = *new; 248130f712c9SDave Chinner if ((error = xfs_btree_insert(cur, &i))) 248230f712c9SDave Chinner goto done; 2483c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 248430f712c9SDave Chinner } 248530f712c9SDave Chinner break; 248630f712c9SDave Chinner 248730f712c9SDave Chinner case BMAP_RIGHT_FILLING | BMAP_RIGHT_CONTIG: 248830f712c9SDave Chinner /* 248930f712c9SDave Chinner * Setting the last part of a previous oldext extent to newext. 249030f712c9SDave Chinner * The right neighbor is contiguous with the new allocation. 249130f712c9SDave Chinner */ 249230f712c9SDave Chinner trace_xfs_bmap_pre_update(ip, *idx, state, _THIS_IP_); 249330f712c9SDave Chinner xfs_bmbt_set_blockcount(ep, 249430f712c9SDave Chinner PREV.br_blockcount - new->br_blockcount); 249530f712c9SDave Chinner trace_xfs_bmap_post_update(ip, *idx, state, _THIS_IP_); 249630f712c9SDave Chinner 249730f712c9SDave Chinner ++*idx; 249830f712c9SDave Chinner 249930f712c9SDave Chinner trace_xfs_bmap_pre_update(ip, *idx, state, _THIS_IP_); 250030f712c9SDave Chinner xfs_bmbt_set_allf(xfs_iext_get_ext(ifp, *idx), 250130f712c9SDave Chinner new->br_startoff, new->br_startblock, 250230f712c9SDave Chinner new->br_blockcount + RIGHT.br_blockcount, newext); 250330f712c9SDave Chinner trace_xfs_bmap_post_update(ip, *idx, state, _THIS_IP_); 250430f712c9SDave Chinner 250530f712c9SDave Chinner if (cur == NULL) 250630f712c9SDave Chinner rval = XFS_ILOG_DEXT; 250730f712c9SDave Chinner else { 250830f712c9SDave Chinner rval = 0; 250930f712c9SDave Chinner if ((error = xfs_bmbt_lookup_eq(cur, PREV.br_startoff, 251030f712c9SDave Chinner PREV.br_startblock, 251130f712c9SDave Chinner PREV.br_blockcount, &i))) 251230f712c9SDave Chinner goto done; 2513c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 251430f712c9SDave Chinner if ((error = xfs_bmbt_update(cur, PREV.br_startoff, 251530f712c9SDave Chinner PREV.br_startblock, 251630f712c9SDave Chinner PREV.br_blockcount - new->br_blockcount, 251730f712c9SDave Chinner oldext))) 251830f712c9SDave Chinner goto done; 251930f712c9SDave Chinner if ((error = xfs_btree_increment(cur, 0, &i))) 252030f712c9SDave Chinner goto done; 252130f712c9SDave Chinner if ((error = xfs_bmbt_update(cur, new->br_startoff, 252230f712c9SDave Chinner new->br_startblock, 252330f712c9SDave Chinner new->br_blockcount + RIGHT.br_blockcount, 252430f712c9SDave Chinner newext))) 252530f712c9SDave Chinner goto done; 252630f712c9SDave Chinner } 252730f712c9SDave Chinner break; 252830f712c9SDave Chinner 252930f712c9SDave Chinner case BMAP_RIGHT_FILLING: 253030f712c9SDave Chinner /* 253130f712c9SDave Chinner * Setting the last part of a previous oldext extent to newext. 253230f712c9SDave Chinner * The right neighbor is not contiguous. 253330f712c9SDave Chinner */ 253430f712c9SDave Chinner trace_xfs_bmap_pre_update(ip, *idx, state, _THIS_IP_); 253530f712c9SDave Chinner xfs_bmbt_set_blockcount(ep, 253630f712c9SDave Chinner PREV.br_blockcount - new->br_blockcount); 253730f712c9SDave Chinner trace_xfs_bmap_post_update(ip, *idx, state, _THIS_IP_); 253830f712c9SDave Chinner 253930f712c9SDave Chinner ++*idx; 254030f712c9SDave Chinner xfs_iext_insert(ip, *idx, 1, new, state); 254130f712c9SDave Chinner 254205a630d7SDarrick J. Wong XFS_IFORK_NEXT_SET(ip, whichfork, 254305a630d7SDarrick J. Wong XFS_IFORK_NEXTENTS(ip, whichfork) + 1); 254430f712c9SDave Chinner if (cur == NULL) 254530f712c9SDave Chinner rval = XFS_ILOG_CORE | XFS_ILOG_DEXT; 254630f712c9SDave Chinner else { 254730f712c9SDave Chinner rval = XFS_ILOG_CORE; 254830f712c9SDave Chinner if ((error = xfs_bmbt_lookup_eq(cur, PREV.br_startoff, 254930f712c9SDave Chinner PREV.br_startblock, PREV.br_blockcount, 255030f712c9SDave Chinner &i))) 255130f712c9SDave Chinner goto done; 2552c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 255330f712c9SDave Chinner if ((error = xfs_bmbt_update(cur, PREV.br_startoff, 255430f712c9SDave Chinner PREV.br_startblock, 255530f712c9SDave Chinner PREV.br_blockcount - new->br_blockcount, 255630f712c9SDave Chinner oldext))) 255730f712c9SDave Chinner goto done; 255830f712c9SDave Chinner if ((error = xfs_bmbt_lookup_eq(cur, new->br_startoff, 255930f712c9SDave Chinner new->br_startblock, new->br_blockcount, 256030f712c9SDave Chinner &i))) 256130f712c9SDave Chinner goto done; 2562c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 0, done); 25635e422f5eSChristoph Hellwig cur->bc_rec.b.br_state = new->br_state; 256430f712c9SDave Chinner if ((error = xfs_btree_insert(cur, &i))) 256530f712c9SDave Chinner goto done; 2566c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 256730f712c9SDave Chinner } 256830f712c9SDave Chinner break; 256930f712c9SDave Chinner 257030f712c9SDave Chinner case 0: 257130f712c9SDave Chinner /* 257230f712c9SDave Chinner * Setting the middle part of a previous oldext extent to 257330f712c9SDave Chinner * newext. Contiguity is impossible here. 257430f712c9SDave Chinner * One extent becomes three extents. 257530f712c9SDave Chinner */ 257630f712c9SDave Chinner trace_xfs_bmap_pre_update(ip, *idx, state, _THIS_IP_); 257730f712c9SDave Chinner xfs_bmbt_set_blockcount(ep, 257830f712c9SDave Chinner new->br_startoff - PREV.br_startoff); 257930f712c9SDave Chinner trace_xfs_bmap_post_update(ip, *idx, state, _THIS_IP_); 258030f712c9SDave Chinner 258130f712c9SDave Chinner r[0] = *new; 258230f712c9SDave Chinner r[1].br_startoff = new_endoff; 258330f712c9SDave Chinner r[1].br_blockcount = 258430f712c9SDave Chinner PREV.br_startoff + PREV.br_blockcount - new_endoff; 258530f712c9SDave Chinner r[1].br_startblock = new->br_startblock + new->br_blockcount; 258630f712c9SDave Chinner r[1].br_state = oldext; 258730f712c9SDave Chinner 258830f712c9SDave Chinner ++*idx; 258930f712c9SDave Chinner xfs_iext_insert(ip, *idx, 2, &r[0], state); 259030f712c9SDave Chinner 259105a630d7SDarrick J. Wong XFS_IFORK_NEXT_SET(ip, whichfork, 259205a630d7SDarrick J. Wong XFS_IFORK_NEXTENTS(ip, whichfork) + 2); 259330f712c9SDave Chinner if (cur == NULL) 259430f712c9SDave Chinner rval = XFS_ILOG_CORE | XFS_ILOG_DEXT; 259530f712c9SDave Chinner else { 259630f712c9SDave Chinner rval = XFS_ILOG_CORE; 259730f712c9SDave Chinner if ((error = xfs_bmbt_lookup_eq(cur, PREV.br_startoff, 259830f712c9SDave Chinner PREV.br_startblock, PREV.br_blockcount, 259930f712c9SDave Chinner &i))) 260030f712c9SDave Chinner goto done; 2601c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 260230f712c9SDave Chinner /* new right extent - oldext */ 260330f712c9SDave Chinner if ((error = xfs_bmbt_update(cur, r[1].br_startoff, 260430f712c9SDave Chinner r[1].br_startblock, r[1].br_blockcount, 260530f712c9SDave Chinner r[1].br_state))) 260630f712c9SDave Chinner goto done; 260730f712c9SDave Chinner /* new left extent - oldext */ 260830f712c9SDave Chinner cur->bc_rec.b = PREV; 260930f712c9SDave Chinner cur->bc_rec.b.br_blockcount = 261030f712c9SDave Chinner new->br_startoff - PREV.br_startoff; 261130f712c9SDave Chinner if ((error = xfs_btree_insert(cur, &i))) 261230f712c9SDave Chinner goto done; 2613c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 261430f712c9SDave Chinner /* 261530f712c9SDave Chinner * Reset the cursor to the position of the new extent 261630f712c9SDave Chinner * we are about to insert as we can't trust it after 261730f712c9SDave Chinner * the previous insert. 261830f712c9SDave Chinner */ 261930f712c9SDave Chinner if ((error = xfs_bmbt_lookup_eq(cur, new->br_startoff, 262030f712c9SDave Chinner new->br_startblock, new->br_blockcount, 262130f712c9SDave Chinner &i))) 262230f712c9SDave Chinner goto done; 2623c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 0, done); 262430f712c9SDave Chinner /* new middle extent - newext */ 262530f712c9SDave Chinner cur->bc_rec.b.br_state = new->br_state; 262630f712c9SDave Chinner if ((error = xfs_btree_insert(cur, &i))) 262730f712c9SDave Chinner goto done; 2628c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 262930f712c9SDave Chinner } 263030f712c9SDave Chinner break; 263130f712c9SDave Chinner 263230f712c9SDave Chinner case BMAP_LEFT_FILLING | BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG: 263330f712c9SDave Chinner case BMAP_RIGHT_FILLING | BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG: 263430f712c9SDave Chinner case BMAP_LEFT_FILLING | BMAP_RIGHT_CONTIG: 263530f712c9SDave Chinner case BMAP_RIGHT_FILLING | BMAP_LEFT_CONTIG: 263630f712c9SDave Chinner case BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG: 263730f712c9SDave Chinner case BMAP_LEFT_CONTIG: 263830f712c9SDave Chinner case BMAP_RIGHT_CONTIG: 263930f712c9SDave Chinner /* 264030f712c9SDave Chinner * These cases are all impossible. 264130f712c9SDave Chinner */ 264230f712c9SDave Chinner ASSERT(0); 264330f712c9SDave Chinner } 264430f712c9SDave Chinner 26459c194644SDarrick J. Wong /* update reverse mappings */ 264605a630d7SDarrick J. Wong error = xfs_rmap_convert_extent(mp, dfops, ip, whichfork, new); 26479c194644SDarrick J. Wong if (error) 26489c194644SDarrick J. Wong goto done; 26499c194644SDarrick J. Wong 265030f712c9SDave Chinner /* convert to a btree if necessary */ 265105a630d7SDarrick J. Wong if (xfs_bmap_needs_btree(ip, whichfork)) { 265230f712c9SDave Chinner int tmp_logflags; /* partial log flag return val */ 265330f712c9SDave Chinner 265430f712c9SDave Chinner ASSERT(cur == NULL); 26552c3234d1SDarrick J. Wong error = xfs_bmap_extents_to_btree(tp, ip, first, dfops, &cur, 265605a630d7SDarrick J. Wong 0, &tmp_logflags, whichfork); 265730f712c9SDave Chinner *logflagsp |= tmp_logflags; 265830f712c9SDave Chinner if (error) 265930f712c9SDave Chinner goto done; 266030f712c9SDave Chinner } 266130f712c9SDave Chinner 266230f712c9SDave Chinner /* clear out the allocated field, done with it now in any case. */ 266330f712c9SDave Chinner if (cur) { 266430f712c9SDave Chinner cur->bc_private.b.allocated = 0; 266530f712c9SDave Chinner *curp = cur; 266630f712c9SDave Chinner } 266730f712c9SDave Chinner 266805a630d7SDarrick J. Wong xfs_bmap_check_leaf_extents(*curp, ip, whichfork); 266930f712c9SDave Chinner done: 267030f712c9SDave Chinner *logflagsp |= rval; 267130f712c9SDave Chinner return error; 267230f712c9SDave Chinner #undef LEFT 267330f712c9SDave Chinner #undef RIGHT 267430f712c9SDave Chinner #undef PREV 267530f712c9SDave Chinner } 267630f712c9SDave Chinner 267730f712c9SDave Chinner /* 267830f712c9SDave Chinner * Convert a hole to a delayed allocation. 267930f712c9SDave Chinner */ 268030f712c9SDave Chinner STATIC void 268130f712c9SDave Chinner xfs_bmap_add_extent_hole_delay( 268230f712c9SDave Chinner xfs_inode_t *ip, /* incore inode pointer */ 2683be51f811SDarrick J. Wong int whichfork, 268430f712c9SDave Chinner xfs_extnum_t *idx, /* extent number to update/insert */ 268530f712c9SDave Chinner xfs_bmbt_irec_t *new) /* new data to add to file extents */ 268630f712c9SDave Chinner { 268730f712c9SDave Chinner xfs_ifork_t *ifp; /* inode fork pointer */ 268830f712c9SDave Chinner xfs_bmbt_irec_t left; /* left neighbor extent entry */ 268930f712c9SDave Chinner xfs_filblks_t newlen=0; /* new indirect size */ 269030f712c9SDave Chinner xfs_filblks_t oldlen=0; /* old indirect size */ 269130f712c9SDave Chinner xfs_bmbt_irec_t right; /* right neighbor extent entry */ 269230f712c9SDave Chinner int state; /* state bits, accessed thru macros */ 269330f712c9SDave Chinner xfs_filblks_t temp=0; /* temp for indirect calculations */ 269430f712c9SDave Chinner 2695be51f811SDarrick J. Wong ifp = XFS_IFORK_PTR(ip, whichfork); 269630f712c9SDave Chinner state = 0; 2697be51f811SDarrick J. Wong if (whichfork == XFS_COW_FORK) 2698be51f811SDarrick J. Wong state |= BMAP_COWFORK; 269930f712c9SDave Chinner ASSERT(isnullstartblock(new->br_startblock)); 270030f712c9SDave Chinner 270130f712c9SDave Chinner /* 270230f712c9SDave Chinner * Check and set flags if this segment has a left neighbor 270330f712c9SDave Chinner */ 270430f712c9SDave Chinner if (*idx > 0) { 270530f712c9SDave Chinner state |= BMAP_LEFT_VALID; 270630f712c9SDave Chinner xfs_bmbt_get_all(xfs_iext_get_ext(ifp, *idx - 1), &left); 270730f712c9SDave Chinner 270830f712c9SDave Chinner if (isnullstartblock(left.br_startblock)) 270930f712c9SDave Chinner state |= BMAP_LEFT_DELAY; 271030f712c9SDave Chinner } 271130f712c9SDave Chinner 271230f712c9SDave Chinner /* 271330f712c9SDave Chinner * Check and set flags if the current (right) segment exists. 271430f712c9SDave Chinner * If it doesn't exist, we're converting the hole at end-of-file. 271530f712c9SDave Chinner */ 27165d829300SEric Sandeen if (*idx < xfs_iext_count(ifp)) { 271730f712c9SDave Chinner state |= BMAP_RIGHT_VALID; 271830f712c9SDave Chinner xfs_bmbt_get_all(xfs_iext_get_ext(ifp, *idx), &right); 271930f712c9SDave Chinner 272030f712c9SDave Chinner if (isnullstartblock(right.br_startblock)) 272130f712c9SDave Chinner state |= BMAP_RIGHT_DELAY; 272230f712c9SDave Chinner } 272330f712c9SDave Chinner 272430f712c9SDave Chinner /* 272530f712c9SDave Chinner * Set contiguity flags on the left and right neighbors. 272630f712c9SDave Chinner * Don't let extents get too large, even if the pieces are contiguous. 272730f712c9SDave Chinner */ 272830f712c9SDave Chinner if ((state & BMAP_LEFT_VALID) && (state & BMAP_LEFT_DELAY) && 272930f712c9SDave Chinner left.br_startoff + left.br_blockcount == new->br_startoff && 273030f712c9SDave Chinner left.br_blockcount + new->br_blockcount <= MAXEXTLEN) 273130f712c9SDave Chinner state |= BMAP_LEFT_CONTIG; 273230f712c9SDave Chinner 273330f712c9SDave Chinner if ((state & BMAP_RIGHT_VALID) && (state & BMAP_RIGHT_DELAY) && 273430f712c9SDave Chinner new->br_startoff + new->br_blockcount == right.br_startoff && 273530f712c9SDave Chinner new->br_blockcount + right.br_blockcount <= MAXEXTLEN && 273630f712c9SDave Chinner (!(state & BMAP_LEFT_CONTIG) || 273730f712c9SDave Chinner (left.br_blockcount + new->br_blockcount + 273830f712c9SDave Chinner right.br_blockcount <= MAXEXTLEN))) 273930f712c9SDave Chinner state |= BMAP_RIGHT_CONTIG; 274030f712c9SDave Chinner 274130f712c9SDave Chinner /* 274230f712c9SDave Chinner * Switch out based on the contiguity flags. 274330f712c9SDave Chinner */ 274430f712c9SDave Chinner switch (state & (BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG)) { 274530f712c9SDave Chinner case BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG: 274630f712c9SDave Chinner /* 274730f712c9SDave Chinner * New allocation is contiguous with delayed allocations 274830f712c9SDave Chinner * on the left and on the right. 274930f712c9SDave Chinner * Merge all three into a single extent record. 275030f712c9SDave Chinner */ 275130f712c9SDave Chinner --*idx; 275230f712c9SDave Chinner temp = left.br_blockcount + new->br_blockcount + 275330f712c9SDave Chinner right.br_blockcount; 275430f712c9SDave Chinner 275530f712c9SDave Chinner trace_xfs_bmap_pre_update(ip, *idx, state, _THIS_IP_); 275630f712c9SDave Chinner xfs_bmbt_set_blockcount(xfs_iext_get_ext(ifp, *idx), temp); 275730f712c9SDave Chinner oldlen = startblockval(left.br_startblock) + 275830f712c9SDave Chinner startblockval(new->br_startblock) + 275930f712c9SDave Chinner startblockval(right.br_startblock); 27600e339ef8SBrian Foster newlen = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(ip, temp), 27610e339ef8SBrian Foster oldlen); 276230f712c9SDave Chinner xfs_bmbt_set_startblock(xfs_iext_get_ext(ifp, *idx), 276330f712c9SDave Chinner nullstartblock((int)newlen)); 276430f712c9SDave Chinner trace_xfs_bmap_post_update(ip, *idx, state, _THIS_IP_); 276530f712c9SDave Chinner 276630f712c9SDave Chinner xfs_iext_remove(ip, *idx + 1, 1, state); 276730f712c9SDave Chinner break; 276830f712c9SDave Chinner 276930f712c9SDave Chinner case BMAP_LEFT_CONTIG: 277030f712c9SDave Chinner /* 277130f712c9SDave Chinner * New allocation is contiguous with a delayed allocation 277230f712c9SDave Chinner * on the left. 277330f712c9SDave Chinner * Merge the new allocation with the left neighbor. 277430f712c9SDave Chinner */ 277530f712c9SDave Chinner --*idx; 277630f712c9SDave Chinner temp = left.br_blockcount + new->br_blockcount; 277730f712c9SDave Chinner 277830f712c9SDave Chinner trace_xfs_bmap_pre_update(ip, *idx, state, _THIS_IP_); 277930f712c9SDave Chinner xfs_bmbt_set_blockcount(xfs_iext_get_ext(ifp, *idx), temp); 278030f712c9SDave Chinner oldlen = startblockval(left.br_startblock) + 278130f712c9SDave Chinner startblockval(new->br_startblock); 27820e339ef8SBrian Foster newlen = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(ip, temp), 27830e339ef8SBrian Foster oldlen); 278430f712c9SDave Chinner xfs_bmbt_set_startblock(xfs_iext_get_ext(ifp, *idx), 278530f712c9SDave Chinner nullstartblock((int)newlen)); 278630f712c9SDave Chinner trace_xfs_bmap_post_update(ip, *idx, state, _THIS_IP_); 278730f712c9SDave Chinner break; 278830f712c9SDave Chinner 278930f712c9SDave Chinner case BMAP_RIGHT_CONTIG: 279030f712c9SDave Chinner /* 279130f712c9SDave Chinner * New allocation is contiguous with a delayed allocation 279230f712c9SDave Chinner * on the right. 279330f712c9SDave Chinner * Merge the new allocation with the right neighbor. 279430f712c9SDave Chinner */ 279530f712c9SDave Chinner trace_xfs_bmap_pre_update(ip, *idx, state, _THIS_IP_); 279630f712c9SDave Chinner temp = new->br_blockcount + right.br_blockcount; 279730f712c9SDave Chinner oldlen = startblockval(new->br_startblock) + 279830f712c9SDave Chinner startblockval(right.br_startblock); 27990e339ef8SBrian Foster newlen = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(ip, temp), 28000e339ef8SBrian Foster oldlen); 280130f712c9SDave Chinner xfs_bmbt_set_allf(xfs_iext_get_ext(ifp, *idx), 280230f712c9SDave Chinner new->br_startoff, 280330f712c9SDave Chinner nullstartblock((int)newlen), temp, right.br_state); 280430f712c9SDave Chinner trace_xfs_bmap_post_update(ip, *idx, state, _THIS_IP_); 280530f712c9SDave Chinner break; 280630f712c9SDave Chinner 280730f712c9SDave Chinner case 0: 280830f712c9SDave Chinner /* 280930f712c9SDave Chinner * New allocation is not contiguous with another 281030f712c9SDave Chinner * delayed allocation. 281130f712c9SDave Chinner * Insert a new entry. 281230f712c9SDave Chinner */ 281330f712c9SDave Chinner oldlen = newlen = 0; 281430f712c9SDave Chinner xfs_iext_insert(ip, *idx, 1, new, state); 281530f712c9SDave Chinner break; 281630f712c9SDave Chinner } 281730f712c9SDave Chinner if (oldlen != newlen) { 281830f712c9SDave Chinner ASSERT(oldlen > newlen); 28190d485adaSDave Chinner xfs_mod_fdblocks(ip->i_mount, (int64_t)(oldlen - newlen), 28200d485adaSDave Chinner false); 282130f712c9SDave Chinner /* 282230f712c9SDave Chinner * Nothing to do for disk quota accounting here. 282330f712c9SDave Chinner */ 282430f712c9SDave Chinner } 282530f712c9SDave Chinner } 282630f712c9SDave Chinner 282730f712c9SDave Chinner /* 282830f712c9SDave Chinner * Convert a hole to a real allocation. 282930f712c9SDave Chinner */ 283030f712c9SDave Chinner STATIC int /* error */ 283130f712c9SDave Chinner xfs_bmap_add_extent_hole_real( 28326d04558fSChristoph Hellwig struct xfs_trans *tp, 28336d04558fSChristoph Hellwig struct xfs_inode *ip, 28346d04558fSChristoph Hellwig int whichfork, 28356d04558fSChristoph Hellwig xfs_extnum_t *idx, 28366d04558fSChristoph Hellwig struct xfs_btree_cur **curp, 28376d04558fSChristoph Hellwig struct xfs_bmbt_irec *new, 28386d04558fSChristoph Hellwig xfs_fsblock_t *first, 28396d04558fSChristoph Hellwig struct xfs_defer_ops *dfops, 28406d04558fSChristoph Hellwig int *logflagsp) 284130f712c9SDave Chinner { 28426d04558fSChristoph Hellwig struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, whichfork); 28436d04558fSChristoph Hellwig struct xfs_mount *mp = ip->i_mount; 28446d04558fSChristoph Hellwig struct xfs_btree_cur *cur = *curp; 284530f712c9SDave Chinner int error; /* error return value */ 284630f712c9SDave Chinner int i; /* temp state */ 284730f712c9SDave Chinner xfs_bmbt_irec_t left; /* left neighbor extent entry */ 284830f712c9SDave Chinner xfs_bmbt_irec_t right; /* right neighbor extent entry */ 284930f712c9SDave Chinner int rval=0; /* return value (logging flags) */ 285030f712c9SDave Chinner int state; /* state bits, accessed thru macros */ 285130f712c9SDave Chinner 28526d04558fSChristoph Hellwig ASSERT(*idx >= 0); 28536d04558fSChristoph Hellwig ASSERT(*idx <= xfs_iext_count(ifp)); 285430f712c9SDave Chinner ASSERT(!isnullstartblock(new->br_startblock)); 28556d04558fSChristoph Hellwig ASSERT(!cur || !(cur->bc_private.b.flags & XFS_BTCUR_BPRV_WASDEL)); 285630f712c9SDave Chinner 2857ff6d6af2SBill O'Donnell XFS_STATS_INC(mp, xs_add_exlist); 285830f712c9SDave Chinner 285930f712c9SDave Chinner state = 0; 286030f712c9SDave Chinner if (whichfork == XFS_ATTR_FORK) 286130f712c9SDave Chinner state |= BMAP_ATTRFORK; 2862a14234c7SChristoph Hellwig if (whichfork == XFS_COW_FORK) 2863a14234c7SChristoph Hellwig state |= BMAP_COWFORK; 286430f712c9SDave Chinner 286530f712c9SDave Chinner /* 286630f712c9SDave Chinner * Check and set flags if this segment has a left neighbor. 286730f712c9SDave Chinner */ 28686d04558fSChristoph Hellwig if (*idx > 0) { 286930f712c9SDave Chinner state |= BMAP_LEFT_VALID; 28706d04558fSChristoph Hellwig xfs_bmbt_get_all(xfs_iext_get_ext(ifp, *idx - 1), &left); 287130f712c9SDave Chinner if (isnullstartblock(left.br_startblock)) 287230f712c9SDave Chinner state |= BMAP_LEFT_DELAY; 287330f712c9SDave Chinner } 287430f712c9SDave Chinner 287530f712c9SDave Chinner /* 287630f712c9SDave Chinner * Check and set flags if this segment has a current value. 287730f712c9SDave Chinner * Not true if we're inserting into the "hole" at eof. 287830f712c9SDave Chinner */ 28796d04558fSChristoph Hellwig if (*idx < xfs_iext_count(ifp)) { 288030f712c9SDave Chinner state |= BMAP_RIGHT_VALID; 28816d04558fSChristoph Hellwig xfs_bmbt_get_all(xfs_iext_get_ext(ifp, *idx), &right); 288230f712c9SDave Chinner if (isnullstartblock(right.br_startblock)) 288330f712c9SDave Chinner state |= BMAP_RIGHT_DELAY; 288430f712c9SDave Chinner } 288530f712c9SDave Chinner 288630f712c9SDave Chinner /* 288730f712c9SDave Chinner * We're inserting a real allocation between "left" and "right". 288830f712c9SDave Chinner * Set the contiguity flags. Don't let extents get too large. 288930f712c9SDave Chinner */ 289030f712c9SDave Chinner if ((state & BMAP_LEFT_VALID) && !(state & BMAP_LEFT_DELAY) && 289130f712c9SDave Chinner left.br_startoff + left.br_blockcount == new->br_startoff && 289230f712c9SDave Chinner left.br_startblock + left.br_blockcount == new->br_startblock && 289330f712c9SDave Chinner left.br_state == new->br_state && 289430f712c9SDave Chinner left.br_blockcount + new->br_blockcount <= MAXEXTLEN) 289530f712c9SDave Chinner state |= BMAP_LEFT_CONTIG; 289630f712c9SDave Chinner 289730f712c9SDave Chinner if ((state & BMAP_RIGHT_VALID) && !(state & BMAP_RIGHT_DELAY) && 289830f712c9SDave Chinner new->br_startoff + new->br_blockcount == right.br_startoff && 289930f712c9SDave Chinner new->br_startblock + new->br_blockcount == right.br_startblock && 290030f712c9SDave Chinner new->br_state == right.br_state && 290130f712c9SDave Chinner new->br_blockcount + right.br_blockcount <= MAXEXTLEN && 290230f712c9SDave Chinner (!(state & BMAP_LEFT_CONTIG) || 290330f712c9SDave Chinner left.br_blockcount + new->br_blockcount + 290430f712c9SDave Chinner right.br_blockcount <= MAXEXTLEN)) 290530f712c9SDave Chinner state |= BMAP_RIGHT_CONTIG; 290630f712c9SDave Chinner 290730f712c9SDave Chinner error = 0; 290830f712c9SDave Chinner /* 290930f712c9SDave Chinner * Select which case we're in here, and implement it. 291030f712c9SDave Chinner */ 291130f712c9SDave Chinner switch (state & (BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG)) { 291230f712c9SDave Chinner case BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG: 291330f712c9SDave Chinner /* 291430f712c9SDave Chinner * New allocation is contiguous with real allocations on the 291530f712c9SDave Chinner * left and on the right. 291630f712c9SDave Chinner * Merge all three into a single extent record. 291730f712c9SDave Chinner */ 29186d04558fSChristoph Hellwig --*idx; 29196d04558fSChristoph Hellwig trace_xfs_bmap_pre_update(ip, *idx, state, _THIS_IP_); 29206d04558fSChristoph Hellwig xfs_bmbt_set_blockcount(xfs_iext_get_ext(ifp, *idx), 292130f712c9SDave Chinner left.br_blockcount + new->br_blockcount + 292230f712c9SDave Chinner right.br_blockcount); 29236d04558fSChristoph Hellwig trace_xfs_bmap_post_update(ip, *idx, state, _THIS_IP_); 292430f712c9SDave Chinner 29256d04558fSChristoph Hellwig xfs_iext_remove(ip, *idx + 1, 1, state); 292630f712c9SDave Chinner 29276d04558fSChristoph Hellwig XFS_IFORK_NEXT_SET(ip, whichfork, 29286d04558fSChristoph Hellwig XFS_IFORK_NEXTENTS(ip, whichfork) - 1); 29296d04558fSChristoph Hellwig if (cur == NULL) { 293030f712c9SDave Chinner rval = XFS_ILOG_CORE | xfs_ilog_fext(whichfork); 293130f712c9SDave Chinner } else { 293230f712c9SDave Chinner rval = XFS_ILOG_CORE; 29336d04558fSChristoph Hellwig error = xfs_bmbt_lookup_eq(cur, right.br_startoff, 293430f712c9SDave Chinner right.br_startblock, right.br_blockcount, 293530f712c9SDave Chinner &i); 293630f712c9SDave Chinner if (error) 293730f712c9SDave Chinner goto done; 2938c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 29396d04558fSChristoph Hellwig error = xfs_btree_delete(cur, &i); 294030f712c9SDave Chinner if (error) 294130f712c9SDave Chinner goto done; 2942c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 29436d04558fSChristoph Hellwig error = xfs_btree_decrement(cur, 0, &i); 294430f712c9SDave Chinner if (error) 294530f712c9SDave Chinner goto done; 2946c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 29476d04558fSChristoph Hellwig error = xfs_bmbt_update(cur, left.br_startoff, 294830f712c9SDave Chinner left.br_startblock, 294930f712c9SDave Chinner left.br_blockcount + 295030f712c9SDave Chinner new->br_blockcount + 295130f712c9SDave Chinner right.br_blockcount, 295230f712c9SDave Chinner left.br_state); 295330f712c9SDave Chinner if (error) 295430f712c9SDave Chinner goto done; 295530f712c9SDave Chinner } 295630f712c9SDave Chinner break; 295730f712c9SDave Chinner 295830f712c9SDave Chinner case BMAP_LEFT_CONTIG: 295930f712c9SDave Chinner /* 296030f712c9SDave Chinner * New allocation is contiguous with a real allocation 296130f712c9SDave Chinner * on the left. 296230f712c9SDave Chinner * Merge the new allocation with the left neighbor. 296330f712c9SDave Chinner */ 29646d04558fSChristoph Hellwig --*idx; 29656d04558fSChristoph Hellwig trace_xfs_bmap_pre_update(ip, *idx, state, _THIS_IP_); 29666d04558fSChristoph Hellwig xfs_bmbt_set_blockcount(xfs_iext_get_ext(ifp, *idx), 296730f712c9SDave Chinner left.br_blockcount + new->br_blockcount); 29686d04558fSChristoph Hellwig trace_xfs_bmap_post_update(ip, *idx, state, _THIS_IP_); 296930f712c9SDave Chinner 29706d04558fSChristoph Hellwig if (cur == NULL) { 297130f712c9SDave Chinner rval = xfs_ilog_fext(whichfork); 297230f712c9SDave Chinner } else { 297330f712c9SDave Chinner rval = 0; 29746d04558fSChristoph Hellwig error = xfs_bmbt_lookup_eq(cur, left.br_startoff, 297530f712c9SDave Chinner left.br_startblock, left.br_blockcount, 297630f712c9SDave Chinner &i); 297730f712c9SDave Chinner if (error) 297830f712c9SDave Chinner goto done; 2979c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 29806d04558fSChristoph Hellwig error = xfs_bmbt_update(cur, left.br_startoff, 298130f712c9SDave Chinner left.br_startblock, 298230f712c9SDave Chinner left.br_blockcount + 298330f712c9SDave Chinner new->br_blockcount, 298430f712c9SDave Chinner left.br_state); 298530f712c9SDave Chinner if (error) 298630f712c9SDave Chinner goto done; 298730f712c9SDave Chinner } 298830f712c9SDave Chinner break; 298930f712c9SDave Chinner 299030f712c9SDave Chinner case BMAP_RIGHT_CONTIG: 299130f712c9SDave Chinner /* 299230f712c9SDave Chinner * New allocation is contiguous with a real allocation 299330f712c9SDave Chinner * on the right. 299430f712c9SDave Chinner * Merge the new allocation with the right neighbor. 299530f712c9SDave Chinner */ 29966d04558fSChristoph Hellwig trace_xfs_bmap_pre_update(ip, *idx, state, _THIS_IP_); 29976d04558fSChristoph Hellwig xfs_bmbt_set_allf(xfs_iext_get_ext(ifp, *idx), 299830f712c9SDave Chinner new->br_startoff, new->br_startblock, 299930f712c9SDave Chinner new->br_blockcount + right.br_blockcount, 300030f712c9SDave Chinner right.br_state); 30016d04558fSChristoph Hellwig trace_xfs_bmap_post_update(ip, *idx, state, _THIS_IP_); 300230f712c9SDave Chinner 30036d04558fSChristoph Hellwig if (cur == NULL) { 300430f712c9SDave Chinner rval = xfs_ilog_fext(whichfork); 300530f712c9SDave Chinner } else { 300630f712c9SDave Chinner rval = 0; 30076d04558fSChristoph Hellwig error = xfs_bmbt_lookup_eq(cur, 300830f712c9SDave Chinner right.br_startoff, 300930f712c9SDave Chinner right.br_startblock, 301030f712c9SDave Chinner right.br_blockcount, &i); 301130f712c9SDave Chinner if (error) 301230f712c9SDave Chinner goto done; 3013c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 30146d04558fSChristoph Hellwig error = xfs_bmbt_update(cur, new->br_startoff, 301530f712c9SDave Chinner new->br_startblock, 301630f712c9SDave Chinner new->br_blockcount + 301730f712c9SDave Chinner right.br_blockcount, 301830f712c9SDave Chinner right.br_state); 301930f712c9SDave Chinner if (error) 302030f712c9SDave Chinner goto done; 302130f712c9SDave Chinner } 302230f712c9SDave Chinner break; 302330f712c9SDave Chinner 302430f712c9SDave Chinner case 0: 302530f712c9SDave Chinner /* 302630f712c9SDave Chinner * New allocation is not contiguous with another 302730f712c9SDave Chinner * real allocation. 302830f712c9SDave Chinner * Insert a new entry. 302930f712c9SDave Chinner */ 30306d04558fSChristoph Hellwig xfs_iext_insert(ip, *idx, 1, new, state); 30316d04558fSChristoph Hellwig XFS_IFORK_NEXT_SET(ip, whichfork, 30326d04558fSChristoph Hellwig XFS_IFORK_NEXTENTS(ip, whichfork) + 1); 30336d04558fSChristoph Hellwig if (cur == NULL) { 303430f712c9SDave Chinner rval = XFS_ILOG_CORE | xfs_ilog_fext(whichfork); 303530f712c9SDave Chinner } else { 303630f712c9SDave Chinner rval = XFS_ILOG_CORE; 30376d04558fSChristoph Hellwig error = xfs_bmbt_lookup_eq(cur, 303830f712c9SDave Chinner new->br_startoff, 303930f712c9SDave Chinner new->br_startblock, 304030f712c9SDave Chinner new->br_blockcount, &i); 304130f712c9SDave Chinner if (error) 304230f712c9SDave Chinner goto done; 3043c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 0, done); 30446d04558fSChristoph Hellwig cur->bc_rec.b.br_state = new->br_state; 30456d04558fSChristoph Hellwig error = xfs_btree_insert(cur, &i); 304630f712c9SDave Chinner if (error) 304730f712c9SDave Chinner goto done; 3048c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 304930f712c9SDave Chinner } 305030f712c9SDave Chinner break; 305130f712c9SDave Chinner } 305230f712c9SDave Chinner 30539c194644SDarrick J. Wong /* add reverse mapping */ 30546d04558fSChristoph Hellwig error = xfs_rmap_map_extent(mp, dfops, ip, whichfork, new); 30559c194644SDarrick J. Wong if (error) 30569c194644SDarrick J. Wong goto done; 30579c194644SDarrick J. Wong 305830f712c9SDave Chinner /* convert to a btree if necessary */ 30596d04558fSChristoph Hellwig if (xfs_bmap_needs_btree(ip, whichfork)) { 306030f712c9SDave Chinner int tmp_logflags; /* partial log flag return val */ 306130f712c9SDave Chinner 30626d04558fSChristoph Hellwig ASSERT(cur == NULL); 30636d04558fSChristoph Hellwig error = xfs_bmap_extents_to_btree(tp, ip, first, dfops, curp, 306430f712c9SDave Chinner 0, &tmp_logflags, whichfork); 30656d04558fSChristoph Hellwig *logflagsp |= tmp_logflags; 30666d04558fSChristoph Hellwig cur = *curp; 306730f712c9SDave Chinner if (error) 306830f712c9SDave Chinner goto done; 306930f712c9SDave Chinner } 307030f712c9SDave Chinner 307130f712c9SDave Chinner /* clear out the allocated field, done with it now in any case. */ 30726d04558fSChristoph Hellwig if (cur) 30736d04558fSChristoph Hellwig cur->bc_private.b.allocated = 0; 307430f712c9SDave Chinner 30756d04558fSChristoph Hellwig xfs_bmap_check_leaf_extents(cur, ip, whichfork); 307630f712c9SDave Chinner done: 30776d04558fSChristoph Hellwig *logflagsp |= rval; 307830f712c9SDave Chinner return error; 307930f712c9SDave Chinner } 308030f712c9SDave Chinner 308130f712c9SDave Chinner /* 308230f712c9SDave Chinner * Functions used in the extent read, allocate and remove paths 308330f712c9SDave Chinner */ 308430f712c9SDave Chinner 308530f712c9SDave Chinner /* 308630f712c9SDave Chinner * Adjust the size of the new extent based on di_extsize and rt extsize. 308730f712c9SDave Chinner */ 308830f712c9SDave Chinner int 308930f712c9SDave Chinner xfs_bmap_extsize_align( 309030f712c9SDave Chinner xfs_mount_t *mp, 309130f712c9SDave Chinner xfs_bmbt_irec_t *gotp, /* next extent pointer */ 309230f712c9SDave Chinner xfs_bmbt_irec_t *prevp, /* previous extent pointer */ 309330f712c9SDave Chinner xfs_extlen_t extsz, /* align to this extent size */ 309430f712c9SDave Chinner int rt, /* is this a realtime inode? */ 309530f712c9SDave Chinner int eof, /* is extent at end-of-file? */ 309630f712c9SDave Chinner int delay, /* creating delalloc extent? */ 309730f712c9SDave Chinner int convert, /* overwriting unwritten extent? */ 309830f712c9SDave Chinner xfs_fileoff_t *offp, /* in/out: aligned offset */ 309930f712c9SDave Chinner xfs_extlen_t *lenp) /* in/out: aligned length */ 310030f712c9SDave Chinner { 310130f712c9SDave Chinner xfs_fileoff_t orig_off; /* original offset */ 310230f712c9SDave Chinner xfs_extlen_t orig_alen; /* original length */ 310330f712c9SDave Chinner xfs_fileoff_t orig_end; /* original off+len */ 310430f712c9SDave Chinner xfs_fileoff_t nexto; /* next file offset */ 310530f712c9SDave Chinner xfs_fileoff_t prevo; /* previous file offset */ 310630f712c9SDave Chinner xfs_fileoff_t align_off; /* temp for offset */ 310730f712c9SDave Chinner xfs_extlen_t align_alen; /* temp for length */ 310830f712c9SDave Chinner xfs_extlen_t temp; /* temp for calculations */ 310930f712c9SDave Chinner 311030f712c9SDave Chinner if (convert) 311130f712c9SDave Chinner return 0; 311230f712c9SDave Chinner 311330f712c9SDave Chinner orig_off = align_off = *offp; 311430f712c9SDave Chinner orig_alen = align_alen = *lenp; 311530f712c9SDave Chinner orig_end = orig_off + orig_alen; 311630f712c9SDave Chinner 311730f712c9SDave Chinner /* 311830f712c9SDave Chinner * If this request overlaps an existing extent, then don't 311930f712c9SDave Chinner * attempt to perform any additional alignment. 312030f712c9SDave Chinner */ 312130f712c9SDave Chinner if (!delay && !eof && 312230f712c9SDave Chinner (orig_off >= gotp->br_startoff) && 312330f712c9SDave Chinner (orig_end <= gotp->br_startoff + gotp->br_blockcount)) { 312430f712c9SDave Chinner return 0; 312530f712c9SDave Chinner } 312630f712c9SDave Chinner 312730f712c9SDave Chinner /* 312830f712c9SDave Chinner * If the file offset is unaligned vs. the extent size 312930f712c9SDave Chinner * we need to align it. This will be possible unless 313030f712c9SDave Chinner * the file was previously written with a kernel that didn't 313130f712c9SDave Chinner * perform this alignment, or if a truncate shot us in the 313230f712c9SDave Chinner * foot. 313330f712c9SDave Chinner */ 313430f712c9SDave Chinner temp = do_mod(orig_off, extsz); 313530f712c9SDave Chinner if (temp) { 313630f712c9SDave Chinner align_alen += temp; 313730f712c9SDave Chinner align_off -= temp; 313830f712c9SDave Chinner } 31396dea405eSDave Chinner 31406dea405eSDave Chinner /* Same adjustment for the end of the requested area. */ 31416dea405eSDave Chinner temp = (align_alen % extsz); 31426dea405eSDave Chinner if (temp) 314330f712c9SDave Chinner align_alen += extsz - temp; 31446dea405eSDave Chinner 31456dea405eSDave Chinner /* 31466dea405eSDave Chinner * For large extent hint sizes, the aligned extent might be larger than 31476dea405eSDave Chinner * MAXEXTLEN. In that case, reduce the size by an extsz so that it pulls 31486dea405eSDave Chinner * the length back under MAXEXTLEN. The outer allocation loops handle 31496dea405eSDave Chinner * short allocation just fine, so it is safe to do this. We only want to 31506dea405eSDave Chinner * do it when we are forced to, though, because it means more allocation 31516dea405eSDave Chinner * operations are required. 31526dea405eSDave Chinner */ 31536dea405eSDave Chinner while (align_alen > MAXEXTLEN) 31546dea405eSDave Chinner align_alen -= extsz; 31556dea405eSDave Chinner ASSERT(align_alen <= MAXEXTLEN); 31566dea405eSDave Chinner 315730f712c9SDave Chinner /* 315830f712c9SDave Chinner * If the previous block overlaps with this proposed allocation 315930f712c9SDave Chinner * then move the start forward without adjusting the length. 316030f712c9SDave Chinner */ 316130f712c9SDave Chinner if (prevp->br_startoff != NULLFILEOFF) { 316230f712c9SDave Chinner if (prevp->br_startblock == HOLESTARTBLOCK) 316330f712c9SDave Chinner prevo = prevp->br_startoff; 316430f712c9SDave Chinner else 316530f712c9SDave Chinner prevo = prevp->br_startoff + prevp->br_blockcount; 316630f712c9SDave Chinner } else 316730f712c9SDave Chinner prevo = 0; 316830f712c9SDave Chinner if (align_off != orig_off && align_off < prevo) 316930f712c9SDave Chinner align_off = prevo; 317030f712c9SDave Chinner /* 317130f712c9SDave Chinner * If the next block overlaps with this proposed allocation 317230f712c9SDave Chinner * then move the start back without adjusting the length, 317330f712c9SDave Chinner * but not before offset 0. 317430f712c9SDave Chinner * This may of course make the start overlap previous block, 317530f712c9SDave Chinner * and if we hit the offset 0 limit then the next block 317630f712c9SDave Chinner * can still overlap too. 317730f712c9SDave Chinner */ 317830f712c9SDave Chinner if (!eof && gotp->br_startoff != NULLFILEOFF) { 317930f712c9SDave Chinner if ((delay && gotp->br_startblock == HOLESTARTBLOCK) || 318030f712c9SDave Chinner (!delay && gotp->br_startblock == DELAYSTARTBLOCK)) 318130f712c9SDave Chinner nexto = gotp->br_startoff + gotp->br_blockcount; 318230f712c9SDave Chinner else 318330f712c9SDave Chinner nexto = gotp->br_startoff; 318430f712c9SDave Chinner } else 318530f712c9SDave Chinner nexto = NULLFILEOFF; 318630f712c9SDave Chinner if (!eof && 318730f712c9SDave Chinner align_off + align_alen != orig_end && 318830f712c9SDave Chinner align_off + align_alen > nexto) 318930f712c9SDave Chinner align_off = nexto > align_alen ? nexto - align_alen : 0; 319030f712c9SDave Chinner /* 319130f712c9SDave Chinner * If we're now overlapping the next or previous extent that 319230f712c9SDave Chinner * means we can't fit an extsz piece in this hole. Just move 319330f712c9SDave Chinner * the start forward to the first valid spot and set 319430f712c9SDave Chinner * the length so we hit the end. 319530f712c9SDave Chinner */ 319630f712c9SDave Chinner if (align_off != orig_off && align_off < prevo) 319730f712c9SDave Chinner align_off = prevo; 319830f712c9SDave Chinner if (align_off + align_alen != orig_end && 319930f712c9SDave Chinner align_off + align_alen > nexto && 320030f712c9SDave Chinner nexto != NULLFILEOFF) { 320130f712c9SDave Chinner ASSERT(nexto > prevo); 320230f712c9SDave Chinner align_alen = nexto - align_off; 320330f712c9SDave Chinner } 320430f712c9SDave Chinner 320530f712c9SDave Chinner /* 320630f712c9SDave Chinner * If realtime, and the result isn't a multiple of the realtime 320730f712c9SDave Chinner * extent size we need to remove blocks until it is. 320830f712c9SDave Chinner */ 320930f712c9SDave Chinner if (rt && (temp = (align_alen % mp->m_sb.sb_rextsize))) { 321030f712c9SDave Chinner /* 321130f712c9SDave Chinner * We're not covering the original request, or 321230f712c9SDave Chinner * we won't be able to once we fix the length. 321330f712c9SDave Chinner */ 321430f712c9SDave Chinner if (orig_off < align_off || 321530f712c9SDave Chinner orig_end > align_off + align_alen || 321630f712c9SDave Chinner align_alen - temp < orig_alen) 32172451337dSDave Chinner return -EINVAL; 321830f712c9SDave Chinner /* 321930f712c9SDave Chinner * Try to fix it by moving the start up. 322030f712c9SDave Chinner */ 322130f712c9SDave Chinner if (align_off + temp <= orig_off) { 322230f712c9SDave Chinner align_alen -= temp; 322330f712c9SDave Chinner align_off += temp; 322430f712c9SDave Chinner } 322530f712c9SDave Chinner /* 322630f712c9SDave Chinner * Try to fix it by moving the end in. 322730f712c9SDave Chinner */ 322830f712c9SDave Chinner else if (align_off + align_alen - temp >= orig_end) 322930f712c9SDave Chinner align_alen -= temp; 323030f712c9SDave Chinner /* 323130f712c9SDave Chinner * Set the start to the minimum then trim the length. 323230f712c9SDave Chinner */ 323330f712c9SDave Chinner else { 323430f712c9SDave Chinner align_alen -= orig_off - align_off; 323530f712c9SDave Chinner align_off = orig_off; 323630f712c9SDave Chinner align_alen -= align_alen % mp->m_sb.sb_rextsize; 323730f712c9SDave Chinner } 323830f712c9SDave Chinner /* 323930f712c9SDave Chinner * Result doesn't cover the request, fail it. 324030f712c9SDave Chinner */ 324130f712c9SDave Chinner if (orig_off < align_off || orig_end > align_off + align_alen) 32422451337dSDave Chinner return -EINVAL; 324330f712c9SDave Chinner } else { 324430f712c9SDave Chinner ASSERT(orig_off >= align_off); 32456dea405eSDave Chinner /* see MAXEXTLEN handling above */ 32466dea405eSDave Chinner ASSERT(orig_end <= align_off + align_alen || 32476dea405eSDave Chinner align_alen + extsz > MAXEXTLEN); 324830f712c9SDave Chinner } 324930f712c9SDave Chinner 325030f712c9SDave Chinner #ifdef DEBUG 325130f712c9SDave Chinner if (!eof && gotp->br_startoff != NULLFILEOFF) 325230f712c9SDave Chinner ASSERT(align_off + align_alen <= gotp->br_startoff); 325330f712c9SDave Chinner if (prevp->br_startoff != NULLFILEOFF) 325430f712c9SDave Chinner ASSERT(align_off >= prevp->br_startoff + prevp->br_blockcount); 325530f712c9SDave Chinner #endif 325630f712c9SDave Chinner 325730f712c9SDave Chinner *lenp = align_alen; 325830f712c9SDave Chinner *offp = align_off; 325930f712c9SDave Chinner return 0; 326030f712c9SDave Chinner } 326130f712c9SDave Chinner 326230f712c9SDave Chinner #define XFS_ALLOC_GAP_UNITS 4 326330f712c9SDave Chinner 326430f712c9SDave Chinner void 326530f712c9SDave Chinner xfs_bmap_adjacent( 326630f712c9SDave Chinner struct xfs_bmalloca *ap) /* bmap alloc argument struct */ 326730f712c9SDave Chinner { 326830f712c9SDave Chinner xfs_fsblock_t adjust; /* adjustment to block numbers */ 326930f712c9SDave Chinner xfs_agnumber_t fb_agno; /* ag number of ap->firstblock */ 327030f712c9SDave Chinner xfs_mount_t *mp; /* mount point structure */ 327130f712c9SDave Chinner int nullfb; /* true if ap->firstblock isn't set */ 327230f712c9SDave Chinner int rt; /* true if inode is realtime */ 327330f712c9SDave Chinner 327430f712c9SDave Chinner #define ISVALID(x,y) \ 327530f712c9SDave Chinner (rt ? \ 327630f712c9SDave Chinner (x) < mp->m_sb.sb_rblocks : \ 327730f712c9SDave Chinner XFS_FSB_TO_AGNO(mp, x) == XFS_FSB_TO_AGNO(mp, y) && \ 327830f712c9SDave Chinner XFS_FSB_TO_AGNO(mp, x) < mp->m_sb.sb_agcount && \ 327930f712c9SDave Chinner XFS_FSB_TO_AGBNO(mp, x) < mp->m_sb.sb_agblocks) 328030f712c9SDave Chinner 328130f712c9SDave Chinner mp = ap->ip->i_mount; 328230f712c9SDave Chinner nullfb = *ap->firstblock == NULLFSBLOCK; 3283292378edSDave Chinner rt = XFS_IS_REALTIME_INODE(ap->ip) && 3284292378edSDave Chinner xfs_alloc_is_userdata(ap->datatype); 328530f712c9SDave Chinner fb_agno = nullfb ? NULLAGNUMBER : XFS_FSB_TO_AGNO(mp, *ap->firstblock); 328630f712c9SDave Chinner /* 328730f712c9SDave Chinner * If allocating at eof, and there's a previous real block, 328830f712c9SDave Chinner * try to use its last block as our starting point. 328930f712c9SDave Chinner */ 329030f712c9SDave Chinner if (ap->eof && ap->prev.br_startoff != NULLFILEOFF && 329130f712c9SDave Chinner !isnullstartblock(ap->prev.br_startblock) && 329230f712c9SDave Chinner ISVALID(ap->prev.br_startblock + ap->prev.br_blockcount, 329330f712c9SDave Chinner ap->prev.br_startblock)) { 329430f712c9SDave Chinner ap->blkno = ap->prev.br_startblock + ap->prev.br_blockcount; 329530f712c9SDave Chinner /* 329630f712c9SDave Chinner * Adjust for the gap between prevp and us. 329730f712c9SDave Chinner */ 329830f712c9SDave Chinner adjust = ap->offset - 329930f712c9SDave Chinner (ap->prev.br_startoff + ap->prev.br_blockcount); 330030f712c9SDave Chinner if (adjust && 330130f712c9SDave Chinner ISVALID(ap->blkno + adjust, ap->prev.br_startblock)) 330230f712c9SDave Chinner ap->blkno += adjust; 330330f712c9SDave Chinner } 330430f712c9SDave Chinner /* 330530f712c9SDave Chinner * If not at eof, then compare the two neighbor blocks. 330630f712c9SDave Chinner * Figure out whether either one gives us a good starting point, 330730f712c9SDave Chinner * and pick the better one. 330830f712c9SDave Chinner */ 330930f712c9SDave Chinner else if (!ap->eof) { 331030f712c9SDave Chinner xfs_fsblock_t gotbno; /* right side block number */ 331130f712c9SDave Chinner xfs_fsblock_t gotdiff=0; /* right side difference */ 331230f712c9SDave Chinner xfs_fsblock_t prevbno; /* left side block number */ 331330f712c9SDave Chinner xfs_fsblock_t prevdiff=0; /* left side difference */ 331430f712c9SDave Chinner 331530f712c9SDave Chinner /* 331630f712c9SDave Chinner * If there's a previous (left) block, select a requested 331730f712c9SDave Chinner * start block based on it. 331830f712c9SDave Chinner */ 331930f712c9SDave Chinner if (ap->prev.br_startoff != NULLFILEOFF && 332030f712c9SDave Chinner !isnullstartblock(ap->prev.br_startblock) && 332130f712c9SDave Chinner (prevbno = ap->prev.br_startblock + 332230f712c9SDave Chinner ap->prev.br_blockcount) && 332330f712c9SDave Chinner ISVALID(prevbno, ap->prev.br_startblock)) { 332430f712c9SDave Chinner /* 332530f712c9SDave Chinner * Calculate gap to end of previous block. 332630f712c9SDave Chinner */ 332730f712c9SDave Chinner adjust = prevdiff = ap->offset - 332830f712c9SDave Chinner (ap->prev.br_startoff + 332930f712c9SDave Chinner ap->prev.br_blockcount); 333030f712c9SDave Chinner /* 333130f712c9SDave Chinner * Figure the startblock based on the previous block's 333230f712c9SDave Chinner * end and the gap size. 333330f712c9SDave Chinner * Heuristic! 333430f712c9SDave Chinner * If the gap is large relative to the piece we're 333530f712c9SDave Chinner * allocating, or using it gives us an invalid block 333630f712c9SDave Chinner * number, then just use the end of the previous block. 333730f712c9SDave Chinner */ 333830f712c9SDave Chinner if (prevdiff <= XFS_ALLOC_GAP_UNITS * ap->length && 333930f712c9SDave Chinner ISVALID(prevbno + prevdiff, 334030f712c9SDave Chinner ap->prev.br_startblock)) 334130f712c9SDave Chinner prevbno += adjust; 334230f712c9SDave Chinner else 334330f712c9SDave Chinner prevdiff += adjust; 334430f712c9SDave Chinner /* 334530f712c9SDave Chinner * If the firstblock forbids it, can't use it, 334630f712c9SDave Chinner * must use default. 334730f712c9SDave Chinner */ 334830f712c9SDave Chinner if (!rt && !nullfb && 334930f712c9SDave Chinner XFS_FSB_TO_AGNO(mp, prevbno) != fb_agno) 335030f712c9SDave Chinner prevbno = NULLFSBLOCK; 335130f712c9SDave Chinner } 335230f712c9SDave Chinner /* 335330f712c9SDave Chinner * No previous block or can't follow it, just default. 335430f712c9SDave Chinner */ 335530f712c9SDave Chinner else 335630f712c9SDave Chinner prevbno = NULLFSBLOCK; 335730f712c9SDave Chinner /* 335830f712c9SDave Chinner * If there's a following (right) block, select a requested 335930f712c9SDave Chinner * start block based on it. 336030f712c9SDave Chinner */ 336130f712c9SDave Chinner if (!isnullstartblock(ap->got.br_startblock)) { 336230f712c9SDave Chinner /* 336330f712c9SDave Chinner * Calculate gap to start of next block. 336430f712c9SDave Chinner */ 336530f712c9SDave Chinner adjust = gotdiff = ap->got.br_startoff - ap->offset; 336630f712c9SDave Chinner /* 336730f712c9SDave Chinner * Figure the startblock based on the next block's 336830f712c9SDave Chinner * start and the gap size. 336930f712c9SDave Chinner */ 337030f712c9SDave Chinner gotbno = ap->got.br_startblock; 337130f712c9SDave Chinner /* 337230f712c9SDave Chinner * Heuristic! 337330f712c9SDave Chinner * If the gap is large relative to the piece we're 337430f712c9SDave Chinner * allocating, or using it gives us an invalid block 337530f712c9SDave Chinner * number, then just use the start of the next block 337630f712c9SDave Chinner * offset by our length. 337730f712c9SDave Chinner */ 337830f712c9SDave Chinner if (gotdiff <= XFS_ALLOC_GAP_UNITS * ap->length && 337930f712c9SDave Chinner ISVALID(gotbno - gotdiff, gotbno)) 338030f712c9SDave Chinner gotbno -= adjust; 338130f712c9SDave Chinner else if (ISVALID(gotbno - ap->length, gotbno)) { 338230f712c9SDave Chinner gotbno -= ap->length; 338330f712c9SDave Chinner gotdiff += adjust - ap->length; 338430f712c9SDave Chinner } else 338530f712c9SDave Chinner gotdiff += adjust; 338630f712c9SDave Chinner /* 338730f712c9SDave Chinner * If the firstblock forbids it, can't use it, 338830f712c9SDave Chinner * must use default. 338930f712c9SDave Chinner */ 339030f712c9SDave Chinner if (!rt && !nullfb && 339130f712c9SDave Chinner XFS_FSB_TO_AGNO(mp, gotbno) != fb_agno) 339230f712c9SDave Chinner gotbno = NULLFSBLOCK; 339330f712c9SDave Chinner } 339430f712c9SDave Chinner /* 339530f712c9SDave Chinner * No next block, just default. 339630f712c9SDave Chinner */ 339730f712c9SDave Chinner else 339830f712c9SDave Chinner gotbno = NULLFSBLOCK; 339930f712c9SDave Chinner /* 340030f712c9SDave Chinner * If both valid, pick the better one, else the only good 340130f712c9SDave Chinner * one, else ap->blkno is already set (to 0 or the inode block). 340230f712c9SDave Chinner */ 340330f712c9SDave Chinner if (prevbno != NULLFSBLOCK && gotbno != NULLFSBLOCK) 340430f712c9SDave Chinner ap->blkno = prevdiff <= gotdiff ? prevbno : gotbno; 340530f712c9SDave Chinner else if (prevbno != NULLFSBLOCK) 340630f712c9SDave Chinner ap->blkno = prevbno; 340730f712c9SDave Chinner else if (gotbno != NULLFSBLOCK) 340830f712c9SDave Chinner ap->blkno = gotbno; 340930f712c9SDave Chinner } 341030f712c9SDave Chinner #undef ISVALID 341130f712c9SDave Chinner } 341230f712c9SDave Chinner 341330f712c9SDave Chinner static int 341430f712c9SDave Chinner xfs_bmap_longest_free_extent( 341530f712c9SDave Chinner struct xfs_trans *tp, 341630f712c9SDave Chinner xfs_agnumber_t ag, 341730f712c9SDave Chinner xfs_extlen_t *blen, 341830f712c9SDave Chinner int *notinit) 341930f712c9SDave Chinner { 342030f712c9SDave Chinner struct xfs_mount *mp = tp->t_mountp; 342130f712c9SDave Chinner struct xfs_perag *pag; 342230f712c9SDave Chinner xfs_extlen_t longest; 342330f712c9SDave Chinner int error = 0; 342430f712c9SDave Chinner 342530f712c9SDave Chinner pag = xfs_perag_get(mp, ag); 342630f712c9SDave Chinner if (!pag->pagf_init) { 342730f712c9SDave Chinner error = xfs_alloc_pagf_init(mp, tp, ag, XFS_ALLOC_FLAG_TRYLOCK); 342830f712c9SDave Chinner if (error) 342930f712c9SDave Chinner goto out; 343030f712c9SDave Chinner 343130f712c9SDave Chinner if (!pag->pagf_init) { 343230f712c9SDave Chinner *notinit = 1; 343330f712c9SDave Chinner goto out; 343430f712c9SDave Chinner } 343530f712c9SDave Chinner } 343630f712c9SDave Chinner 343750adbcb4SDave Chinner longest = xfs_alloc_longest_free_extent(mp, pag, 34383fd129b6SDarrick J. Wong xfs_alloc_min_freelist(mp, pag), 34393fd129b6SDarrick J. Wong xfs_ag_resv_needed(pag, XFS_AG_RESV_NONE)); 344030f712c9SDave Chinner if (*blen < longest) 344130f712c9SDave Chinner *blen = longest; 344230f712c9SDave Chinner 344330f712c9SDave Chinner out: 344430f712c9SDave Chinner xfs_perag_put(pag); 344530f712c9SDave Chinner return error; 344630f712c9SDave Chinner } 344730f712c9SDave Chinner 344830f712c9SDave Chinner static void 344930f712c9SDave Chinner xfs_bmap_select_minlen( 345030f712c9SDave Chinner struct xfs_bmalloca *ap, 345130f712c9SDave Chinner struct xfs_alloc_arg *args, 345230f712c9SDave Chinner xfs_extlen_t *blen, 345330f712c9SDave Chinner int notinit) 345430f712c9SDave Chinner { 345530f712c9SDave Chinner if (notinit || *blen < ap->minlen) { 345630f712c9SDave Chinner /* 345730f712c9SDave Chinner * Since we did a BUF_TRYLOCK above, it is possible that 345830f712c9SDave Chinner * there is space for this request. 345930f712c9SDave Chinner */ 346030f712c9SDave Chinner args->minlen = ap->minlen; 346130f712c9SDave Chinner } else if (*blen < args->maxlen) { 346230f712c9SDave Chinner /* 346330f712c9SDave Chinner * If the best seen length is less than the request length, 346430f712c9SDave Chinner * use the best as the minimum. 346530f712c9SDave Chinner */ 346630f712c9SDave Chinner args->minlen = *blen; 346730f712c9SDave Chinner } else { 346830f712c9SDave Chinner /* 346930f712c9SDave Chinner * Otherwise we've seen an extent as big as maxlen, use that 347030f712c9SDave Chinner * as the minimum. 347130f712c9SDave Chinner */ 347230f712c9SDave Chinner args->minlen = args->maxlen; 347330f712c9SDave Chinner } 347430f712c9SDave Chinner } 347530f712c9SDave Chinner 347630f712c9SDave Chinner STATIC int 347730f712c9SDave Chinner xfs_bmap_btalloc_nullfb( 347830f712c9SDave Chinner struct xfs_bmalloca *ap, 347930f712c9SDave Chinner struct xfs_alloc_arg *args, 348030f712c9SDave Chinner xfs_extlen_t *blen) 348130f712c9SDave Chinner { 348230f712c9SDave Chinner struct xfs_mount *mp = ap->ip->i_mount; 348330f712c9SDave Chinner xfs_agnumber_t ag, startag; 348430f712c9SDave Chinner int notinit = 0; 348530f712c9SDave Chinner int error; 348630f712c9SDave Chinner 348730f712c9SDave Chinner args->type = XFS_ALLOCTYPE_START_BNO; 348830f712c9SDave Chinner args->total = ap->total; 348930f712c9SDave Chinner 349030f712c9SDave Chinner startag = ag = XFS_FSB_TO_AGNO(mp, args->fsbno); 349130f712c9SDave Chinner if (startag == NULLAGNUMBER) 349230f712c9SDave Chinner startag = ag = 0; 349330f712c9SDave Chinner 349430f712c9SDave Chinner while (*blen < args->maxlen) { 349530f712c9SDave Chinner error = xfs_bmap_longest_free_extent(args->tp, ag, blen, 349630f712c9SDave Chinner ¬init); 349730f712c9SDave Chinner if (error) 349830f712c9SDave Chinner return error; 349930f712c9SDave Chinner 350030f712c9SDave Chinner if (++ag == mp->m_sb.sb_agcount) 350130f712c9SDave Chinner ag = 0; 350230f712c9SDave Chinner if (ag == startag) 350330f712c9SDave Chinner break; 350430f712c9SDave Chinner } 350530f712c9SDave Chinner 350630f712c9SDave Chinner xfs_bmap_select_minlen(ap, args, blen, notinit); 350730f712c9SDave Chinner return 0; 350830f712c9SDave Chinner } 350930f712c9SDave Chinner 351030f712c9SDave Chinner STATIC int 351130f712c9SDave Chinner xfs_bmap_btalloc_filestreams( 351230f712c9SDave Chinner struct xfs_bmalloca *ap, 351330f712c9SDave Chinner struct xfs_alloc_arg *args, 351430f712c9SDave Chinner xfs_extlen_t *blen) 351530f712c9SDave Chinner { 351630f712c9SDave Chinner struct xfs_mount *mp = ap->ip->i_mount; 351730f712c9SDave Chinner xfs_agnumber_t ag; 351830f712c9SDave Chinner int notinit = 0; 351930f712c9SDave Chinner int error; 352030f712c9SDave Chinner 352130f712c9SDave Chinner args->type = XFS_ALLOCTYPE_NEAR_BNO; 352230f712c9SDave Chinner args->total = ap->total; 352330f712c9SDave Chinner 352430f712c9SDave Chinner ag = XFS_FSB_TO_AGNO(mp, args->fsbno); 352530f712c9SDave Chinner if (ag == NULLAGNUMBER) 352630f712c9SDave Chinner ag = 0; 352730f712c9SDave Chinner 352830f712c9SDave Chinner error = xfs_bmap_longest_free_extent(args->tp, ag, blen, ¬init); 352930f712c9SDave Chinner if (error) 353030f712c9SDave Chinner return error; 353130f712c9SDave Chinner 353230f712c9SDave Chinner if (*blen < args->maxlen) { 353330f712c9SDave Chinner error = xfs_filestream_new_ag(ap, &ag); 353430f712c9SDave Chinner if (error) 353530f712c9SDave Chinner return error; 353630f712c9SDave Chinner 353730f712c9SDave Chinner error = xfs_bmap_longest_free_extent(args->tp, ag, blen, 353830f712c9SDave Chinner ¬init); 353930f712c9SDave Chinner if (error) 354030f712c9SDave Chinner return error; 354130f712c9SDave Chinner 354230f712c9SDave Chinner } 354330f712c9SDave Chinner 354430f712c9SDave Chinner xfs_bmap_select_minlen(ap, args, blen, notinit); 354530f712c9SDave Chinner 354630f712c9SDave Chinner /* 354730f712c9SDave Chinner * Set the failure fallback case to look in the selected AG as stream 354830f712c9SDave Chinner * may have moved. 354930f712c9SDave Chinner */ 355030f712c9SDave Chinner ap->blkno = args->fsbno = XFS_AGB_TO_FSB(mp, ag, 0); 355130f712c9SDave Chinner return 0; 355230f712c9SDave Chinner } 355330f712c9SDave Chinner 355430f712c9SDave Chinner STATIC int 355530f712c9SDave Chinner xfs_bmap_btalloc( 355630f712c9SDave Chinner struct xfs_bmalloca *ap) /* bmap alloc argument struct */ 355730f712c9SDave Chinner { 355830f712c9SDave Chinner xfs_mount_t *mp; /* mount point structure */ 355930f712c9SDave Chinner xfs_alloctype_t atype = 0; /* type for allocation routines */ 3560292378edSDave Chinner xfs_extlen_t align = 0; /* minimum allocation alignment */ 356130f712c9SDave Chinner xfs_agnumber_t fb_agno; /* ag number of ap->firstblock */ 356230f712c9SDave Chinner xfs_agnumber_t ag; 356330f712c9SDave Chinner xfs_alloc_arg_t args; 356430f712c9SDave Chinner xfs_extlen_t blen; 356530f712c9SDave Chinner xfs_extlen_t nextminlen = 0; 356630f712c9SDave Chinner int nullfb; /* true if ap->firstblock isn't set */ 356730f712c9SDave Chinner int isaligned; 356830f712c9SDave Chinner int tryagain; 356930f712c9SDave Chinner int error; 357030f712c9SDave Chinner int stripe_align; 357130f712c9SDave Chinner 357230f712c9SDave Chinner ASSERT(ap->length); 357330f712c9SDave Chinner 357430f712c9SDave Chinner mp = ap->ip->i_mount; 357530f712c9SDave Chinner 357630f712c9SDave Chinner /* stripe alignment for allocation is determined by mount parameters */ 357730f712c9SDave Chinner stripe_align = 0; 357830f712c9SDave Chinner if (mp->m_swidth && (mp->m_flags & XFS_MOUNT_SWALLOC)) 357930f712c9SDave Chinner stripe_align = mp->m_swidth; 358030f712c9SDave Chinner else if (mp->m_dalign) 358130f712c9SDave Chinner stripe_align = mp->m_dalign; 358230f712c9SDave Chinner 3583f7ca3522SDarrick J. Wong if (ap->flags & XFS_BMAPI_COWFORK) 3584f7ca3522SDarrick J. Wong align = xfs_get_cowextsz_hint(ap->ip); 3585f7ca3522SDarrick J. Wong else if (xfs_alloc_is_userdata(ap->datatype)) 3586292378edSDave Chinner align = xfs_get_extsz_hint(ap->ip); 3587493611ebSChristoph Hellwig if (align) { 358830f712c9SDave Chinner error = xfs_bmap_extsize_align(mp, &ap->got, &ap->prev, 358930f712c9SDave Chinner align, 0, ap->eof, 0, ap->conv, 359030f712c9SDave Chinner &ap->offset, &ap->length); 359130f712c9SDave Chinner ASSERT(!error); 359230f712c9SDave Chinner ASSERT(ap->length); 359330f712c9SDave Chinner } 359430f712c9SDave Chinner 359530f712c9SDave Chinner 359630f712c9SDave Chinner nullfb = *ap->firstblock == NULLFSBLOCK; 359730f712c9SDave Chinner fb_agno = nullfb ? NULLAGNUMBER : XFS_FSB_TO_AGNO(mp, *ap->firstblock); 359830f712c9SDave Chinner if (nullfb) { 3599292378edSDave Chinner if (xfs_alloc_is_userdata(ap->datatype) && 3600292378edSDave Chinner xfs_inode_is_filestream(ap->ip)) { 360130f712c9SDave Chinner ag = xfs_filestream_lookup_ag(ap->ip); 360230f712c9SDave Chinner ag = (ag != NULLAGNUMBER) ? ag : 0; 360330f712c9SDave Chinner ap->blkno = XFS_AGB_TO_FSB(mp, ag, 0); 360430f712c9SDave Chinner } else { 360530f712c9SDave Chinner ap->blkno = XFS_INO_TO_FSB(mp, ap->ip->i_ino); 360630f712c9SDave Chinner } 360730f712c9SDave Chinner } else 360830f712c9SDave Chinner ap->blkno = *ap->firstblock; 360930f712c9SDave Chinner 361030f712c9SDave Chinner xfs_bmap_adjacent(ap); 361130f712c9SDave Chinner 361230f712c9SDave Chinner /* 361330f712c9SDave Chinner * If allowed, use ap->blkno; otherwise must use firstblock since 361430f712c9SDave Chinner * it's in the right allocation group. 361530f712c9SDave Chinner */ 361630f712c9SDave Chinner if (nullfb || XFS_FSB_TO_AGNO(mp, ap->blkno) == fb_agno) 361730f712c9SDave Chinner ; 361830f712c9SDave Chinner else 361930f712c9SDave Chinner ap->blkno = *ap->firstblock; 362030f712c9SDave Chinner /* 362130f712c9SDave Chinner * Normal allocation, done through xfs_alloc_vextent. 362230f712c9SDave Chinner */ 362330f712c9SDave Chinner tryagain = isaligned = 0; 362430f712c9SDave Chinner memset(&args, 0, sizeof(args)); 362530f712c9SDave Chinner args.tp = ap->tp; 362630f712c9SDave Chinner args.mp = mp; 362730f712c9SDave Chinner args.fsbno = ap->blkno; 3628340785ccSDarrick J. Wong xfs_rmap_skip_owner_update(&args.oinfo); 362930f712c9SDave Chinner 363030f712c9SDave Chinner /* Trim the allocation back to the maximum an AG can fit. */ 363152548852SDarrick J. Wong args.maxlen = MIN(ap->length, mp->m_ag_max_usable); 363230f712c9SDave Chinner args.firstblock = *ap->firstblock; 363330f712c9SDave Chinner blen = 0; 363430f712c9SDave Chinner if (nullfb) { 363530f712c9SDave Chinner /* 363630f712c9SDave Chinner * Search for an allocation group with a single extent large 363730f712c9SDave Chinner * enough for the request. If one isn't found, then adjust 363830f712c9SDave Chinner * the minimum allocation size to the largest space found. 363930f712c9SDave Chinner */ 3640292378edSDave Chinner if (xfs_alloc_is_userdata(ap->datatype) && 3641292378edSDave Chinner xfs_inode_is_filestream(ap->ip)) 364230f712c9SDave Chinner error = xfs_bmap_btalloc_filestreams(ap, &args, &blen); 364330f712c9SDave Chinner else 364430f712c9SDave Chinner error = xfs_bmap_btalloc_nullfb(ap, &args, &blen); 364530f712c9SDave Chinner if (error) 364630f712c9SDave Chinner return error; 36472c3234d1SDarrick J. Wong } else if (ap->dfops->dop_low) { 364830f712c9SDave Chinner if (xfs_inode_is_filestream(ap->ip)) 364930f712c9SDave Chinner args.type = XFS_ALLOCTYPE_FIRST_AG; 365030f712c9SDave Chinner else 365130f712c9SDave Chinner args.type = XFS_ALLOCTYPE_START_BNO; 365230f712c9SDave Chinner args.total = args.minlen = ap->minlen; 365330f712c9SDave Chinner } else { 365430f712c9SDave Chinner args.type = XFS_ALLOCTYPE_NEAR_BNO; 365530f712c9SDave Chinner args.total = ap->total; 365630f712c9SDave Chinner args.minlen = ap->minlen; 365730f712c9SDave Chinner } 365830f712c9SDave Chinner /* apply extent size hints if obtained earlier */ 3659493611ebSChristoph Hellwig if (align) { 366030f712c9SDave Chinner args.prod = align; 366130f712c9SDave Chinner if ((args.mod = (xfs_extlen_t)do_mod(ap->offset, args.prod))) 366230f712c9SDave Chinner args.mod = (xfs_extlen_t)(args.prod - args.mod); 366309cbfeafSKirill A. Shutemov } else if (mp->m_sb.sb_blocksize >= PAGE_SIZE) { 366430f712c9SDave Chinner args.prod = 1; 366530f712c9SDave Chinner args.mod = 0; 366630f712c9SDave Chinner } else { 366709cbfeafSKirill A. Shutemov args.prod = PAGE_SIZE >> mp->m_sb.sb_blocklog; 366830f712c9SDave Chinner if ((args.mod = (xfs_extlen_t)(do_mod(ap->offset, args.prod)))) 366930f712c9SDave Chinner args.mod = (xfs_extlen_t)(args.prod - args.mod); 367030f712c9SDave Chinner } 367130f712c9SDave Chinner /* 367230f712c9SDave Chinner * If we are not low on available data blocks, and the 367330f712c9SDave Chinner * underlying logical volume manager is a stripe, and 367430f712c9SDave Chinner * the file offset is zero then try to allocate data 367530f712c9SDave Chinner * blocks on stripe unit boundary. 367630f712c9SDave Chinner * NOTE: ap->aeof is only set if the allocation length 367730f712c9SDave Chinner * is >= the stripe unit and the allocation offset is 367830f712c9SDave Chinner * at the end of file. 367930f712c9SDave Chinner */ 36802c3234d1SDarrick J. Wong if (!ap->dfops->dop_low && ap->aeof) { 368130f712c9SDave Chinner if (!ap->offset) { 368230f712c9SDave Chinner args.alignment = stripe_align; 368330f712c9SDave Chinner atype = args.type; 368430f712c9SDave Chinner isaligned = 1; 368530f712c9SDave Chinner /* 368630f712c9SDave Chinner * Adjust for alignment 368730f712c9SDave Chinner */ 368830f712c9SDave Chinner if (blen > args.alignment && blen <= args.maxlen) 368930f712c9SDave Chinner args.minlen = blen - args.alignment; 369030f712c9SDave Chinner args.minalignslop = 0; 369130f712c9SDave Chinner } else { 369230f712c9SDave Chinner /* 369330f712c9SDave Chinner * First try an exact bno allocation. 369430f712c9SDave Chinner * If it fails then do a near or start bno 369530f712c9SDave Chinner * allocation with alignment turned on. 369630f712c9SDave Chinner */ 369730f712c9SDave Chinner atype = args.type; 369830f712c9SDave Chinner tryagain = 1; 369930f712c9SDave Chinner args.type = XFS_ALLOCTYPE_THIS_BNO; 370030f712c9SDave Chinner args.alignment = 1; 370130f712c9SDave Chinner /* 370230f712c9SDave Chinner * Compute the minlen+alignment for the 370330f712c9SDave Chinner * next case. Set slop so that the value 370430f712c9SDave Chinner * of minlen+alignment+slop doesn't go up 370530f712c9SDave Chinner * between the calls. 370630f712c9SDave Chinner */ 370730f712c9SDave Chinner if (blen > stripe_align && blen <= args.maxlen) 370830f712c9SDave Chinner nextminlen = blen - stripe_align; 370930f712c9SDave Chinner else 371030f712c9SDave Chinner nextminlen = args.minlen; 371130f712c9SDave Chinner if (nextminlen + stripe_align > args.minlen + 1) 371230f712c9SDave Chinner args.minalignslop = 371330f712c9SDave Chinner nextminlen + stripe_align - 371430f712c9SDave Chinner args.minlen - 1; 371530f712c9SDave Chinner else 371630f712c9SDave Chinner args.minalignslop = 0; 371730f712c9SDave Chinner } 371830f712c9SDave Chinner } else { 371930f712c9SDave Chinner args.alignment = 1; 372030f712c9SDave Chinner args.minalignslop = 0; 372130f712c9SDave Chinner } 372230f712c9SDave Chinner args.minleft = ap->minleft; 372330f712c9SDave Chinner args.wasdel = ap->wasdel; 37243fd129b6SDarrick J. Wong args.resv = XFS_AG_RESV_NONE; 3725292378edSDave Chinner args.datatype = ap->datatype; 3726292378edSDave Chinner if (ap->datatype & XFS_ALLOC_USERDATA_ZERO) 37273fbbbea3SDave Chinner args.ip = ap->ip; 37283fbbbea3SDave Chinner 37293fbbbea3SDave Chinner error = xfs_alloc_vextent(&args); 37303fbbbea3SDave Chinner if (error) 373130f712c9SDave Chinner return error; 37323fbbbea3SDave Chinner 373330f712c9SDave Chinner if (tryagain && args.fsbno == NULLFSBLOCK) { 373430f712c9SDave Chinner /* 373530f712c9SDave Chinner * Exact allocation failed. Now try with alignment 373630f712c9SDave Chinner * turned on. 373730f712c9SDave Chinner */ 373830f712c9SDave Chinner args.type = atype; 373930f712c9SDave Chinner args.fsbno = ap->blkno; 374030f712c9SDave Chinner args.alignment = stripe_align; 374130f712c9SDave Chinner args.minlen = nextminlen; 374230f712c9SDave Chinner args.minalignslop = 0; 374330f712c9SDave Chinner isaligned = 1; 374430f712c9SDave Chinner if ((error = xfs_alloc_vextent(&args))) 374530f712c9SDave Chinner return error; 374630f712c9SDave Chinner } 374730f712c9SDave Chinner if (isaligned && args.fsbno == NULLFSBLOCK) { 374830f712c9SDave Chinner /* 374930f712c9SDave Chinner * allocation failed, so turn off alignment and 375030f712c9SDave Chinner * try again. 375130f712c9SDave Chinner */ 375230f712c9SDave Chinner args.type = atype; 375330f712c9SDave Chinner args.fsbno = ap->blkno; 375430f712c9SDave Chinner args.alignment = 0; 375530f712c9SDave Chinner if ((error = xfs_alloc_vextent(&args))) 375630f712c9SDave Chinner return error; 375730f712c9SDave Chinner } 375830f712c9SDave Chinner if (args.fsbno == NULLFSBLOCK && nullfb && 375930f712c9SDave Chinner args.minlen > ap->minlen) { 376030f712c9SDave Chinner args.minlen = ap->minlen; 376130f712c9SDave Chinner args.type = XFS_ALLOCTYPE_START_BNO; 376230f712c9SDave Chinner args.fsbno = ap->blkno; 376330f712c9SDave Chinner if ((error = xfs_alloc_vextent(&args))) 376430f712c9SDave Chinner return error; 376530f712c9SDave Chinner } 376630f712c9SDave Chinner if (args.fsbno == NULLFSBLOCK && nullfb) { 376730f712c9SDave Chinner args.fsbno = 0; 376830f712c9SDave Chinner args.type = XFS_ALLOCTYPE_FIRST_AG; 376930f712c9SDave Chinner args.total = ap->minlen; 377030f712c9SDave Chinner if ((error = xfs_alloc_vextent(&args))) 377130f712c9SDave Chinner return error; 37722c3234d1SDarrick J. Wong ap->dfops->dop_low = true; 377330f712c9SDave Chinner } 377430f712c9SDave Chinner if (args.fsbno != NULLFSBLOCK) { 377530f712c9SDave Chinner /* 377630f712c9SDave Chinner * check the allocation happened at the same or higher AG than 377730f712c9SDave Chinner * the first block that was allocated. 377830f712c9SDave Chinner */ 377930f712c9SDave Chinner ASSERT(*ap->firstblock == NULLFSBLOCK || 3780410d17f6SChristoph Hellwig XFS_FSB_TO_AGNO(mp, *ap->firstblock) <= 3781410d17f6SChristoph Hellwig XFS_FSB_TO_AGNO(mp, args.fsbno)); 378230f712c9SDave Chinner 378330f712c9SDave Chinner ap->blkno = args.fsbno; 378430f712c9SDave Chinner if (*ap->firstblock == NULLFSBLOCK) 378530f712c9SDave Chinner *ap->firstblock = args.fsbno; 3786410d17f6SChristoph Hellwig ASSERT(nullfb || fb_agno <= args.agno); 378730f712c9SDave Chinner ap->length = args.len; 378860b4984fSDarrick J. Wong if (!(ap->flags & XFS_BMAPI_COWFORK)) 378930f712c9SDave Chinner ap->ip->i_d.di_nblocks += args.len; 379030f712c9SDave Chinner xfs_trans_log_inode(ap->tp, ap->ip, XFS_ILOG_CORE); 379130f712c9SDave Chinner if (ap->wasdel) 379230f712c9SDave Chinner ap->ip->i_delayed_blks -= args.len; 379330f712c9SDave Chinner /* 379430f712c9SDave Chinner * Adjust the disk quota also. This was reserved 379530f712c9SDave Chinner * earlier. 379630f712c9SDave Chinner */ 379730f712c9SDave Chinner xfs_trans_mod_dquot_byino(ap->tp, ap->ip, 379830f712c9SDave Chinner ap->wasdel ? XFS_TRANS_DQ_DELBCOUNT : 379930f712c9SDave Chinner XFS_TRANS_DQ_BCOUNT, 380030f712c9SDave Chinner (long) args.len); 380130f712c9SDave Chinner } else { 380230f712c9SDave Chinner ap->blkno = NULLFSBLOCK; 380330f712c9SDave Chinner ap->length = 0; 380430f712c9SDave Chinner } 380530f712c9SDave Chinner return 0; 380630f712c9SDave Chinner } 380730f712c9SDave Chinner 380830f712c9SDave Chinner /* 380930f712c9SDave Chinner * xfs_bmap_alloc is called by xfs_bmapi to allocate an extent for a file. 381030f712c9SDave Chinner * It figures out where to ask the underlying allocator to put the new extent. 381130f712c9SDave Chinner */ 381230f712c9SDave Chinner STATIC int 381330f712c9SDave Chinner xfs_bmap_alloc( 381430f712c9SDave Chinner struct xfs_bmalloca *ap) /* bmap alloc argument struct */ 381530f712c9SDave Chinner { 3816292378edSDave Chinner if (XFS_IS_REALTIME_INODE(ap->ip) && 3817292378edSDave Chinner xfs_alloc_is_userdata(ap->datatype)) 381830f712c9SDave Chinner return xfs_bmap_rtalloc(ap); 381930f712c9SDave Chinner return xfs_bmap_btalloc(ap); 382030f712c9SDave Chinner } 382130f712c9SDave Chinner 38220a0af28cSDarrick J. Wong /* Trim extent to fit a logical block range. */ 38230a0af28cSDarrick J. Wong void 38240a0af28cSDarrick J. Wong xfs_trim_extent( 38250a0af28cSDarrick J. Wong struct xfs_bmbt_irec *irec, 38260a0af28cSDarrick J. Wong xfs_fileoff_t bno, 38270a0af28cSDarrick J. Wong xfs_filblks_t len) 38280a0af28cSDarrick J. Wong { 38290a0af28cSDarrick J. Wong xfs_fileoff_t distance; 38300a0af28cSDarrick J. Wong xfs_fileoff_t end = bno + len; 38310a0af28cSDarrick J. Wong 38320a0af28cSDarrick J. Wong if (irec->br_startoff + irec->br_blockcount <= bno || 38330a0af28cSDarrick J. Wong irec->br_startoff >= end) { 38340a0af28cSDarrick J. Wong irec->br_blockcount = 0; 38350a0af28cSDarrick J. Wong return; 38360a0af28cSDarrick J. Wong } 38370a0af28cSDarrick J. Wong 38380a0af28cSDarrick J. Wong if (irec->br_startoff < bno) { 38390a0af28cSDarrick J. Wong distance = bno - irec->br_startoff; 38400a0af28cSDarrick J. Wong if (isnullstartblock(irec->br_startblock)) 38410a0af28cSDarrick J. Wong irec->br_startblock = DELAYSTARTBLOCK; 38420a0af28cSDarrick J. Wong if (irec->br_startblock != DELAYSTARTBLOCK && 38430a0af28cSDarrick J. Wong irec->br_startblock != HOLESTARTBLOCK) 38440a0af28cSDarrick J. Wong irec->br_startblock += distance; 38450a0af28cSDarrick J. Wong irec->br_startoff += distance; 38460a0af28cSDarrick J. Wong irec->br_blockcount -= distance; 38470a0af28cSDarrick J. Wong } 38480a0af28cSDarrick J. Wong 38490a0af28cSDarrick J. Wong if (end < irec->br_startoff + irec->br_blockcount) { 38500a0af28cSDarrick J. Wong distance = irec->br_startoff + irec->br_blockcount - end; 38510a0af28cSDarrick J. Wong irec->br_blockcount -= distance; 38520a0af28cSDarrick J. Wong } 38530a0af28cSDarrick J. Wong } 38540a0af28cSDarrick J. Wong 385540214d12SBrian Foster /* trim extent to within eof */ 385640214d12SBrian Foster void 385740214d12SBrian Foster xfs_trim_extent_eof( 385840214d12SBrian Foster struct xfs_bmbt_irec *irec, 385940214d12SBrian Foster struct xfs_inode *ip) 386040214d12SBrian Foster 386140214d12SBrian Foster { 386240214d12SBrian Foster xfs_trim_extent(irec, 0, XFS_B_TO_FSB(ip->i_mount, 386340214d12SBrian Foster i_size_read(VFS_I(ip)))); 386440214d12SBrian Foster } 386540214d12SBrian Foster 386630f712c9SDave Chinner /* 386730f712c9SDave Chinner * Trim the returned map to the required bounds 386830f712c9SDave Chinner */ 386930f712c9SDave Chinner STATIC void 387030f712c9SDave Chinner xfs_bmapi_trim_map( 387130f712c9SDave Chinner struct xfs_bmbt_irec *mval, 387230f712c9SDave Chinner struct xfs_bmbt_irec *got, 387330f712c9SDave Chinner xfs_fileoff_t *bno, 387430f712c9SDave Chinner xfs_filblks_t len, 387530f712c9SDave Chinner xfs_fileoff_t obno, 387630f712c9SDave Chinner xfs_fileoff_t end, 387730f712c9SDave Chinner int n, 387830f712c9SDave Chinner int flags) 387930f712c9SDave Chinner { 388030f712c9SDave Chinner if ((flags & XFS_BMAPI_ENTIRE) || 388130f712c9SDave Chinner got->br_startoff + got->br_blockcount <= obno) { 388230f712c9SDave Chinner *mval = *got; 388330f712c9SDave Chinner if (isnullstartblock(got->br_startblock)) 388430f712c9SDave Chinner mval->br_startblock = DELAYSTARTBLOCK; 388530f712c9SDave Chinner return; 388630f712c9SDave Chinner } 388730f712c9SDave Chinner 388830f712c9SDave Chinner if (obno > *bno) 388930f712c9SDave Chinner *bno = obno; 389030f712c9SDave Chinner ASSERT((*bno >= obno) || (n == 0)); 389130f712c9SDave Chinner ASSERT(*bno < end); 389230f712c9SDave Chinner mval->br_startoff = *bno; 389330f712c9SDave Chinner if (isnullstartblock(got->br_startblock)) 389430f712c9SDave Chinner mval->br_startblock = DELAYSTARTBLOCK; 389530f712c9SDave Chinner else 389630f712c9SDave Chinner mval->br_startblock = got->br_startblock + 389730f712c9SDave Chinner (*bno - got->br_startoff); 389830f712c9SDave Chinner /* 389930f712c9SDave Chinner * Return the minimum of what we got and what we asked for for 390030f712c9SDave Chinner * the length. We can use the len variable here because it is 390130f712c9SDave Chinner * modified below and we could have been there before coming 390230f712c9SDave Chinner * here if the first part of the allocation didn't overlap what 390330f712c9SDave Chinner * was asked for. 390430f712c9SDave Chinner */ 390530f712c9SDave Chinner mval->br_blockcount = XFS_FILBLKS_MIN(end - *bno, 390630f712c9SDave Chinner got->br_blockcount - (*bno - got->br_startoff)); 390730f712c9SDave Chinner mval->br_state = got->br_state; 390830f712c9SDave Chinner ASSERT(mval->br_blockcount <= len); 390930f712c9SDave Chinner return; 391030f712c9SDave Chinner } 391130f712c9SDave Chinner 391230f712c9SDave Chinner /* 391330f712c9SDave Chinner * Update and validate the extent map to return 391430f712c9SDave Chinner */ 391530f712c9SDave Chinner STATIC void 391630f712c9SDave Chinner xfs_bmapi_update_map( 391730f712c9SDave Chinner struct xfs_bmbt_irec **map, 391830f712c9SDave Chinner xfs_fileoff_t *bno, 391930f712c9SDave Chinner xfs_filblks_t *len, 392030f712c9SDave Chinner xfs_fileoff_t obno, 392130f712c9SDave Chinner xfs_fileoff_t end, 392230f712c9SDave Chinner int *n, 392330f712c9SDave Chinner int flags) 392430f712c9SDave Chinner { 392530f712c9SDave Chinner xfs_bmbt_irec_t *mval = *map; 392630f712c9SDave Chinner 392730f712c9SDave Chinner ASSERT((flags & XFS_BMAPI_ENTIRE) || 392830f712c9SDave Chinner ((mval->br_startoff + mval->br_blockcount) <= end)); 392930f712c9SDave Chinner ASSERT((flags & XFS_BMAPI_ENTIRE) || (mval->br_blockcount <= *len) || 393030f712c9SDave Chinner (mval->br_startoff < obno)); 393130f712c9SDave Chinner 393230f712c9SDave Chinner *bno = mval->br_startoff + mval->br_blockcount; 393330f712c9SDave Chinner *len = end - *bno; 393430f712c9SDave Chinner if (*n > 0 && mval->br_startoff == mval[-1].br_startoff) { 393530f712c9SDave Chinner /* update previous map with new information */ 393630f712c9SDave Chinner ASSERT(mval->br_startblock == mval[-1].br_startblock); 393730f712c9SDave Chinner ASSERT(mval->br_blockcount > mval[-1].br_blockcount); 393830f712c9SDave Chinner ASSERT(mval->br_state == mval[-1].br_state); 393930f712c9SDave Chinner mval[-1].br_blockcount = mval->br_blockcount; 394030f712c9SDave Chinner mval[-1].br_state = mval->br_state; 394130f712c9SDave Chinner } else if (*n > 0 && mval->br_startblock != DELAYSTARTBLOCK && 394230f712c9SDave Chinner mval[-1].br_startblock != DELAYSTARTBLOCK && 394330f712c9SDave Chinner mval[-1].br_startblock != HOLESTARTBLOCK && 394430f712c9SDave Chinner mval->br_startblock == mval[-1].br_startblock + 394530f712c9SDave Chinner mval[-1].br_blockcount && 394630f712c9SDave Chinner ((flags & XFS_BMAPI_IGSTATE) || 394730f712c9SDave Chinner mval[-1].br_state == mval->br_state)) { 394830f712c9SDave Chinner ASSERT(mval->br_startoff == 394930f712c9SDave Chinner mval[-1].br_startoff + mval[-1].br_blockcount); 395030f712c9SDave Chinner mval[-1].br_blockcount += mval->br_blockcount; 395130f712c9SDave Chinner } else if (*n > 0 && 395230f712c9SDave Chinner mval->br_startblock == DELAYSTARTBLOCK && 395330f712c9SDave Chinner mval[-1].br_startblock == DELAYSTARTBLOCK && 395430f712c9SDave Chinner mval->br_startoff == 395530f712c9SDave Chinner mval[-1].br_startoff + mval[-1].br_blockcount) { 395630f712c9SDave Chinner mval[-1].br_blockcount += mval->br_blockcount; 395730f712c9SDave Chinner mval[-1].br_state = mval->br_state; 395830f712c9SDave Chinner } else if (!((*n == 0) && 395930f712c9SDave Chinner ((mval->br_startoff + mval->br_blockcount) <= 396030f712c9SDave Chinner obno))) { 396130f712c9SDave Chinner mval++; 396230f712c9SDave Chinner (*n)++; 396330f712c9SDave Chinner } 396430f712c9SDave Chinner *map = mval; 396530f712c9SDave Chinner } 396630f712c9SDave Chinner 396730f712c9SDave Chinner /* 396830f712c9SDave Chinner * Map file blocks to filesystem blocks without allocation. 396930f712c9SDave Chinner */ 397030f712c9SDave Chinner int 397130f712c9SDave Chinner xfs_bmapi_read( 397230f712c9SDave Chinner struct xfs_inode *ip, 397330f712c9SDave Chinner xfs_fileoff_t bno, 397430f712c9SDave Chinner xfs_filblks_t len, 397530f712c9SDave Chinner struct xfs_bmbt_irec *mval, 397630f712c9SDave Chinner int *nmap, 397730f712c9SDave Chinner int flags) 397830f712c9SDave Chinner { 397930f712c9SDave Chinner struct xfs_mount *mp = ip->i_mount; 398030f712c9SDave Chinner struct xfs_ifork *ifp; 398130f712c9SDave Chinner struct xfs_bmbt_irec got; 398230f712c9SDave Chinner xfs_fileoff_t obno; 398330f712c9SDave Chinner xfs_fileoff_t end; 3984334f3423SChristoph Hellwig xfs_extnum_t idx; 398530f712c9SDave Chinner int error; 3986334f3423SChristoph Hellwig bool eof = false; 398730f712c9SDave Chinner int n = 0; 39883993baebSDarrick J. Wong int whichfork = xfs_bmapi_whichfork(flags); 398930f712c9SDave Chinner 399030f712c9SDave Chinner ASSERT(*nmap >= 1); 399130f712c9SDave Chinner ASSERT(!(flags & ~(XFS_BMAPI_ATTRFORK|XFS_BMAPI_ENTIRE| 39923993baebSDarrick J. Wong XFS_BMAPI_IGSTATE|XFS_BMAPI_COWFORK))); 399330f712c9SDave Chinner ASSERT(xfs_isilocked(ip, XFS_ILOCK_SHARED|XFS_ILOCK_EXCL)); 399430f712c9SDave Chinner 399530f712c9SDave Chinner if (unlikely(XFS_TEST_ERROR( 399630f712c9SDave Chinner (XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS && 399730f712c9SDave Chinner XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE), 39989e24cfd0SDarrick J. Wong mp, XFS_ERRTAG_BMAPIFORMAT))) { 399930f712c9SDave Chinner XFS_ERROR_REPORT("xfs_bmapi_read", XFS_ERRLEVEL_LOW, mp); 40002451337dSDave Chinner return -EFSCORRUPTED; 400130f712c9SDave Chinner } 400230f712c9SDave Chinner 400330f712c9SDave Chinner if (XFS_FORCED_SHUTDOWN(mp)) 40042451337dSDave Chinner return -EIO; 400530f712c9SDave Chinner 4006ff6d6af2SBill O'Donnell XFS_STATS_INC(mp, xs_blk_mapr); 400730f712c9SDave Chinner 400830f712c9SDave Chinner ifp = XFS_IFORK_PTR(ip, whichfork); 400930f712c9SDave Chinner 40103993baebSDarrick J. Wong /* No CoW fork? Return a hole. */ 40113993baebSDarrick J. Wong if (whichfork == XFS_COW_FORK && !ifp) { 40123993baebSDarrick J. Wong mval->br_startoff = bno; 40133993baebSDarrick J. Wong mval->br_startblock = HOLESTARTBLOCK; 40143993baebSDarrick J. Wong mval->br_blockcount = len; 40153993baebSDarrick J. Wong mval->br_state = XFS_EXT_NORM; 40163993baebSDarrick J. Wong *nmap = 1; 40173993baebSDarrick J. Wong return 0; 40183993baebSDarrick J. Wong } 40193993baebSDarrick J. Wong 402030f712c9SDave Chinner if (!(ifp->if_flags & XFS_IFEXTENTS)) { 402130f712c9SDave Chinner error = xfs_iread_extents(NULL, ip, whichfork); 402230f712c9SDave Chinner if (error) 402330f712c9SDave Chinner return error; 402430f712c9SDave Chinner } 402530f712c9SDave Chinner 4026334f3423SChristoph Hellwig if (!xfs_iext_lookup_extent(ip, ifp, bno, &idx, &got)) 4027334f3423SChristoph Hellwig eof = true; 402830f712c9SDave Chinner end = bno + len; 402930f712c9SDave Chinner obno = bno; 403030f712c9SDave Chinner 403130f712c9SDave Chinner while (bno < end && n < *nmap) { 403230f712c9SDave Chinner /* Reading past eof, act as though there's a hole up to end. */ 403330f712c9SDave Chinner if (eof) 403430f712c9SDave Chinner got.br_startoff = end; 403530f712c9SDave Chinner if (got.br_startoff > bno) { 403630f712c9SDave Chinner /* Reading in a hole. */ 403730f712c9SDave Chinner mval->br_startoff = bno; 403830f712c9SDave Chinner mval->br_startblock = HOLESTARTBLOCK; 403930f712c9SDave Chinner mval->br_blockcount = 404030f712c9SDave Chinner XFS_FILBLKS_MIN(len, got.br_startoff - bno); 404130f712c9SDave Chinner mval->br_state = XFS_EXT_NORM; 404230f712c9SDave Chinner bno += mval->br_blockcount; 404330f712c9SDave Chinner len -= mval->br_blockcount; 404430f712c9SDave Chinner mval++; 404530f712c9SDave Chinner n++; 404630f712c9SDave Chinner continue; 404730f712c9SDave Chinner } 404830f712c9SDave Chinner 404930f712c9SDave Chinner /* set up the extent map to return. */ 405030f712c9SDave Chinner xfs_bmapi_trim_map(mval, &got, &bno, len, obno, end, n, flags); 405130f712c9SDave Chinner xfs_bmapi_update_map(&mval, &bno, &len, obno, end, &n, flags); 405230f712c9SDave Chinner 405330f712c9SDave Chinner /* If we're done, stop now. */ 405430f712c9SDave Chinner if (bno >= end || n >= *nmap) 405530f712c9SDave Chinner break; 405630f712c9SDave Chinner 405730f712c9SDave Chinner /* Else go on to the next record. */ 4058334f3423SChristoph Hellwig if (!xfs_iext_get_extent(ifp, ++idx, &got)) 4059334f3423SChristoph Hellwig eof = true; 406030f712c9SDave Chinner } 406130f712c9SDave Chinner *nmap = n; 406230f712c9SDave Chinner return 0; 406330f712c9SDave Chinner } 406430f712c9SDave Chinner 4065f65e6fadSBrian Foster /* 4066f65e6fadSBrian Foster * Add a delayed allocation extent to an inode. Blocks are reserved from the 4067f65e6fadSBrian Foster * global pool and the extent inserted into the inode in-core extent tree. 4068f65e6fadSBrian Foster * 4069f65e6fadSBrian Foster * On entry, got refers to the first extent beyond the offset of the extent to 4070f65e6fadSBrian Foster * allocate or eof is specified if no such extent exists. On return, got refers 4071f65e6fadSBrian Foster * to the extent record that was inserted to the inode fork. 4072f65e6fadSBrian Foster * 4073f65e6fadSBrian Foster * Note that the allocated extent may have been merged with contiguous extents 4074f65e6fadSBrian Foster * during insertion into the inode fork. Thus, got does not reflect the current 4075f65e6fadSBrian Foster * state of the inode fork on return. If necessary, the caller can use lastx to 4076f65e6fadSBrian Foster * look up the updated record in the inode fork. 4077f65e6fadSBrian Foster */ 407851446f5bSChristoph Hellwig int 407930f712c9SDave Chinner xfs_bmapi_reserve_delalloc( 408030f712c9SDave Chinner struct xfs_inode *ip, 4081be51f811SDarrick J. Wong int whichfork, 4082974ae922SBrian Foster xfs_fileoff_t off, 408330f712c9SDave Chinner xfs_filblks_t len, 4084974ae922SBrian Foster xfs_filblks_t prealloc, 408530f712c9SDave Chinner struct xfs_bmbt_irec *got, 408630f712c9SDave Chinner xfs_extnum_t *lastx, 408730f712c9SDave Chinner int eof) 408830f712c9SDave Chinner { 408930f712c9SDave Chinner struct xfs_mount *mp = ip->i_mount; 4090be51f811SDarrick J. Wong struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, whichfork); 409130f712c9SDave Chinner xfs_extlen_t alen; 409230f712c9SDave Chinner xfs_extlen_t indlen; 409330f712c9SDave Chinner char rt = XFS_IS_REALTIME_INODE(ip); 409430f712c9SDave Chinner xfs_extlen_t extsz; 409530f712c9SDave Chinner int error; 4096974ae922SBrian Foster xfs_fileoff_t aoff = off; 409730f712c9SDave Chinner 4098974ae922SBrian Foster /* 4099974ae922SBrian Foster * Cap the alloc length. Keep track of prealloc so we know whether to 4100974ae922SBrian Foster * tag the inode before we return. 4101974ae922SBrian Foster */ 4102974ae922SBrian Foster alen = XFS_FILBLKS_MIN(len + prealloc, MAXEXTLEN); 410330f712c9SDave Chinner if (!eof) 410430f712c9SDave Chinner alen = XFS_FILBLKS_MIN(alen, got->br_startoff - aoff); 4105974ae922SBrian Foster if (prealloc && alen >= len) 4106974ae922SBrian Foster prealloc = alen - len; 410730f712c9SDave Chinner 410830f712c9SDave Chinner /* Figure out the extent size, adjust alen */ 4109f7ca3522SDarrick J. Wong if (whichfork == XFS_COW_FORK) 4110f7ca3522SDarrick J. Wong extsz = xfs_get_cowextsz_hint(ip); 4111f7ca3522SDarrick J. Wong else 411230f712c9SDave Chinner extsz = xfs_get_extsz_hint(ip); 411330f712c9SDave Chinner if (extsz) { 411465c5f419SChristoph Hellwig struct xfs_bmbt_irec prev; 411565c5f419SChristoph Hellwig 411665c5f419SChristoph Hellwig if (!xfs_iext_get_extent(ifp, *lastx - 1, &prev)) 411765c5f419SChristoph Hellwig prev.br_startoff = NULLFILEOFF; 411865c5f419SChristoph Hellwig 411965c5f419SChristoph Hellwig error = xfs_bmap_extsize_align(mp, got, &prev, extsz, rt, eof, 412030f712c9SDave Chinner 1, 0, &aoff, &alen); 412130f712c9SDave Chinner ASSERT(!error); 412230f712c9SDave Chinner } 412330f712c9SDave Chinner 412430f712c9SDave Chinner if (rt) 412530f712c9SDave Chinner extsz = alen / mp->m_sb.sb_rextsize; 412630f712c9SDave Chinner 412730f712c9SDave Chinner /* 412830f712c9SDave Chinner * Make a transaction-less quota reservation for delayed allocation 412930f712c9SDave Chinner * blocks. This number gets adjusted later. We return if we haven't 413030f712c9SDave Chinner * allocated blocks already inside this loop. 413130f712c9SDave Chinner */ 413230f712c9SDave Chinner error = xfs_trans_reserve_quota_nblks(NULL, ip, (long)alen, 0, 413330f712c9SDave Chinner rt ? XFS_QMOPT_RES_RTBLKS : XFS_QMOPT_RES_REGBLKS); 413430f712c9SDave Chinner if (error) 413530f712c9SDave Chinner return error; 413630f712c9SDave Chinner 413730f712c9SDave Chinner /* 413830f712c9SDave Chinner * Split changing sb for alen and indlen since they could be coming 413930f712c9SDave Chinner * from different places. 414030f712c9SDave Chinner */ 414130f712c9SDave Chinner indlen = (xfs_extlen_t)xfs_bmap_worst_indlen(ip, alen); 414230f712c9SDave Chinner ASSERT(indlen > 0); 414330f712c9SDave Chinner 414430f712c9SDave Chinner if (rt) { 4145bab98bbeSDave Chinner error = xfs_mod_frextents(mp, -((int64_t)extsz)); 414630f712c9SDave Chinner } else { 41470d485adaSDave Chinner error = xfs_mod_fdblocks(mp, -((int64_t)alen), false); 414830f712c9SDave Chinner } 414930f712c9SDave Chinner 415030f712c9SDave Chinner if (error) 415130f712c9SDave Chinner goto out_unreserve_quota; 415230f712c9SDave Chinner 41530d485adaSDave Chinner error = xfs_mod_fdblocks(mp, -((int64_t)indlen), false); 415430f712c9SDave Chinner if (error) 415530f712c9SDave Chinner goto out_unreserve_blocks; 415630f712c9SDave Chinner 415730f712c9SDave Chinner 415830f712c9SDave Chinner ip->i_delayed_blks += alen; 415930f712c9SDave Chinner 416030f712c9SDave Chinner got->br_startoff = aoff; 416130f712c9SDave Chinner got->br_startblock = nullstartblock(indlen); 416230f712c9SDave Chinner got->br_blockcount = alen; 416330f712c9SDave Chinner got->br_state = XFS_EXT_NORM; 416430f712c9SDave Chinner 4165f65e6fadSBrian Foster xfs_bmap_add_extent_hole_delay(ip, whichfork, lastx, got); 416630f712c9SDave Chinner 4167974ae922SBrian Foster /* 4168974ae922SBrian Foster * Tag the inode if blocks were preallocated. Note that COW fork 4169974ae922SBrian Foster * preallocation can occur at the start or end of the extent, even when 4170974ae922SBrian Foster * prealloc == 0, so we must also check the aligned offset and length. 4171974ae922SBrian Foster */ 4172974ae922SBrian Foster if (whichfork == XFS_DATA_FORK && prealloc) 4173974ae922SBrian Foster xfs_inode_set_eofblocks_tag(ip); 4174974ae922SBrian Foster if (whichfork == XFS_COW_FORK && (prealloc || aoff < off || alen > len)) 4175974ae922SBrian Foster xfs_inode_set_cowblocks_tag(ip); 4176974ae922SBrian Foster 417730f712c9SDave Chinner return 0; 417830f712c9SDave Chinner 417930f712c9SDave Chinner out_unreserve_blocks: 418030f712c9SDave Chinner if (rt) 4181bab98bbeSDave Chinner xfs_mod_frextents(mp, extsz); 418230f712c9SDave Chinner else 41830d485adaSDave Chinner xfs_mod_fdblocks(mp, alen, false); 418430f712c9SDave Chinner out_unreserve_quota: 418530f712c9SDave Chinner if (XFS_IS_QUOTA_ON(mp)) 418630f712c9SDave Chinner xfs_trans_unreserve_quota_nblks(NULL, ip, (long)alen, 0, rt ? 418730f712c9SDave Chinner XFS_QMOPT_RES_RTBLKS : XFS_QMOPT_RES_REGBLKS); 418830f712c9SDave Chinner return error; 418930f712c9SDave Chinner } 419030f712c9SDave Chinner 41917f8a058fSDave Chinner static int 41927f8a058fSDave Chinner xfs_bmapi_allocate( 419330f712c9SDave Chinner struct xfs_bmalloca *bma) 419430f712c9SDave Chinner { 419530f712c9SDave Chinner struct xfs_mount *mp = bma->ip->i_mount; 419660b4984fSDarrick J. Wong int whichfork = xfs_bmapi_whichfork(bma->flags); 419730f712c9SDave Chinner struct xfs_ifork *ifp = XFS_IFORK_PTR(bma->ip, whichfork); 419830f712c9SDave Chinner int tmp_logflags = 0; 419930f712c9SDave Chinner int error; 420030f712c9SDave Chinner 420130f712c9SDave Chinner ASSERT(bma->length > 0); 420230f712c9SDave Chinner 420330f712c9SDave Chinner /* 420430f712c9SDave Chinner * For the wasdelay case, we could also just allocate the stuff asked 420530f712c9SDave Chinner * for in this bmap call but that wouldn't be as good. 420630f712c9SDave Chinner */ 420730f712c9SDave Chinner if (bma->wasdel) { 420830f712c9SDave Chinner bma->length = (xfs_extlen_t)bma->got.br_blockcount; 420930f712c9SDave Chinner bma->offset = bma->got.br_startoff; 42100e8d630bSChristoph Hellwig if (bma->idx) { 421130f712c9SDave Chinner xfs_bmbt_get_all(xfs_iext_get_ext(ifp, bma->idx - 1), 421230f712c9SDave Chinner &bma->prev); 421330f712c9SDave Chinner } 421430f712c9SDave Chinner } else { 421530f712c9SDave Chinner bma->length = XFS_FILBLKS_MIN(bma->length, MAXEXTLEN); 421630f712c9SDave Chinner if (!bma->eof) 421730f712c9SDave Chinner bma->length = XFS_FILBLKS_MIN(bma->length, 421830f712c9SDave Chinner bma->got.br_startoff - bma->offset); 421930f712c9SDave Chinner } 422030f712c9SDave Chinner 422130f712c9SDave Chinner /* 4222292378edSDave Chinner * Set the data type being allocated. For the data fork, the first data 4223292378edSDave Chinner * in the file is treated differently to all other allocations. For the 4224292378edSDave Chinner * attribute fork, we only need to ensure the allocated range is not on 4225292378edSDave Chinner * the busy list. 422630f712c9SDave Chinner */ 422730f712c9SDave Chinner if (!(bma->flags & XFS_BMAPI_METADATA)) { 4228292378edSDave Chinner bma->datatype = XFS_ALLOC_NOBUSY; 4229292378edSDave Chinner if (whichfork == XFS_DATA_FORK) { 4230292378edSDave Chinner if (bma->offset == 0) 4231292378edSDave Chinner bma->datatype |= XFS_ALLOC_INITIAL_USER_DATA; 4232292378edSDave Chinner else 4233292378edSDave Chinner bma->datatype |= XFS_ALLOC_USERDATA; 4234292378edSDave Chinner } 42353fbbbea3SDave Chinner if (bma->flags & XFS_BMAPI_ZERO) 4236292378edSDave Chinner bma->datatype |= XFS_ALLOC_USERDATA_ZERO; 423730f712c9SDave Chinner } 423830f712c9SDave Chinner 423930f712c9SDave Chinner bma->minlen = (bma->flags & XFS_BMAPI_CONTIG) ? bma->length : 1; 424030f712c9SDave Chinner 424130f712c9SDave Chinner /* 424230f712c9SDave Chinner * Only want to do the alignment at the eof if it is userdata and 424330f712c9SDave Chinner * allocation length is larger than a stripe unit. 424430f712c9SDave Chinner */ 424530f712c9SDave Chinner if (mp->m_dalign && bma->length >= mp->m_dalign && 424630f712c9SDave Chinner !(bma->flags & XFS_BMAPI_METADATA) && whichfork == XFS_DATA_FORK) { 424730f712c9SDave Chinner error = xfs_bmap_isaeof(bma, whichfork); 424830f712c9SDave Chinner if (error) 424930f712c9SDave Chinner return error; 425030f712c9SDave Chinner } 425130f712c9SDave Chinner 425230f712c9SDave Chinner error = xfs_bmap_alloc(bma); 425330f712c9SDave Chinner if (error) 425430f712c9SDave Chinner return error; 425530f712c9SDave Chinner 425630f712c9SDave Chinner if (bma->cur) 425730f712c9SDave Chinner bma->cur->bc_private.b.firstblock = *bma->firstblock; 425830f712c9SDave Chinner if (bma->blkno == NULLFSBLOCK) 425930f712c9SDave Chinner return 0; 426030f712c9SDave Chinner if ((ifp->if_flags & XFS_IFBROOT) && !bma->cur) { 426130f712c9SDave Chinner bma->cur = xfs_bmbt_init_cursor(mp, bma->tp, bma->ip, whichfork); 426230f712c9SDave Chinner bma->cur->bc_private.b.firstblock = *bma->firstblock; 42632c3234d1SDarrick J. Wong bma->cur->bc_private.b.dfops = bma->dfops; 426430f712c9SDave Chinner } 426530f712c9SDave Chinner /* 426630f712c9SDave Chinner * Bump the number of extents we've allocated 426730f712c9SDave Chinner * in this call. 426830f712c9SDave Chinner */ 426930f712c9SDave Chinner bma->nallocs++; 427030f712c9SDave Chinner 427130f712c9SDave Chinner if (bma->cur) 427230f712c9SDave Chinner bma->cur->bc_private.b.flags = 427330f712c9SDave Chinner bma->wasdel ? XFS_BTCUR_BPRV_WASDEL : 0; 427430f712c9SDave Chinner 427530f712c9SDave Chinner bma->got.br_startoff = bma->offset; 427630f712c9SDave Chinner bma->got.br_startblock = bma->blkno; 427730f712c9SDave Chinner bma->got.br_blockcount = bma->length; 427830f712c9SDave Chinner bma->got.br_state = XFS_EXT_NORM; 427930f712c9SDave Chinner 428030f712c9SDave Chinner /* 428105a630d7SDarrick J. Wong * In the data fork, a wasdelay extent has been initialized, so 428205a630d7SDarrick J. Wong * shouldn't be flagged as unwritten. 428305a630d7SDarrick J. Wong * 428405a630d7SDarrick J. Wong * For the cow fork, however, we convert delalloc reservations 428505a630d7SDarrick J. Wong * (extents allocated for speculative preallocation) to 428605a630d7SDarrick J. Wong * allocated unwritten extents, and only convert the unwritten 428705a630d7SDarrick J. Wong * extents to real extents when we're about to write the data. 428830f712c9SDave Chinner */ 428905a630d7SDarrick J. Wong if ((!bma->wasdel || (bma->flags & XFS_BMAPI_COWFORK)) && 429005a630d7SDarrick J. Wong (bma->flags & XFS_BMAPI_PREALLOC) && 429130f712c9SDave Chinner xfs_sb_version_hasextflgbit(&mp->m_sb)) 429230f712c9SDave Chinner bma->got.br_state = XFS_EXT_UNWRITTEN; 429330f712c9SDave Chinner 429430f712c9SDave Chinner if (bma->wasdel) 429560b4984fSDarrick J. Wong error = xfs_bmap_add_extent_delay_real(bma, whichfork); 429630f712c9SDave Chinner else 42976d04558fSChristoph Hellwig error = xfs_bmap_add_extent_hole_real(bma->tp, bma->ip, 42986d04558fSChristoph Hellwig whichfork, &bma->idx, &bma->cur, &bma->got, 42996d04558fSChristoph Hellwig bma->firstblock, bma->dfops, &bma->logflags); 430030f712c9SDave Chinner 430130f712c9SDave Chinner bma->logflags |= tmp_logflags; 430230f712c9SDave Chinner if (error) 430330f712c9SDave Chinner return error; 430430f712c9SDave Chinner 430530f712c9SDave Chinner /* 430630f712c9SDave Chinner * Update our extent pointer, given that xfs_bmap_add_extent_delay_real 430730f712c9SDave Chinner * or xfs_bmap_add_extent_hole_real might have merged it into one of 430830f712c9SDave Chinner * the neighbouring ones. 430930f712c9SDave Chinner */ 431030f712c9SDave Chinner xfs_bmbt_get_all(xfs_iext_get_ext(ifp, bma->idx), &bma->got); 431130f712c9SDave Chinner 431230f712c9SDave Chinner ASSERT(bma->got.br_startoff <= bma->offset); 431330f712c9SDave Chinner ASSERT(bma->got.br_startoff + bma->got.br_blockcount >= 431430f712c9SDave Chinner bma->offset + bma->length); 431530f712c9SDave Chinner ASSERT(bma->got.br_state == XFS_EXT_NORM || 431630f712c9SDave Chinner bma->got.br_state == XFS_EXT_UNWRITTEN); 431730f712c9SDave Chinner return 0; 431830f712c9SDave Chinner } 431930f712c9SDave Chinner 432030f712c9SDave Chinner STATIC int 432130f712c9SDave Chinner xfs_bmapi_convert_unwritten( 432230f712c9SDave Chinner struct xfs_bmalloca *bma, 432330f712c9SDave Chinner struct xfs_bmbt_irec *mval, 432430f712c9SDave Chinner xfs_filblks_t len, 432530f712c9SDave Chinner int flags) 432630f712c9SDave Chinner { 43273993baebSDarrick J. Wong int whichfork = xfs_bmapi_whichfork(flags); 432830f712c9SDave Chinner struct xfs_ifork *ifp = XFS_IFORK_PTR(bma->ip, whichfork); 432930f712c9SDave Chinner int tmp_logflags = 0; 433030f712c9SDave Chinner int error; 433130f712c9SDave Chinner 433230f712c9SDave Chinner /* check if we need to do unwritten->real conversion */ 433330f712c9SDave Chinner if (mval->br_state == XFS_EXT_UNWRITTEN && 433430f712c9SDave Chinner (flags & XFS_BMAPI_PREALLOC)) 433530f712c9SDave Chinner return 0; 433630f712c9SDave Chinner 433730f712c9SDave Chinner /* check if we need to do real->unwritten conversion */ 433830f712c9SDave Chinner if (mval->br_state == XFS_EXT_NORM && 433930f712c9SDave Chinner (flags & (XFS_BMAPI_PREALLOC | XFS_BMAPI_CONVERT)) != 434030f712c9SDave Chinner (XFS_BMAPI_PREALLOC | XFS_BMAPI_CONVERT)) 434130f712c9SDave Chinner return 0; 434230f712c9SDave Chinner 434330f712c9SDave Chinner /* 434430f712c9SDave Chinner * Modify (by adding) the state flag, if writing. 434530f712c9SDave Chinner */ 434630f712c9SDave Chinner ASSERT(mval->br_blockcount <= len); 434730f712c9SDave Chinner if ((ifp->if_flags & XFS_IFBROOT) && !bma->cur) { 434830f712c9SDave Chinner bma->cur = xfs_bmbt_init_cursor(bma->ip->i_mount, bma->tp, 434930f712c9SDave Chinner bma->ip, whichfork); 435030f712c9SDave Chinner bma->cur->bc_private.b.firstblock = *bma->firstblock; 43512c3234d1SDarrick J. Wong bma->cur->bc_private.b.dfops = bma->dfops; 435230f712c9SDave Chinner } 435330f712c9SDave Chinner mval->br_state = (mval->br_state == XFS_EXT_UNWRITTEN) 435430f712c9SDave Chinner ? XFS_EXT_NORM : XFS_EXT_UNWRITTEN; 435530f712c9SDave Chinner 43563fbbbea3SDave Chinner /* 43573fbbbea3SDave Chinner * Before insertion into the bmbt, zero the range being converted 43583fbbbea3SDave Chinner * if required. 43593fbbbea3SDave Chinner */ 43603fbbbea3SDave Chinner if (flags & XFS_BMAPI_ZERO) { 43613fbbbea3SDave Chinner error = xfs_zero_extent(bma->ip, mval->br_startblock, 43623fbbbea3SDave Chinner mval->br_blockcount); 43633fbbbea3SDave Chinner if (error) 43643fbbbea3SDave Chinner return error; 43653fbbbea3SDave Chinner } 43663fbbbea3SDave Chinner 436705a630d7SDarrick J. Wong error = xfs_bmap_add_extent_unwritten_real(bma->tp, bma->ip, whichfork, 436805a630d7SDarrick J. Wong &bma->idx, &bma->cur, mval, bma->firstblock, bma->dfops, 436930f712c9SDave Chinner &tmp_logflags); 43702e588a46SBrian Foster /* 43712e588a46SBrian Foster * Log the inode core unconditionally in the unwritten extent conversion 43722e588a46SBrian Foster * path because the conversion might not have done so (e.g., if the 43732e588a46SBrian Foster * extent count hasn't changed). We need to make sure the inode is dirty 43742e588a46SBrian Foster * in the transaction for the sake of fsync(), even if nothing has 43752e588a46SBrian Foster * changed, because fsync() will not force the log for this transaction 43762e588a46SBrian Foster * unless it sees the inode pinned. 437705a630d7SDarrick J. Wong * 437805a630d7SDarrick J. Wong * Note: If we're only converting cow fork extents, there aren't 437905a630d7SDarrick J. Wong * any on-disk updates to make, so we don't need to log anything. 43802e588a46SBrian Foster */ 438105a630d7SDarrick J. Wong if (whichfork != XFS_COW_FORK) 43822e588a46SBrian Foster bma->logflags |= tmp_logflags | XFS_ILOG_CORE; 438330f712c9SDave Chinner if (error) 438430f712c9SDave Chinner return error; 438530f712c9SDave Chinner 438630f712c9SDave Chinner /* 438730f712c9SDave Chinner * Update our extent pointer, given that 438830f712c9SDave Chinner * xfs_bmap_add_extent_unwritten_real might have merged it into one 438930f712c9SDave Chinner * of the neighbouring ones. 439030f712c9SDave Chinner */ 439130f712c9SDave Chinner xfs_bmbt_get_all(xfs_iext_get_ext(ifp, bma->idx), &bma->got); 439230f712c9SDave Chinner 439330f712c9SDave Chinner /* 439430f712c9SDave Chinner * We may have combined previously unwritten space with written space, 439530f712c9SDave Chinner * so generate another request. 439630f712c9SDave Chinner */ 439730f712c9SDave Chinner if (mval->br_blockcount < len) 43982451337dSDave Chinner return -EAGAIN; 439930f712c9SDave Chinner return 0; 440030f712c9SDave Chinner } 440130f712c9SDave Chinner 440230f712c9SDave Chinner /* 440330f712c9SDave Chinner * Map file blocks to filesystem blocks, and allocate blocks or convert the 440430f712c9SDave Chinner * extent state if necessary. Details behaviour is controlled by the flags 440530f712c9SDave Chinner * parameter. Only allocates blocks from a single allocation group, to avoid 440630f712c9SDave Chinner * locking problems. 440730f712c9SDave Chinner * 440830f712c9SDave Chinner * The returned value in "firstblock" from the first call in a transaction 440930f712c9SDave Chinner * must be remembered and presented to subsequent calls in "firstblock". 441030f712c9SDave Chinner * An upper bound for the number of blocks to be allocated is supplied to 441130f712c9SDave Chinner * the first call in "total"; if no allocation group has that many free 441230f712c9SDave Chinner * blocks then the call will fail (return NULLFSBLOCK in "firstblock"). 441330f712c9SDave Chinner */ 441430f712c9SDave Chinner int 441530f712c9SDave Chinner xfs_bmapi_write( 441630f712c9SDave Chinner struct xfs_trans *tp, /* transaction pointer */ 441730f712c9SDave Chinner struct xfs_inode *ip, /* incore inode */ 441830f712c9SDave Chinner xfs_fileoff_t bno, /* starting file offs. mapped */ 441930f712c9SDave Chinner xfs_filblks_t len, /* length to map in file */ 442030f712c9SDave Chinner int flags, /* XFS_BMAPI_... */ 442130f712c9SDave Chinner xfs_fsblock_t *firstblock, /* first allocated block 442230f712c9SDave Chinner controls a.g. for allocs */ 442330f712c9SDave Chinner xfs_extlen_t total, /* total blocks needed */ 442430f712c9SDave Chinner struct xfs_bmbt_irec *mval, /* output: map values */ 442530f712c9SDave Chinner int *nmap, /* i/o: mval size/count */ 44262c3234d1SDarrick J. Wong struct xfs_defer_ops *dfops) /* i/o: list extents to free */ 442730f712c9SDave Chinner { 442830f712c9SDave Chinner struct xfs_mount *mp = ip->i_mount; 442930f712c9SDave Chinner struct xfs_ifork *ifp; 443030f712c9SDave Chinner struct xfs_bmalloca bma = { NULL }; /* args for xfs_bmap_alloc */ 443130f712c9SDave Chinner xfs_fileoff_t end; /* end of mapped file region */ 44322d58f6efSChristoph Hellwig bool eof = false; /* after the end of extents */ 443330f712c9SDave Chinner int error; /* error return */ 443430f712c9SDave Chinner int n; /* current extent index */ 443530f712c9SDave Chinner xfs_fileoff_t obno; /* old block number (offset) */ 443630f712c9SDave Chinner int whichfork; /* data or attr fork */ 443730f712c9SDave Chinner 443830f712c9SDave Chinner #ifdef DEBUG 443930f712c9SDave Chinner xfs_fileoff_t orig_bno; /* original block number value */ 444030f712c9SDave Chinner int orig_flags; /* original flags arg value */ 444130f712c9SDave Chinner xfs_filblks_t orig_len; /* original value of len arg */ 444230f712c9SDave Chinner struct xfs_bmbt_irec *orig_mval; /* original value of mval */ 444330f712c9SDave Chinner int orig_nmap; /* original value of *nmap */ 444430f712c9SDave Chinner 444530f712c9SDave Chinner orig_bno = bno; 444630f712c9SDave Chinner orig_len = len; 444730f712c9SDave Chinner orig_flags = flags; 444830f712c9SDave Chinner orig_mval = mval; 444930f712c9SDave Chinner orig_nmap = *nmap; 445030f712c9SDave Chinner #endif 445160b4984fSDarrick J. Wong whichfork = xfs_bmapi_whichfork(flags); 445230f712c9SDave Chinner 445330f712c9SDave Chinner ASSERT(*nmap >= 1); 445430f712c9SDave Chinner ASSERT(*nmap <= XFS_BMAP_MAX_NMAP); 445530f712c9SDave Chinner ASSERT(!(flags & XFS_BMAPI_IGSTATE)); 445605a630d7SDarrick J. Wong ASSERT(tp != NULL || 445705a630d7SDarrick J. Wong (flags & (XFS_BMAPI_CONVERT | XFS_BMAPI_COWFORK)) == 445805a630d7SDarrick J. Wong (XFS_BMAPI_CONVERT | XFS_BMAPI_COWFORK)); 445930f712c9SDave Chinner ASSERT(len > 0); 446030f712c9SDave Chinner ASSERT(XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_LOCAL); 446130f712c9SDave Chinner ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL)); 44626ebd5a44SChristoph Hellwig ASSERT(!(flags & XFS_BMAPI_REMAP)); 446330f712c9SDave Chinner 44643fbbbea3SDave Chinner /* zeroing is for currently only for data extents, not metadata */ 44653fbbbea3SDave Chinner ASSERT((flags & (XFS_BMAPI_METADATA | XFS_BMAPI_ZERO)) != 44663fbbbea3SDave Chinner (XFS_BMAPI_METADATA | XFS_BMAPI_ZERO)); 44673fbbbea3SDave Chinner /* 44683fbbbea3SDave Chinner * we can allocate unwritten extents or pre-zero allocated blocks, 44693fbbbea3SDave Chinner * but it makes no sense to do both at once. This would result in 44703fbbbea3SDave Chinner * zeroing the unwritten extent twice, but it still being an 44713fbbbea3SDave Chinner * unwritten extent.... 44723fbbbea3SDave Chinner */ 44733fbbbea3SDave Chinner ASSERT((flags & (XFS_BMAPI_PREALLOC | XFS_BMAPI_ZERO)) != 44743fbbbea3SDave Chinner (XFS_BMAPI_PREALLOC | XFS_BMAPI_ZERO)); 44753fbbbea3SDave Chinner 447630f712c9SDave Chinner if (unlikely(XFS_TEST_ERROR( 447730f712c9SDave Chinner (XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS && 447830f712c9SDave Chinner XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE), 44799e24cfd0SDarrick J. Wong mp, XFS_ERRTAG_BMAPIFORMAT))) { 448030f712c9SDave Chinner XFS_ERROR_REPORT("xfs_bmapi_write", XFS_ERRLEVEL_LOW, mp); 44812451337dSDave Chinner return -EFSCORRUPTED; 448230f712c9SDave Chinner } 448330f712c9SDave Chinner 448430f712c9SDave Chinner if (XFS_FORCED_SHUTDOWN(mp)) 44852451337dSDave Chinner return -EIO; 448630f712c9SDave Chinner 448730f712c9SDave Chinner ifp = XFS_IFORK_PTR(ip, whichfork); 448830f712c9SDave Chinner 4489ff6d6af2SBill O'Donnell XFS_STATS_INC(mp, xs_blk_mapw); 449030f712c9SDave Chinner 449130f712c9SDave Chinner if (*firstblock == NULLFSBLOCK) { 449230f712c9SDave Chinner if (XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_BTREE) 449330f712c9SDave Chinner bma.minleft = be16_to_cpu(ifp->if_broot->bb_level) + 1; 449430f712c9SDave Chinner else 449530f712c9SDave Chinner bma.minleft = 1; 449630f712c9SDave Chinner } else { 449730f712c9SDave Chinner bma.minleft = 0; 449830f712c9SDave Chinner } 449930f712c9SDave Chinner 450030f712c9SDave Chinner if (!(ifp->if_flags & XFS_IFEXTENTS)) { 450130f712c9SDave Chinner error = xfs_iread_extents(tp, ip, whichfork); 450230f712c9SDave Chinner if (error) 450330f712c9SDave Chinner goto error0; 450430f712c9SDave Chinner } 450530f712c9SDave Chinner 450630f712c9SDave Chinner n = 0; 450730f712c9SDave Chinner end = bno + len; 450830f712c9SDave Chinner obno = bno; 450930f712c9SDave Chinner 45102d58f6efSChristoph Hellwig if (!xfs_iext_lookup_extent(ip, ifp, bno, &bma.idx, &bma.got)) 45112d58f6efSChristoph Hellwig eof = true; 45122d58f6efSChristoph Hellwig if (!xfs_iext_get_extent(ifp, bma.idx - 1, &bma.prev)) 45132d58f6efSChristoph Hellwig bma.prev.br_startoff = NULLFILEOFF; 451430f712c9SDave Chinner bma.tp = tp; 451530f712c9SDave Chinner bma.ip = ip; 451630f712c9SDave Chinner bma.total = total; 4517292378edSDave Chinner bma.datatype = 0; 45182c3234d1SDarrick J. Wong bma.dfops = dfops; 451930f712c9SDave Chinner bma.firstblock = firstblock; 452030f712c9SDave Chinner 452130f712c9SDave Chinner while (bno < end && n < *nmap) { 4522d2b3964aSChristoph Hellwig bool need_alloc = false, wasdelay = false; 452330f712c9SDave Chinner 4524d2b3964aSChristoph Hellwig /* in hole or beyoned EOF? */ 4525d2b3964aSChristoph Hellwig if (eof || bma.got.br_startoff > bno) { 4526d2b3964aSChristoph Hellwig if (flags & XFS_BMAPI_DELALLOC) { 4527d2b3964aSChristoph Hellwig /* 4528d2b3964aSChristoph Hellwig * For the COW fork we can reasonably get a 4529d2b3964aSChristoph Hellwig * request for converting an extent that races 4530d2b3964aSChristoph Hellwig * with other threads already having converted 4531d2b3964aSChristoph Hellwig * part of it, as there converting COW to 4532d2b3964aSChristoph Hellwig * regular blocks is not protected using the 4533d2b3964aSChristoph Hellwig * IOLOCK. 4534d2b3964aSChristoph Hellwig */ 4535d2b3964aSChristoph Hellwig ASSERT(flags & XFS_BMAPI_COWFORK); 4536d2b3964aSChristoph Hellwig if (!(flags & XFS_BMAPI_COWFORK)) { 4537d2b3964aSChristoph Hellwig error = -EIO; 4538d2b3964aSChristoph Hellwig goto error0; 4539d2b3964aSChristoph Hellwig } 4540d2b3964aSChristoph Hellwig 4541d2b3964aSChristoph Hellwig if (eof || bno >= end) 4542d2b3964aSChristoph Hellwig break; 4543d2b3964aSChristoph Hellwig } else { 4544d2b3964aSChristoph Hellwig need_alloc = true; 4545d2b3964aSChristoph Hellwig } 45466ebd5a44SChristoph Hellwig } else if (isnullstartblock(bma.got.br_startblock)) { 4547d2b3964aSChristoph Hellwig wasdelay = true; 4548d2b3964aSChristoph Hellwig } 4549f65306eaSDarrick J. Wong 4550f65306eaSDarrick J. Wong /* 455130f712c9SDave Chinner * First, deal with the hole before the allocated space 455230f712c9SDave Chinner * that we found, if any. 455330f712c9SDave Chinner */ 4554d2b3964aSChristoph Hellwig if (need_alloc || wasdelay) { 455530f712c9SDave Chinner bma.eof = eof; 455630f712c9SDave Chinner bma.conv = !!(flags & XFS_BMAPI_CONVERT); 455730f712c9SDave Chinner bma.wasdel = wasdelay; 455830f712c9SDave Chinner bma.offset = bno; 455930f712c9SDave Chinner bma.flags = flags; 456030f712c9SDave Chinner 456130f712c9SDave Chinner /* 456230f712c9SDave Chinner * There's a 32/64 bit type mismatch between the 456330f712c9SDave Chinner * allocation length request (which can be 64 bits in 456430f712c9SDave Chinner * length) and the bma length request, which is 456530f712c9SDave Chinner * xfs_extlen_t and therefore 32 bits. Hence we have to 456630f712c9SDave Chinner * check for 32-bit overflows and handle them here. 456730f712c9SDave Chinner */ 456830f712c9SDave Chinner if (len > (xfs_filblks_t)MAXEXTLEN) 456930f712c9SDave Chinner bma.length = MAXEXTLEN; 457030f712c9SDave Chinner else 457130f712c9SDave Chinner bma.length = len; 457230f712c9SDave Chinner 457330f712c9SDave Chinner ASSERT(len > 0); 457430f712c9SDave Chinner ASSERT(bma.length > 0); 457530f712c9SDave Chinner error = xfs_bmapi_allocate(&bma); 457630f712c9SDave Chinner if (error) 457730f712c9SDave Chinner goto error0; 457830f712c9SDave Chinner if (bma.blkno == NULLFSBLOCK) 457930f712c9SDave Chinner break; 4580174edb0eSDarrick J. Wong 4581174edb0eSDarrick J. Wong /* 4582174edb0eSDarrick J. Wong * If this is a CoW allocation, record the data in 4583174edb0eSDarrick J. Wong * the refcount btree for orphan recovery. 4584174edb0eSDarrick J. Wong */ 4585174edb0eSDarrick J. Wong if (whichfork == XFS_COW_FORK) { 4586174edb0eSDarrick J. Wong error = xfs_refcount_alloc_cow_extent(mp, dfops, 4587174edb0eSDarrick J. Wong bma.blkno, bma.length); 4588174edb0eSDarrick J. Wong if (error) 4589174edb0eSDarrick J. Wong goto error0; 4590174edb0eSDarrick J. Wong } 459130f712c9SDave Chinner } 459230f712c9SDave Chinner 459330f712c9SDave Chinner /* Deal with the allocated space we found. */ 459430f712c9SDave Chinner xfs_bmapi_trim_map(mval, &bma.got, &bno, len, obno, 459530f712c9SDave Chinner end, n, flags); 459630f712c9SDave Chinner 459730f712c9SDave Chinner /* Execute unwritten extent conversion if necessary */ 459830f712c9SDave Chinner error = xfs_bmapi_convert_unwritten(&bma, mval, len, flags); 45992451337dSDave Chinner if (error == -EAGAIN) 460030f712c9SDave Chinner continue; 460130f712c9SDave Chinner if (error) 460230f712c9SDave Chinner goto error0; 460330f712c9SDave Chinner 460430f712c9SDave Chinner /* update the extent map to return */ 460530f712c9SDave Chinner xfs_bmapi_update_map(&mval, &bno, &len, obno, end, &n, flags); 460630f712c9SDave Chinner 460730f712c9SDave Chinner /* 460830f712c9SDave Chinner * If we're done, stop now. Stop when we've allocated 460930f712c9SDave Chinner * XFS_BMAP_MAX_NMAP extents no matter what. Otherwise 461030f712c9SDave Chinner * the transaction may get too big. 461130f712c9SDave Chinner */ 461230f712c9SDave Chinner if (bno >= end || n >= *nmap || bma.nallocs >= *nmap) 461330f712c9SDave Chinner break; 461430f712c9SDave Chinner 461530f712c9SDave Chinner /* Else go on to the next record. */ 461630f712c9SDave Chinner bma.prev = bma.got; 46172d58f6efSChristoph Hellwig if (!xfs_iext_get_extent(ifp, ++bma.idx, &bma.got)) 46182d58f6efSChristoph Hellwig eof = true; 461930f712c9SDave Chinner } 462030f712c9SDave Chinner *nmap = n; 462130f712c9SDave Chinner 462230f712c9SDave Chinner /* 462330f712c9SDave Chinner * Transform from btree to extents, give it cur. 462430f712c9SDave Chinner */ 462530f712c9SDave Chinner if (xfs_bmap_wants_extents(ip, whichfork)) { 462630f712c9SDave Chinner int tmp_logflags = 0; 462730f712c9SDave Chinner 462830f712c9SDave Chinner ASSERT(bma.cur); 462930f712c9SDave Chinner error = xfs_bmap_btree_to_extents(tp, ip, bma.cur, 463030f712c9SDave Chinner &tmp_logflags, whichfork); 463130f712c9SDave Chinner bma.logflags |= tmp_logflags; 463230f712c9SDave Chinner if (error) 463330f712c9SDave Chinner goto error0; 463430f712c9SDave Chinner } 463530f712c9SDave Chinner 463630f712c9SDave Chinner ASSERT(XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE || 463730f712c9SDave Chinner XFS_IFORK_NEXTENTS(ip, whichfork) > 463830f712c9SDave Chinner XFS_IFORK_MAXEXT(ip, whichfork)); 463930f712c9SDave Chinner error = 0; 464030f712c9SDave Chinner error0: 464130f712c9SDave Chinner /* 464230f712c9SDave Chinner * Log everything. Do this after conversion, there's no point in 464330f712c9SDave Chinner * logging the extent records if we've converted to btree format. 464430f712c9SDave Chinner */ 464530f712c9SDave Chinner if ((bma.logflags & xfs_ilog_fext(whichfork)) && 464630f712c9SDave Chinner XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS) 464730f712c9SDave Chinner bma.logflags &= ~xfs_ilog_fext(whichfork); 464830f712c9SDave Chinner else if ((bma.logflags & xfs_ilog_fbroot(whichfork)) && 464930f712c9SDave Chinner XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE) 465030f712c9SDave Chinner bma.logflags &= ~xfs_ilog_fbroot(whichfork); 465130f712c9SDave Chinner /* 465230f712c9SDave Chinner * Log whatever the flags say, even if error. Otherwise we might miss 465330f712c9SDave Chinner * detecting a case where the data is changed, there's an error, 465430f712c9SDave Chinner * and it's not logged so we don't shutdown when we should. 465530f712c9SDave Chinner */ 465630f712c9SDave Chinner if (bma.logflags) 465730f712c9SDave Chinner xfs_trans_log_inode(tp, ip, bma.logflags); 465830f712c9SDave Chinner 465930f712c9SDave Chinner if (bma.cur) { 466030f712c9SDave Chinner if (!error) { 466130f712c9SDave Chinner ASSERT(*firstblock == NULLFSBLOCK || 4662410d17f6SChristoph Hellwig XFS_FSB_TO_AGNO(mp, *firstblock) <= 466330f712c9SDave Chinner XFS_FSB_TO_AGNO(mp, 4664410d17f6SChristoph Hellwig bma.cur->bc_private.b.firstblock)); 466530f712c9SDave Chinner *firstblock = bma.cur->bc_private.b.firstblock; 466630f712c9SDave Chinner } 466730f712c9SDave Chinner xfs_btree_del_cursor(bma.cur, 466830f712c9SDave Chinner error ? XFS_BTREE_ERROR : XFS_BTREE_NOERROR); 466930f712c9SDave Chinner } 467030f712c9SDave Chinner if (!error) 467130f712c9SDave Chinner xfs_bmap_validate_ret(orig_bno, orig_len, orig_flags, orig_mval, 467230f712c9SDave Chinner orig_nmap, *nmap); 467330f712c9SDave Chinner return error; 467430f712c9SDave Chinner } 467530f712c9SDave Chinner 46766ebd5a44SChristoph Hellwig static int 46776ebd5a44SChristoph Hellwig xfs_bmapi_remap( 46786ebd5a44SChristoph Hellwig struct xfs_trans *tp, 46796ebd5a44SChristoph Hellwig struct xfs_inode *ip, 46806ebd5a44SChristoph Hellwig xfs_fileoff_t bno, 46816ebd5a44SChristoph Hellwig xfs_filblks_t len, 46826ebd5a44SChristoph Hellwig xfs_fsblock_t startblock, 46836ebd5a44SChristoph Hellwig struct xfs_defer_ops *dfops) 46846ebd5a44SChristoph Hellwig { 46856ebd5a44SChristoph Hellwig struct xfs_mount *mp = ip->i_mount; 46866ebd5a44SChristoph Hellwig struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, XFS_DATA_FORK); 46876ebd5a44SChristoph Hellwig struct xfs_btree_cur *cur = NULL; 46886ebd5a44SChristoph Hellwig xfs_fsblock_t firstblock = NULLFSBLOCK; 46896ebd5a44SChristoph Hellwig struct xfs_bmbt_irec got; 46906ebd5a44SChristoph Hellwig xfs_extnum_t idx; 46916ebd5a44SChristoph Hellwig int logflags = 0, error; 46926ebd5a44SChristoph Hellwig 46936ebd5a44SChristoph Hellwig ASSERT(len > 0); 46946ebd5a44SChristoph Hellwig ASSERT(len <= (xfs_filblks_t)MAXEXTLEN); 46956ebd5a44SChristoph Hellwig ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL)); 46966ebd5a44SChristoph Hellwig 46976ebd5a44SChristoph Hellwig if (unlikely(XFS_TEST_ERROR( 46986ebd5a44SChristoph Hellwig (XFS_IFORK_FORMAT(ip, XFS_DATA_FORK) != XFS_DINODE_FMT_EXTENTS && 46996ebd5a44SChristoph Hellwig XFS_IFORK_FORMAT(ip, XFS_DATA_FORK) != XFS_DINODE_FMT_BTREE), 47009e24cfd0SDarrick J. Wong mp, XFS_ERRTAG_BMAPIFORMAT))) { 47016ebd5a44SChristoph Hellwig XFS_ERROR_REPORT("xfs_bmapi_remap", XFS_ERRLEVEL_LOW, mp); 47026ebd5a44SChristoph Hellwig return -EFSCORRUPTED; 47036ebd5a44SChristoph Hellwig } 47046ebd5a44SChristoph Hellwig 47056ebd5a44SChristoph Hellwig if (XFS_FORCED_SHUTDOWN(mp)) 47066ebd5a44SChristoph Hellwig return -EIO; 47076ebd5a44SChristoph Hellwig 47086ebd5a44SChristoph Hellwig if (!(ifp->if_flags & XFS_IFEXTENTS)) { 47096ebd5a44SChristoph Hellwig error = xfs_iread_extents(NULL, ip, XFS_DATA_FORK); 47106ebd5a44SChristoph Hellwig if (error) 47116ebd5a44SChristoph Hellwig return error; 47126ebd5a44SChristoph Hellwig } 47136ebd5a44SChristoph Hellwig 47146ebd5a44SChristoph Hellwig if (xfs_iext_lookup_extent(ip, ifp, bno, &idx, &got)) { 47156ebd5a44SChristoph Hellwig /* make sure we only reflink into a hole. */ 47166ebd5a44SChristoph Hellwig ASSERT(got.br_startoff > bno); 47176ebd5a44SChristoph Hellwig ASSERT(got.br_startoff - bno >= len); 47186ebd5a44SChristoph Hellwig } 47196ebd5a44SChristoph Hellwig 4720bf8eadbaSChristoph Hellwig ip->i_d.di_nblocks += len; 4721bf8eadbaSChristoph Hellwig xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE); 47226ebd5a44SChristoph Hellwig 47236ebd5a44SChristoph Hellwig if (ifp->if_flags & XFS_IFBROOT) { 47246ebd5a44SChristoph Hellwig cur = xfs_bmbt_init_cursor(mp, tp, ip, XFS_DATA_FORK); 47256ebd5a44SChristoph Hellwig cur->bc_private.b.firstblock = firstblock; 47266ebd5a44SChristoph Hellwig cur->bc_private.b.dfops = dfops; 47276ebd5a44SChristoph Hellwig cur->bc_private.b.flags = 0; 47286ebd5a44SChristoph Hellwig } 47296ebd5a44SChristoph Hellwig 47306ebd5a44SChristoph Hellwig got.br_startoff = bno; 47316ebd5a44SChristoph Hellwig got.br_startblock = startblock; 47326ebd5a44SChristoph Hellwig got.br_blockcount = len; 47336ebd5a44SChristoph Hellwig got.br_state = XFS_EXT_NORM; 47346ebd5a44SChristoph Hellwig 47356ebd5a44SChristoph Hellwig error = xfs_bmap_add_extent_hole_real(tp, ip, XFS_DATA_FORK, &idx, &cur, 47366ebd5a44SChristoph Hellwig &got, &firstblock, dfops, &logflags); 47376ebd5a44SChristoph Hellwig if (error) 47386ebd5a44SChristoph Hellwig goto error0; 47396ebd5a44SChristoph Hellwig 47406ebd5a44SChristoph Hellwig if (xfs_bmap_wants_extents(ip, XFS_DATA_FORK)) { 47416ebd5a44SChristoph Hellwig int tmp_logflags = 0; 47426ebd5a44SChristoph Hellwig 47436ebd5a44SChristoph Hellwig error = xfs_bmap_btree_to_extents(tp, ip, cur, 47446ebd5a44SChristoph Hellwig &tmp_logflags, XFS_DATA_FORK); 47456ebd5a44SChristoph Hellwig logflags |= tmp_logflags; 47466ebd5a44SChristoph Hellwig } 47476ebd5a44SChristoph Hellwig 47486ebd5a44SChristoph Hellwig error0: 47496ebd5a44SChristoph Hellwig if (ip->i_d.di_format != XFS_DINODE_FMT_EXTENTS) 47506ebd5a44SChristoph Hellwig logflags &= ~XFS_ILOG_DEXT; 47516ebd5a44SChristoph Hellwig else if (ip->i_d.di_format != XFS_DINODE_FMT_BTREE) 47526ebd5a44SChristoph Hellwig logflags &= ~XFS_ILOG_DBROOT; 47536ebd5a44SChristoph Hellwig 47546ebd5a44SChristoph Hellwig if (logflags) 47556ebd5a44SChristoph Hellwig xfs_trans_log_inode(tp, ip, logflags); 47566ebd5a44SChristoph Hellwig if (cur) { 47576ebd5a44SChristoph Hellwig xfs_btree_del_cursor(cur, 47586ebd5a44SChristoph Hellwig error ? XFS_BTREE_ERROR : XFS_BTREE_NOERROR); 47596ebd5a44SChristoph Hellwig } 47606ebd5a44SChristoph Hellwig return error; 47616ebd5a44SChristoph Hellwig } 47626ebd5a44SChristoph Hellwig 476330f712c9SDave Chinner /* 4764a9bd24acSBrian Foster * When a delalloc extent is split (e.g., due to a hole punch), the original 4765a9bd24acSBrian Foster * indlen reservation must be shared across the two new extents that are left 4766a9bd24acSBrian Foster * behind. 4767a9bd24acSBrian Foster * 4768a9bd24acSBrian Foster * Given the original reservation and the worst case indlen for the two new 4769a9bd24acSBrian Foster * extents (as calculated by xfs_bmap_worst_indlen()), split the original 4770d34999c9SBrian Foster * reservation fairly across the two new extents. If necessary, steal available 4771d34999c9SBrian Foster * blocks from a deleted extent to make up a reservation deficiency (e.g., if 4772d34999c9SBrian Foster * ores == 1). The number of stolen blocks is returned. The availability and 4773d34999c9SBrian Foster * subsequent accounting of stolen blocks is the responsibility of the caller. 4774a9bd24acSBrian Foster */ 4775d34999c9SBrian Foster static xfs_filblks_t 4776a9bd24acSBrian Foster xfs_bmap_split_indlen( 4777a9bd24acSBrian Foster xfs_filblks_t ores, /* original res. */ 4778a9bd24acSBrian Foster xfs_filblks_t *indlen1, /* ext1 worst indlen */ 4779d34999c9SBrian Foster xfs_filblks_t *indlen2, /* ext2 worst indlen */ 4780d34999c9SBrian Foster xfs_filblks_t avail) /* stealable blocks */ 4781a9bd24acSBrian Foster { 4782a9bd24acSBrian Foster xfs_filblks_t len1 = *indlen1; 4783a9bd24acSBrian Foster xfs_filblks_t len2 = *indlen2; 4784a9bd24acSBrian Foster xfs_filblks_t nres = len1 + len2; /* new total res. */ 4785d34999c9SBrian Foster xfs_filblks_t stolen = 0; 478675d65361SBrian Foster xfs_filblks_t resfactor; 4787a9bd24acSBrian Foster 4788a9bd24acSBrian Foster /* 4789d34999c9SBrian Foster * Steal as many blocks as we can to try and satisfy the worst case 4790d34999c9SBrian Foster * indlen for both new extents. 4791d34999c9SBrian Foster */ 479275d65361SBrian Foster if (ores < nres && avail) 479375d65361SBrian Foster stolen = XFS_FILBLKS_MIN(nres - ores, avail); 479475d65361SBrian Foster ores += stolen; 479575d65361SBrian Foster 479675d65361SBrian Foster /* nothing else to do if we've satisfied the new reservation */ 479775d65361SBrian Foster if (ores >= nres) 479875d65361SBrian Foster return stolen; 4799d34999c9SBrian Foster 4800d34999c9SBrian Foster /* 480175d65361SBrian Foster * We can't meet the total required reservation for the two extents. 480275d65361SBrian Foster * Calculate the percent of the overall shortage between both extents 480375d65361SBrian Foster * and apply this percentage to each of the requested indlen values. 480475d65361SBrian Foster * This distributes the shortage fairly and reduces the chances that one 480575d65361SBrian Foster * of the two extents is left with nothing when extents are repeatedly 480675d65361SBrian Foster * split. 4807a9bd24acSBrian Foster */ 480875d65361SBrian Foster resfactor = (ores * 100); 480975d65361SBrian Foster do_div(resfactor, nres); 481075d65361SBrian Foster len1 *= resfactor; 481175d65361SBrian Foster do_div(len1, 100); 481275d65361SBrian Foster len2 *= resfactor; 481375d65361SBrian Foster do_div(len2, 100); 481475d65361SBrian Foster ASSERT(len1 + len2 <= ores); 481575d65361SBrian Foster ASSERT(len1 < *indlen1 && len2 < *indlen2); 481675d65361SBrian Foster 481775d65361SBrian Foster /* 481875d65361SBrian Foster * Hand out the remainder to each extent. If one of the two reservations 481975d65361SBrian Foster * is zero, we want to make sure that one gets a block first. The loop 482075d65361SBrian Foster * below starts with len1, so hand len2 a block right off the bat if it 482175d65361SBrian Foster * is zero. 482275d65361SBrian Foster */ 482375d65361SBrian Foster ores -= (len1 + len2); 482475d65361SBrian Foster ASSERT((*indlen1 - len1) + (*indlen2 - len2) >= ores); 482575d65361SBrian Foster if (ores && !len2 && *indlen2) { 482675d65361SBrian Foster len2++; 482775d65361SBrian Foster ores--; 4828a9bd24acSBrian Foster } 482975d65361SBrian Foster while (ores) { 483075d65361SBrian Foster if (len1 < *indlen1) { 483175d65361SBrian Foster len1++; 483275d65361SBrian Foster ores--; 483375d65361SBrian Foster } 483475d65361SBrian Foster if (!ores) 4835a9bd24acSBrian Foster break; 483675d65361SBrian Foster if (len2 < *indlen2) { 483775d65361SBrian Foster len2++; 483875d65361SBrian Foster ores--; 4839a9bd24acSBrian Foster } 4840a9bd24acSBrian Foster } 4841a9bd24acSBrian Foster 4842a9bd24acSBrian Foster *indlen1 = len1; 4843a9bd24acSBrian Foster *indlen2 = len2; 4844d34999c9SBrian Foster 4845d34999c9SBrian Foster return stolen; 4846a9bd24acSBrian Foster } 4847a9bd24acSBrian Foster 4848fa5c836cSChristoph Hellwig int 4849fa5c836cSChristoph Hellwig xfs_bmap_del_extent_delay( 4850fa5c836cSChristoph Hellwig struct xfs_inode *ip, 4851fa5c836cSChristoph Hellwig int whichfork, 4852fa5c836cSChristoph Hellwig xfs_extnum_t *idx, 4853fa5c836cSChristoph Hellwig struct xfs_bmbt_irec *got, 4854fa5c836cSChristoph Hellwig struct xfs_bmbt_irec *del) 4855fa5c836cSChristoph Hellwig { 4856fa5c836cSChristoph Hellwig struct xfs_mount *mp = ip->i_mount; 4857fa5c836cSChristoph Hellwig struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, whichfork); 4858fa5c836cSChristoph Hellwig struct xfs_bmbt_irec new; 4859fa5c836cSChristoph Hellwig int64_t da_old, da_new, da_diff = 0; 4860fa5c836cSChristoph Hellwig xfs_fileoff_t del_endoff, got_endoff; 4861fa5c836cSChristoph Hellwig xfs_filblks_t got_indlen, new_indlen, stolen; 4862fa5c836cSChristoph Hellwig int error = 0, state = 0; 4863fa5c836cSChristoph Hellwig bool isrt; 4864fa5c836cSChristoph Hellwig 4865fa5c836cSChristoph Hellwig XFS_STATS_INC(mp, xs_del_exlist); 4866fa5c836cSChristoph Hellwig 4867fa5c836cSChristoph Hellwig isrt = (whichfork == XFS_DATA_FORK) && XFS_IS_REALTIME_INODE(ip); 4868fa5c836cSChristoph Hellwig del_endoff = del->br_startoff + del->br_blockcount; 4869fa5c836cSChristoph Hellwig got_endoff = got->br_startoff + got->br_blockcount; 4870fa5c836cSChristoph Hellwig da_old = startblockval(got->br_startblock); 4871fa5c836cSChristoph Hellwig da_new = 0; 4872fa5c836cSChristoph Hellwig 4873fa5c836cSChristoph Hellwig ASSERT(*idx >= 0); 48745d829300SEric Sandeen ASSERT(*idx <= xfs_iext_count(ifp)); 4875fa5c836cSChristoph Hellwig ASSERT(del->br_blockcount > 0); 4876fa5c836cSChristoph Hellwig ASSERT(got->br_startoff <= del->br_startoff); 4877fa5c836cSChristoph Hellwig ASSERT(got_endoff >= del_endoff); 4878fa5c836cSChristoph Hellwig 4879fa5c836cSChristoph Hellwig if (isrt) { 48804f1adf33SEric Sandeen uint64_t rtexts = XFS_FSB_TO_B(mp, del->br_blockcount); 4881fa5c836cSChristoph Hellwig 4882fa5c836cSChristoph Hellwig do_div(rtexts, mp->m_sb.sb_rextsize); 4883fa5c836cSChristoph Hellwig xfs_mod_frextents(mp, rtexts); 4884fa5c836cSChristoph Hellwig } 4885fa5c836cSChristoph Hellwig 4886fa5c836cSChristoph Hellwig /* 4887fa5c836cSChristoph Hellwig * Update the inode delalloc counter now and wait to update the 4888fa5c836cSChristoph Hellwig * sb counters as we might have to borrow some blocks for the 4889fa5c836cSChristoph Hellwig * indirect block accounting. 4890fa5c836cSChristoph Hellwig */ 48914fd29ec4SDarrick J. Wong error = xfs_trans_reserve_quota_nblks(NULL, ip, 48924fd29ec4SDarrick J. Wong -((long)del->br_blockcount), 0, 4893fa5c836cSChristoph Hellwig isrt ? XFS_QMOPT_RES_RTBLKS : XFS_QMOPT_RES_REGBLKS); 48944fd29ec4SDarrick J. Wong if (error) 48954fd29ec4SDarrick J. Wong return error; 4896fa5c836cSChristoph Hellwig ip->i_delayed_blks -= del->br_blockcount; 4897fa5c836cSChristoph Hellwig 4898fa5c836cSChristoph Hellwig if (whichfork == XFS_COW_FORK) 4899fa5c836cSChristoph Hellwig state |= BMAP_COWFORK; 4900fa5c836cSChristoph Hellwig 4901fa5c836cSChristoph Hellwig if (got->br_startoff == del->br_startoff) 4902fa5c836cSChristoph Hellwig state |= BMAP_LEFT_CONTIG; 4903fa5c836cSChristoph Hellwig if (got_endoff == del_endoff) 4904fa5c836cSChristoph Hellwig state |= BMAP_RIGHT_CONTIG; 4905fa5c836cSChristoph Hellwig 4906fa5c836cSChristoph Hellwig switch (state & (BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG)) { 4907fa5c836cSChristoph Hellwig case BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG: 4908fa5c836cSChristoph Hellwig /* 4909fa5c836cSChristoph Hellwig * Matches the whole extent. Delete the entry. 4910fa5c836cSChristoph Hellwig */ 4911fa5c836cSChristoph Hellwig xfs_iext_remove(ip, *idx, 1, state); 4912fa5c836cSChristoph Hellwig --*idx; 4913fa5c836cSChristoph Hellwig break; 4914fa5c836cSChristoph Hellwig case BMAP_LEFT_CONTIG: 4915fa5c836cSChristoph Hellwig /* 4916fa5c836cSChristoph Hellwig * Deleting the first part of the extent. 4917fa5c836cSChristoph Hellwig */ 4918fa5c836cSChristoph Hellwig trace_xfs_bmap_pre_update(ip, *idx, state, _THIS_IP_); 4919fa5c836cSChristoph Hellwig got->br_startoff = del_endoff; 4920fa5c836cSChristoph Hellwig got->br_blockcount -= del->br_blockcount; 4921fa5c836cSChristoph Hellwig da_new = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(ip, 4922fa5c836cSChristoph Hellwig got->br_blockcount), da_old); 4923fa5c836cSChristoph Hellwig got->br_startblock = nullstartblock((int)da_new); 492467e4e69cSChristoph Hellwig xfs_iext_update_extent(ifp, *idx, got); 4925fa5c836cSChristoph Hellwig trace_xfs_bmap_post_update(ip, *idx, state, _THIS_IP_); 4926fa5c836cSChristoph Hellwig break; 4927fa5c836cSChristoph Hellwig case BMAP_RIGHT_CONTIG: 4928fa5c836cSChristoph Hellwig /* 4929fa5c836cSChristoph Hellwig * Deleting the last part of the extent. 4930fa5c836cSChristoph Hellwig */ 4931fa5c836cSChristoph Hellwig trace_xfs_bmap_pre_update(ip, *idx, state, _THIS_IP_); 4932fa5c836cSChristoph Hellwig got->br_blockcount = got->br_blockcount - del->br_blockcount; 4933fa5c836cSChristoph Hellwig da_new = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(ip, 4934fa5c836cSChristoph Hellwig got->br_blockcount), da_old); 4935fa5c836cSChristoph Hellwig got->br_startblock = nullstartblock((int)da_new); 493667e4e69cSChristoph Hellwig xfs_iext_update_extent(ifp, *idx, got); 4937fa5c836cSChristoph Hellwig trace_xfs_bmap_post_update(ip, *idx, state, _THIS_IP_); 4938fa5c836cSChristoph Hellwig break; 4939fa5c836cSChristoph Hellwig case 0: 4940fa5c836cSChristoph Hellwig /* 4941fa5c836cSChristoph Hellwig * Deleting the middle of the extent. 4942fa5c836cSChristoph Hellwig * 4943fa5c836cSChristoph Hellwig * Distribute the original indlen reservation across the two new 4944fa5c836cSChristoph Hellwig * extents. Steal blocks from the deleted extent if necessary. 4945fa5c836cSChristoph Hellwig * Stealing blocks simply fudges the fdblocks accounting below. 4946fa5c836cSChristoph Hellwig * Warn if either of the new indlen reservations is zero as this 4947fa5c836cSChristoph Hellwig * can lead to delalloc problems. 4948fa5c836cSChristoph Hellwig */ 4949fa5c836cSChristoph Hellwig trace_xfs_bmap_pre_update(ip, *idx, state, _THIS_IP_); 4950fa5c836cSChristoph Hellwig 4951fa5c836cSChristoph Hellwig got->br_blockcount = del->br_startoff - got->br_startoff; 4952fa5c836cSChristoph Hellwig got_indlen = xfs_bmap_worst_indlen(ip, got->br_blockcount); 4953fa5c836cSChristoph Hellwig 4954fa5c836cSChristoph Hellwig new.br_blockcount = got_endoff - del_endoff; 4955fa5c836cSChristoph Hellwig new_indlen = xfs_bmap_worst_indlen(ip, new.br_blockcount); 4956fa5c836cSChristoph Hellwig 4957fa5c836cSChristoph Hellwig WARN_ON_ONCE(!got_indlen || !new_indlen); 4958fa5c836cSChristoph Hellwig stolen = xfs_bmap_split_indlen(da_old, &got_indlen, &new_indlen, 4959fa5c836cSChristoph Hellwig del->br_blockcount); 4960fa5c836cSChristoph Hellwig 4961fa5c836cSChristoph Hellwig got->br_startblock = nullstartblock((int)got_indlen); 496267e4e69cSChristoph Hellwig xfs_iext_update_extent(ifp, *idx, got); 4963fa5c836cSChristoph Hellwig trace_xfs_bmap_post_update(ip, *idx, 0, _THIS_IP_); 4964fa5c836cSChristoph Hellwig 4965fa5c836cSChristoph Hellwig new.br_startoff = del_endoff; 4966fa5c836cSChristoph Hellwig new.br_state = got->br_state; 4967fa5c836cSChristoph Hellwig new.br_startblock = nullstartblock((int)new_indlen); 4968fa5c836cSChristoph Hellwig 4969fa5c836cSChristoph Hellwig ++*idx; 4970fa5c836cSChristoph Hellwig xfs_iext_insert(ip, *idx, 1, &new, state); 4971fa5c836cSChristoph Hellwig 4972fa5c836cSChristoph Hellwig da_new = got_indlen + new_indlen - stolen; 4973fa5c836cSChristoph Hellwig del->br_blockcount -= stolen; 4974fa5c836cSChristoph Hellwig break; 4975fa5c836cSChristoph Hellwig } 4976fa5c836cSChristoph Hellwig 4977fa5c836cSChristoph Hellwig ASSERT(da_old >= da_new); 4978fa5c836cSChristoph Hellwig da_diff = da_old - da_new; 4979fa5c836cSChristoph Hellwig if (!isrt) 4980fa5c836cSChristoph Hellwig da_diff += del->br_blockcount; 4981fa5c836cSChristoph Hellwig if (da_diff) 4982fa5c836cSChristoph Hellwig xfs_mod_fdblocks(mp, da_diff, false); 4983fa5c836cSChristoph Hellwig return error; 4984fa5c836cSChristoph Hellwig } 4985fa5c836cSChristoph Hellwig 4986fa5c836cSChristoph Hellwig void 4987fa5c836cSChristoph Hellwig xfs_bmap_del_extent_cow( 4988fa5c836cSChristoph Hellwig struct xfs_inode *ip, 4989fa5c836cSChristoph Hellwig xfs_extnum_t *idx, 4990fa5c836cSChristoph Hellwig struct xfs_bmbt_irec *got, 4991fa5c836cSChristoph Hellwig struct xfs_bmbt_irec *del) 4992fa5c836cSChristoph Hellwig { 4993fa5c836cSChristoph Hellwig struct xfs_mount *mp = ip->i_mount; 4994fa5c836cSChristoph Hellwig struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, XFS_COW_FORK); 4995fa5c836cSChristoph Hellwig struct xfs_bmbt_irec new; 4996fa5c836cSChristoph Hellwig xfs_fileoff_t del_endoff, got_endoff; 4997fa5c836cSChristoph Hellwig int state = BMAP_COWFORK; 4998fa5c836cSChristoph Hellwig 4999fa5c836cSChristoph Hellwig XFS_STATS_INC(mp, xs_del_exlist); 5000fa5c836cSChristoph Hellwig 5001fa5c836cSChristoph Hellwig del_endoff = del->br_startoff + del->br_blockcount; 5002fa5c836cSChristoph Hellwig got_endoff = got->br_startoff + got->br_blockcount; 5003fa5c836cSChristoph Hellwig 5004fa5c836cSChristoph Hellwig ASSERT(*idx >= 0); 50055d829300SEric Sandeen ASSERT(*idx <= xfs_iext_count(ifp)); 5006fa5c836cSChristoph Hellwig ASSERT(del->br_blockcount > 0); 5007fa5c836cSChristoph Hellwig ASSERT(got->br_startoff <= del->br_startoff); 5008fa5c836cSChristoph Hellwig ASSERT(got_endoff >= del_endoff); 5009fa5c836cSChristoph Hellwig ASSERT(!isnullstartblock(got->br_startblock)); 5010fa5c836cSChristoph Hellwig 5011fa5c836cSChristoph Hellwig if (got->br_startoff == del->br_startoff) 5012fa5c836cSChristoph Hellwig state |= BMAP_LEFT_CONTIG; 5013fa5c836cSChristoph Hellwig if (got_endoff == del_endoff) 5014fa5c836cSChristoph Hellwig state |= BMAP_RIGHT_CONTIG; 5015fa5c836cSChristoph Hellwig 5016fa5c836cSChristoph Hellwig switch (state & (BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG)) { 5017fa5c836cSChristoph Hellwig case BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG: 5018fa5c836cSChristoph Hellwig /* 5019fa5c836cSChristoph Hellwig * Matches the whole extent. Delete the entry. 5020fa5c836cSChristoph Hellwig */ 5021fa5c836cSChristoph Hellwig xfs_iext_remove(ip, *idx, 1, state); 5022fa5c836cSChristoph Hellwig --*idx; 5023fa5c836cSChristoph Hellwig break; 5024fa5c836cSChristoph Hellwig case BMAP_LEFT_CONTIG: 5025fa5c836cSChristoph Hellwig /* 5026fa5c836cSChristoph Hellwig * Deleting the first part of the extent. 5027fa5c836cSChristoph Hellwig */ 5028fa5c836cSChristoph Hellwig trace_xfs_bmap_pre_update(ip, *idx, state, _THIS_IP_); 5029fa5c836cSChristoph Hellwig got->br_startoff = del_endoff; 5030fa5c836cSChristoph Hellwig got->br_blockcount -= del->br_blockcount; 5031fa5c836cSChristoph Hellwig got->br_startblock = del->br_startblock + del->br_blockcount; 503267e4e69cSChristoph Hellwig xfs_iext_update_extent(ifp, *idx, got); 5033fa5c836cSChristoph Hellwig trace_xfs_bmap_post_update(ip, *idx, state, _THIS_IP_); 5034fa5c836cSChristoph Hellwig break; 5035fa5c836cSChristoph Hellwig case BMAP_RIGHT_CONTIG: 5036fa5c836cSChristoph Hellwig /* 5037fa5c836cSChristoph Hellwig * Deleting the last part of the extent. 5038fa5c836cSChristoph Hellwig */ 5039fa5c836cSChristoph Hellwig trace_xfs_bmap_pre_update(ip, *idx, state, _THIS_IP_); 5040fa5c836cSChristoph Hellwig got->br_blockcount -= del->br_blockcount; 504167e4e69cSChristoph Hellwig xfs_iext_update_extent(ifp, *idx, got); 5042fa5c836cSChristoph Hellwig trace_xfs_bmap_post_update(ip, *idx, state, _THIS_IP_); 5043fa5c836cSChristoph Hellwig break; 5044fa5c836cSChristoph Hellwig case 0: 5045fa5c836cSChristoph Hellwig /* 5046fa5c836cSChristoph Hellwig * Deleting the middle of the extent. 5047fa5c836cSChristoph Hellwig */ 5048fa5c836cSChristoph Hellwig trace_xfs_bmap_pre_update(ip, *idx, state, _THIS_IP_); 5049fa5c836cSChristoph Hellwig got->br_blockcount = del->br_startoff - got->br_startoff; 505067e4e69cSChristoph Hellwig xfs_iext_update_extent(ifp, *idx, got); 5051fa5c836cSChristoph Hellwig trace_xfs_bmap_post_update(ip, *idx, state, _THIS_IP_); 5052fa5c836cSChristoph Hellwig 5053fa5c836cSChristoph Hellwig new.br_startoff = del_endoff; 5054fa5c836cSChristoph Hellwig new.br_blockcount = got_endoff - del_endoff; 5055fa5c836cSChristoph Hellwig new.br_state = got->br_state; 5056fa5c836cSChristoph Hellwig new.br_startblock = del->br_startblock + del->br_blockcount; 5057fa5c836cSChristoph Hellwig 5058fa5c836cSChristoph Hellwig ++*idx; 5059fa5c836cSChristoph Hellwig xfs_iext_insert(ip, *idx, 1, &new, state); 5060fa5c836cSChristoph Hellwig break; 5061fa5c836cSChristoph Hellwig } 5062fa5c836cSChristoph Hellwig } 5063fa5c836cSChristoph Hellwig 5064a9bd24acSBrian Foster /* 506530f712c9SDave Chinner * Called by xfs_bmapi to update file extent records and the btree 506630f712c9SDave Chinner * after removing space (or undoing a delayed allocation). 506730f712c9SDave Chinner */ 506830f712c9SDave Chinner STATIC int /* error */ 506930f712c9SDave Chinner xfs_bmap_del_extent( 507030f712c9SDave Chinner xfs_inode_t *ip, /* incore inode pointer */ 507130f712c9SDave Chinner xfs_trans_t *tp, /* current transaction pointer */ 507230f712c9SDave Chinner xfs_extnum_t *idx, /* extent number to update/delete */ 50732c3234d1SDarrick J. Wong struct xfs_defer_ops *dfops, /* list of extents to be freed */ 507430f712c9SDave Chinner xfs_btree_cur_t *cur, /* if null, not a btree */ 507530f712c9SDave Chinner xfs_bmbt_irec_t *del, /* data to remove from extents */ 507630f712c9SDave Chinner int *logflagsp, /* inode logging flags */ 50774847acf8SDarrick J. Wong int whichfork, /* data or attr fork */ 50784847acf8SDarrick J. Wong int bflags) /* bmapi flags */ 507930f712c9SDave Chinner { 508030f712c9SDave Chinner xfs_filblks_t da_new; /* new delay-alloc indirect blocks */ 508130f712c9SDave Chinner xfs_filblks_t da_old; /* old delay-alloc indirect blocks */ 508230f712c9SDave Chinner xfs_fsblock_t del_endblock=0; /* first block past del */ 508330f712c9SDave Chinner xfs_fileoff_t del_endoff; /* first offset past del */ 508430f712c9SDave Chinner int delay; /* current block is delayed allocated */ 508530f712c9SDave Chinner int do_fx; /* free extent at end of routine */ 508630f712c9SDave Chinner xfs_bmbt_rec_host_t *ep; /* current extent entry pointer */ 508730f712c9SDave Chinner int error; /* error return value */ 508830f712c9SDave Chinner int flags; /* inode logging flags */ 508930f712c9SDave Chinner xfs_bmbt_irec_t got; /* current extent entry */ 509030f712c9SDave Chinner xfs_fileoff_t got_endoff; /* first offset past got */ 509130f712c9SDave Chinner int i; /* temp state */ 509230f712c9SDave Chinner xfs_ifork_t *ifp; /* inode fork pointer */ 509330f712c9SDave Chinner xfs_mount_t *mp; /* mount structure */ 509430f712c9SDave Chinner xfs_filblks_t nblks; /* quota/sb block count */ 509530f712c9SDave Chinner xfs_bmbt_irec_t new; /* new record to be inserted */ 509630f712c9SDave Chinner /* REFERENCED */ 509730f712c9SDave Chinner uint qfield; /* quota field to update */ 509830f712c9SDave Chinner xfs_filblks_t temp; /* for indirect length calculations */ 509930f712c9SDave Chinner xfs_filblks_t temp2; /* for indirect length calculations */ 510030f712c9SDave Chinner int state = 0; 510130f712c9SDave Chinner 5102ff6d6af2SBill O'Donnell mp = ip->i_mount; 5103ff6d6af2SBill O'Donnell XFS_STATS_INC(mp, xs_del_exlist); 510430f712c9SDave Chinner 510530f712c9SDave Chinner if (whichfork == XFS_ATTR_FORK) 510630f712c9SDave Chinner state |= BMAP_ATTRFORK; 51073993baebSDarrick J. Wong else if (whichfork == XFS_COW_FORK) 51083993baebSDarrick J. Wong state |= BMAP_COWFORK; 510930f712c9SDave Chinner 511030f712c9SDave Chinner ifp = XFS_IFORK_PTR(ip, whichfork); 51115d829300SEric Sandeen ASSERT((*idx >= 0) && (*idx < xfs_iext_count(ifp))); 511230f712c9SDave Chinner ASSERT(del->br_blockcount > 0); 511330f712c9SDave Chinner ep = xfs_iext_get_ext(ifp, *idx); 511430f712c9SDave Chinner xfs_bmbt_get_all(ep, &got); 511530f712c9SDave Chinner ASSERT(got.br_startoff <= del->br_startoff); 511630f712c9SDave Chinner del_endoff = del->br_startoff + del->br_blockcount; 511730f712c9SDave Chinner got_endoff = got.br_startoff + got.br_blockcount; 511830f712c9SDave Chinner ASSERT(got_endoff >= del_endoff); 511930f712c9SDave Chinner delay = isnullstartblock(got.br_startblock); 512030f712c9SDave Chinner ASSERT(isnullstartblock(del->br_startblock) == delay); 512130f712c9SDave Chinner flags = 0; 512230f712c9SDave Chinner qfield = 0; 512330f712c9SDave Chinner error = 0; 512430f712c9SDave Chinner /* 512530f712c9SDave Chinner * If deleting a real allocation, must free up the disk space. 512630f712c9SDave Chinner */ 512730f712c9SDave Chinner if (!delay) { 512830f712c9SDave Chinner flags = XFS_ILOG_CORE; 512930f712c9SDave Chinner /* 513030f712c9SDave Chinner * Realtime allocation. Free it and record di_nblocks update. 513130f712c9SDave Chinner */ 513230f712c9SDave Chinner if (whichfork == XFS_DATA_FORK && XFS_IS_REALTIME_INODE(ip)) { 513330f712c9SDave Chinner xfs_fsblock_t bno; 513430f712c9SDave Chinner xfs_filblks_t len; 513530f712c9SDave Chinner 513630f712c9SDave Chinner ASSERT(do_mod(del->br_blockcount, 513730f712c9SDave Chinner mp->m_sb.sb_rextsize) == 0); 513830f712c9SDave Chinner ASSERT(do_mod(del->br_startblock, 513930f712c9SDave Chinner mp->m_sb.sb_rextsize) == 0); 514030f712c9SDave Chinner bno = del->br_startblock; 514130f712c9SDave Chinner len = del->br_blockcount; 514230f712c9SDave Chinner do_div(bno, mp->m_sb.sb_rextsize); 514330f712c9SDave Chinner do_div(len, mp->m_sb.sb_rextsize); 514430f712c9SDave Chinner error = xfs_rtfree_extent(tp, bno, (xfs_extlen_t)len); 514530f712c9SDave Chinner if (error) 514630f712c9SDave Chinner goto done; 514730f712c9SDave Chinner do_fx = 0; 514830f712c9SDave Chinner nblks = len * mp->m_sb.sb_rextsize; 514930f712c9SDave Chinner qfield = XFS_TRANS_DQ_RTBCOUNT; 515030f712c9SDave Chinner } 515130f712c9SDave Chinner /* 515230f712c9SDave Chinner * Ordinary allocation. 515330f712c9SDave Chinner */ 515430f712c9SDave Chinner else { 515530f712c9SDave Chinner do_fx = 1; 515630f712c9SDave Chinner nblks = del->br_blockcount; 515730f712c9SDave Chinner qfield = XFS_TRANS_DQ_BCOUNT; 515830f712c9SDave Chinner } 515930f712c9SDave Chinner /* 516030f712c9SDave Chinner * Set up del_endblock and cur for later. 516130f712c9SDave Chinner */ 516230f712c9SDave Chinner del_endblock = del->br_startblock + del->br_blockcount; 516330f712c9SDave Chinner if (cur) { 516430f712c9SDave Chinner if ((error = xfs_bmbt_lookup_eq(cur, got.br_startoff, 516530f712c9SDave Chinner got.br_startblock, got.br_blockcount, 516630f712c9SDave Chinner &i))) 516730f712c9SDave Chinner goto done; 5168c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 516930f712c9SDave Chinner } 517030f712c9SDave Chinner da_old = da_new = 0; 517130f712c9SDave Chinner } else { 517230f712c9SDave Chinner da_old = startblockval(got.br_startblock); 517330f712c9SDave Chinner da_new = 0; 517430f712c9SDave Chinner nblks = 0; 517530f712c9SDave Chinner do_fx = 0; 517630f712c9SDave Chinner } 5177340785ccSDarrick J. Wong 517830f712c9SDave Chinner /* 517930f712c9SDave Chinner * Set flag value to use in switch statement. 518030f712c9SDave Chinner * Left-contig is 2, right-contig is 1. 518130f712c9SDave Chinner */ 518230f712c9SDave Chinner switch (((got.br_startoff == del->br_startoff) << 1) | 518330f712c9SDave Chinner (got_endoff == del_endoff)) { 518430f712c9SDave Chinner case 3: 518530f712c9SDave Chinner /* 518630f712c9SDave Chinner * Matches the whole extent. Delete the entry. 518730f712c9SDave Chinner */ 51884862cfe8SDarrick J. Wong trace_xfs_bmap_pre_update(ip, *idx, state, _THIS_IP_); 518930f712c9SDave Chinner xfs_iext_remove(ip, *idx, 1, 519030f712c9SDave Chinner whichfork == XFS_ATTR_FORK ? BMAP_ATTRFORK : 0); 519130f712c9SDave Chinner --*idx; 519230f712c9SDave Chinner if (delay) 519330f712c9SDave Chinner break; 519430f712c9SDave Chinner 519530f712c9SDave Chinner XFS_IFORK_NEXT_SET(ip, whichfork, 519630f712c9SDave Chinner XFS_IFORK_NEXTENTS(ip, whichfork) - 1); 519730f712c9SDave Chinner flags |= XFS_ILOG_CORE; 519830f712c9SDave Chinner if (!cur) { 519930f712c9SDave Chinner flags |= xfs_ilog_fext(whichfork); 520030f712c9SDave Chinner break; 520130f712c9SDave Chinner } 520230f712c9SDave Chinner if ((error = xfs_btree_delete(cur, &i))) 520330f712c9SDave Chinner goto done; 5204c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 520530f712c9SDave Chinner break; 520630f712c9SDave Chinner 520730f712c9SDave Chinner case 2: 520830f712c9SDave Chinner /* 520930f712c9SDave Chinner * Deleting the first part of the extent. 521030f712c9SDave Chinner */ 521130f712c9SDave Chinner trace_xfs_bmap_pre_update(ip, *idx, state, _THIS_IP_); 521230f712c9SDave Chinner xfs_bmbt_set_startoff(ep, del_endoff); 521330f712c9SDave Chinner temp = got.br_blockcount - del->br_blockcount; 521430f712c9SDave Chinner xfs_bmbt_set_blockcount(ep, temp); 521530f712c9SDave Chinner if (delay) { 521630f712c9SDave Chinner temp = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(ip, temp), 521730f712c9SDave Chinner da_old); 521830f712c9SDave Chinner xfs_bmbt_set_startblock(ep, nullstartblock((int)temp)); 521930f712c9SDave Chinner trace_xfs_bmap_post_update(ip, *idx, state, _THIS_IP_); 522030f712c9SDave Chinner da_new = temp; 522130f712c9SDave Chinner break; 522230f712c9SDave Chinner } 522330f712c9SDave Chinner xfs_bmbt_set_startblock(ep, del_endblock); 522430f712c9SDave Chinner trace_xfs_bmap_post_update(ip, *idx, state, _THIS_IP_); 522530f712c9SDave Chinner if (!cur) { 522630f712c9SDave Chinner flags |= xfs_ilog_fext(whichfork); 522730f712c9SDave Chinner break; 522830f712c9SDave Chinner } 522930f712c9SDave Chinner if ((error = xfs_bmbt_update(cur, del_endoff, del_endblock, 523030f712c9SDave Chinner got.br_blockcount - del->br_blockcount, 523130f712c9SDave Chinner got.br_state))) 523230f712c9SDave Chinner goto done; 523330f712c9SDave Chinner break; 523430f712c9SDave Chinner 523530f712c9SDave Chinner case 1: 523630f712c9SDave Chinner /* 523730f712c9SDave Chinner * Deleting the last part of the extent. 523830f712c9SDave Chinner */ 523930f712c9SDave Chinner temp = got.br_blockcount - del->br_blockcount; 524030f712c9SDave Chinner trace_xfs_bmap_pre_update(ip, *idx, state, _THIS_IP_); 524130f712c9SDave Chinner xfs_bmbt_set_blockcount(ep, temp); 524230f712c9SDave Chinner if (delay) { 524330f712c9SDave Chinner temp = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(ip, temp), 524430f712c9SDave Chinner da_old); 524530f712c9SDave Chinner xfs_bmbt_set_startblock(ep, nullstartblock((int)temp)); 524630f712c9SDave Chinner trace_xfs_bmap_post_update(ip, *idx, state, _THIS_IP_); 524730f712c9SDave Chinner da_new = temp; 524830f712c9SDave Chinner break; 524930f712c9SDave Chinner } 525030f712c9SDave Chinner trace_xfs_bmap_post_update(ip, *idx, state, _THIS_IP_); 525130f712c9SDave Chinner if (!cur) { 525230f712c9SDave Chinner flags |= xfs_ilog_fext(whichfork); 525330f712c9SDave Chinner break; 525430f712c9SDave Chinner } 525530f712c9SDave Chinner if ((error = xfs_bmbt_update(cur, got.br_startoff, 525630f712c9SDave Chinner got.br_startblock, 525730f712c9SDave Chinner got.br_blockcount - del->br_blockcount, 525830f712c9SDave Chinner got.br_state))) 525930f712c9SDave Chinner goto done; 526030f712c9SDave Chinner break; 526130f712c9SDave Chinner 526230f712c9SDave Chinner case 0: 526330f712c9SDave Chinner /* 526430f712c9SDave Chinner * Deleting the middle of the extent. 526530f712c9SDave Chinner */ 526630f712c9SDave Chinner temp = del->br_startoff - got.br_startoff; 526730f712c9SDave Chinner trace_xfs_bmap_pre_update(ip, *idx, state, _THIS_IP_); 526830f712c9SDave Chinner xfs_bmbt_set_blockcount(ep, temp); 526930f712c9SDave Chinner new.br_startoff = del_endoff; 527030f712c9SDave Chinner temp2 = got_endoff - del_endoff; 527130f712c9SDave Chinner new.br_blockcount = temp2; 527230f712c9SDave Chinner new.br_state = got.br_state; 527330f712c9SDave Chinner if (!delay) { 527430f712c9SDave Chinner new.br_startblock = del_endblock; 527530f712c9SDave Chinner flags |= XFS_ILOG_CORE; 527630f712c9SDave Chinner if (cur) { 527730f712c9SDave Chinner if ((error = xfs_bmbt_update(cur, 527830f712c9SDave Chinner got.br_startoff, 527930f712c9SDave Chinner got.br_startblock, temp, 528030f712c9SDave Chinner got.br_state))) 528130f712c9SDave Chinner goto done; 528230f712c9SDave Chinner if ((error = xfs_btree_increment(cur, 0, &i))) 528330f712c9SDave Chinner goto done; 528430f712c9SDave Chinner cur->bc_rec.b = new; 528530f712c9SDave Chinner error = xfs_btree_insert(cur, &i); 52862451337dSDave Chinner if (error && error != -ENOSPC) 528730f712c9SDave Chinner goto done; 528830f712c9SDave Chinner /* 528930f712c9SDave Chinner * If get no-space back from btree insert, 529030f712c9SDave Chinner * it tried a split, and we have a zero 529130f712c9SDave Chinner * block reservation. 529230f712c9SDave Chinner * Fix up our state and return the error. 529330f712c9SDave Chinner */ 52942451337dSDave Chinner if (error == -ENOSPC) { 529530f712c9SDave Chinner /* 529630f712c9SDave Chinner * Reset the cursor, don't trust 529730f712c9SDave Chinner * it after any insert operation. 529830f712c9SDave Chinner */ 529930f712c9SDave Chinner if ((error = xfs_bmbt_lookup_eq(cur, 530030f712c9SDave Chinner got.br_startoff, 530130f712c9SDave Chinner got.br_startblock, 530230f712c9SDave Chinner temp, &i))) 530330f712c9SDave Chinner goto done; 5304c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, 5305c29aad41SEric Sandeen i == 1, done); 530630f712c9SDave Chinner /* 530730f712c9SDave Chinner * Update the btree record back 530830f712c9SDave Chinner * to the original value. 530930f712c9SDave Chinner */ 531030f712c9SDave Chinner if ((error = xfs_bmbt_update(cur, 531130f712c9SDave Chinner got.br_startoff, 531230f712c9SDave Chinner got.br_startblock, 531330f712c9SDave Chinner got.br_blockcount, 531430f712c9SDave Chinner got.br_state))) 531530f712c9SDave Chinner goto done; 531630f712c9SDave Chinner /* 531730f712c9SDave Chinner * Reset the extent record back 531830f712c9SDave Chinner * to the original value. 531930f712c9SDave Chinner */ 532030f712c9SDave Chinner xfs_bmbt_set_blockcount(ep, 532130f712c9SDave Chinner got.br_blockcount); 532230f712c9SDave Chinner flags = 0; 53232451337dSDave Chinner error = -ENOSPC; 532430f712c9SDave Chinner goto done; 532530f712c9SDave Chinner } 5326c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 532730f712c9SDave Chinner } else 532830f712c9SDave Chinner flags |= xfs_ilog_fext(whichfork); 532930f712c9SDave Chinner XFS_IFORK_NEXT_SET(ip, whichfork, 533030f712c9SDave Chinner XFS_IFORK_NEXTENTS(ip, whichfork) + 1); 533130f712c9SDave Chinner } else { 5332d34999c9SBrian Foster xfs_filblks_t stolen; 533330f712c9SDave Chinner ASSERT(whichfork == XFS_DATA_FORK); 5334a9bd24acSBrian Foster 5335a9bd24acSBrian Foster /* 5336a9bd24acSBrian Foster * Distribute the original indlen reservation across the 5337d34999c9SBrian Foster * two new extents. Steal blocks from the deleted extent 5338d34999c9SBrian Foster * if necessary. Stealing blocks simply fudges the 5339d34999c9SBrian Foster * fdblocks accounting in xfs_bunmapi(). 5340a9bd24acSBrian Foster */ 5341a9bd24acSBrian Foster temp = xfs_bmap_worst_indlen(ip, got.br_blockcount); 5342a9bd24acSBrian Foster temp2 = xfs_bmap_worst_indlen(ip, new.br_blockcount); 5343d34999c9SBrian Foster stolen = xfs_bmap_split_indlen(da_old, &temp, &temp2, 5344d34999c9SBrian Foster del->br_blockcount); 5345d34999c9SBrian Foster da_new = temp + temp2 - stolen; 5346d34999c9SBrian Foster del->br_blockcount -= stolen; 5347a9bd24acSBrian Foster 5348a9bd24acSBrian Foster /* 5349d34999c9SBrian Foster * Set the reservation for each extent. Warn if either 5350d34999c9SBrian Foster * is zero as this can lead to delalloc problems. 5351a9bd24acSBrian Foster */ 5352d34999c9SBrian Foster WARN_ON_ONCE(!temp || !temp2); 535330f712c9SDave Chinner xfs_bmbt_set_startblock(ep, nullstartblock((int)temp)); 535430f712c9SDave Chinner new.br_startblock = nullstartblock((int)temp2); 535530f712c9SDave Chinner } 535630f712c9SDave Chinner trace_xfs_bmap_post_update(ip, *idx, state, _THIS_IP_); 535730f712c9SDave Chinner xfs_iext_insert(ip, *idx + 1, 1, &new, state); 535830f712c9SDave Chinner ++*idx; 535930f712c9SDave Chinner break; 536030f712c9SDave Chinner } 53619c194644SDarrick J. Wong 53629c194644SDarrick J. Wong /* remove reverse mapping */ 53639c194644SDarrick J. Wong if (!delay) { 53649c194644SDarrick J. Wong error = xfs_rmap_unmap_extent(mp, dfops, ip, whichfork, del); 53659c194644SDarrick J. Wong if (error) 53669c194644SDarrick J. Wong goto done; 53679c194644SDarrick J. Wong } 53689c194644SDarrick J. Wong 536930f712c9SDave Chinner /* 537030f712c9SDave Chinner * If we need to, add to list of extents to delete. 537130f712c9SDave Chinner */ 53724847acf8SDarrick J. Wong if (do_fx && !(bflags & XFS_BMAPI_REMAP)) { 537362aab20fSDarrick J. Wong if (xfs_is_reflink_inode(ip) && whichfork == XFS_DATA_FORK) { 537462aab20fSDarrick J. Wong error = xfs_refcount_decrease_extent(mp, dfops, del); 537562aab20fSDarrick J. Wong if (error) 537662aab20fSDarrick J. Wong goto done; 537762aab20fSDarrick J. Wong } else 53782c3234d1SDarrick J. Wong xfs_bmap_add_free(mp, dfops, del->br_startblock, 5379340785ccSDarrick J. Wong del->br_blockcount, NULL); 538062aab20fSDarrick J. Wong } 538162aab20fSDarrick J. Wong 538230f712c9SDave Chinner /* 538330f712c9SDave Chinner * Adjust inode # blocks in the file. 538430f712c9SDave Chinner */ 538530f712c9SDave Chinner if (nblks) 538630f712c9SDave Chinner ip->i_d.di_nblocks -= nblks; 538730f712c9SDave Chinner /* 538830f712c9SDave Chinner * Adjust quota data. 538930f712c9SDave Chinner */ 53904847acf8SDarrick J. Wong if (qfield && !(bflags & XFS_BMAPI_REMAP)) 539130f712c9SDave Chinner xfs_trans_mod_dquot_byino(tp, ip, qfield, (long)-nblks); 539230f712c9SDave Chinner 539330f712c9SDave Chinner /* 539430f712c9SDave Chinner * Account for change in delayed indirect blocks. 539530f712c9SDave Chinner * Nothing to do for disk quota accounting here. 539630f712c9SDave Chinner */ 539730f712c9SDave Chinner ASSERT(da_old >= da_new); 53980d485adaSDave Chinner if (da_old > da_new) 53990d485adaSDave Chinner xfs_mod_fdblocks(mp, (int64_t)(da_old - da_new), false); 540030f712c9SDave Chinner done: 540130f712c9SDave Chinner *logflagsp = flags; 540230f712c9SDave Chinner return error; 540330f712c9SDave Chinner } 540430f712c9SDave Chinner 540530f712c9SDave Chinner /* 540630f712c9SDave Chinner * Unmap (remove) blocks from a file. 540730f712c9SDave Chinner * If nexts is nonzero then the number of extents to remove is limited to 540830f712c9SDave Chinner * that value. If not all extents in the block range can be removed then 540930f712c9SDave Chinner * *done is set. 541030f712c9SDave Chinner */ 541130f712c9SDave Chinner int /* error */ 54124453593bSDarrick J. Wong __xfs_bunmapi( 541330f712c9SDave Chinner xfs_trans_t *tp, /* transaction pointer */ 541430f712c9SDave Chinner struct xfs_inode *ip, /* incore inode */ 541530f712c9SDave Chinner xfs_fileoff_t bno, /* starting offset to unmap */ 54164453593bSDarrick J. Wong xfs_filblks_t *rlen, /* i/o: amount remaining */ 541730f712c9SDave Chinner int flags, /* misc flags */ 541830f712c9SDave Chinner xfs_extnum_t nexts, /* number of extents max */ 541930f712c9SDave Chinner xfs_fsblock_t *firstblock, /* first allocated block 542030f712c9SDave Chinner controls a.g. for allocs */ 54214453593bSDarrick J. Wong struct xfs_defer_ops *dfops) /* i/o: deferred updates */ 542230f712c9SDave Chinner { 542330f712c9SDave Chinner xfs_btree_cur_t *cur; /* bmap btree cursor */ 542430f712c9SDave Chinner xfs_bmbt_irec_t del; /* extent being deleted */ 542530f712c9SDave Chinner int error; /* error return value */ 542630f712c9SDave Chinner xfs_extnum_t extno; /* extent number in list */ 542730f712c9SDave Chinner xfs_bmbt_irec_t got; /* current extent record */ 542830f712c9SDave Chinner xfs_ifork_t *ifp; /* inode fork pointer */ 542930f712c9SDave Chinner int isrt; /* freeing in rt area */ 543030f712c9SDave Chinner xfs_extnum_t lastx; /* last extent index used */ 543130f712c9SDave Chinner int logflags; /* transaction logging flags */ 543230f712c9SDave Chinner xfs_extlen_t mod; /* rt extent offset */ 543330f712c9SDave Chinner xfs_mount_t *mp; /* mount structure */ 543430f712c9SDave Chinner xfs_fileoff_t start; /* first file offset deleted */ 543530f712c9SDave Chinner int tmp_logflags; /* partial logging flags */ 543630f712c9SDave Chinner int wasdel; /* was a delayed alloc extent */ 543730f712c9SDave Chinner int whichfork; /* data or attribute fork */ 543830f712c9SDave Chinner xfs_fsblock_t sum; 54394453593bSDarrick J. Wong xfs_filblks_t len = *rlen; /* length to unmap in file */ 5440e1a4e37cSDarrick J. Wong xfs_fileoff_t max_len; 54415b094d6dSChristoph Hellwig xfs_agnumber_t prev_agno = NULLAGNUMBER, agno; 544230f712c9SDave Chinner 544330f712c9SDave Chinner trace_xfs_bunmap(ip, bno, len, flags, _RET_IP_); 544430f712c9SDave Chinner 54453993baebSDarrick J. Wong whichfork = xfs_bmapi_whichfork(flags); 54463993baebSDarrick J. Wong ASSERT(whichfork != XFS_COW_FORK); 544730f712c9SDave Chinner ifp = XFS_IFORK_PTR(ip, whichfork); 544830f712c9SDave Chinner if (unlikely( 544930f712c9SDave Chinner XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS && 545030f712c9SDave Chinner XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE)) { 545130f712c9SDave Chinner XFS_ERROR_REPORT("xfs_bunmapi", XFS_ERRLEVEL_LOW, 545230f712c9SDave Chinner ip->i_mount); 54532451337dSDave Chinner return -EFSCORRUPTED; 545430f712c9SDave Chinner } 545530f712c9SDave Chinner mp = ip->i_mount; 545630f712c9SDave Chinner if (XFS_FORCED_SHUTDOWN(mp)) 54572451337dSDave Chinner return -EIO; 545830f712c9SDave Chinner 545930f712c9SDave Chinner ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL)); 546030f712c9SDave Chinner ASSERT(len > 0); 546130f712c9SDave Chinner ASSERT(nexts >= 0); 546230f712c9SDave Chinner 5463e1a4e37cSDarrick J. Wong /* 5464e1a4e37cSDarrick J. Wong * Guesstimate how many blocks we can unmap without running the risk of 5465e1a4e37cSDarrick J. Wong * blowing out the transaction with a mix of EFIs and reflink 5466e1a4e37cSDarrick J. Wong * adjustments. 5467e1a4e37cSDarrick J. Wong */ 5468e1a4e37cSDarrick J. Wong if (xfs_is_reflink_inode(ip) && whichfork == XFS_DATA_FORK) 5469e1a4e37cSDarrick J. Wong max_len = min(len, xfs_refcount_max_unmap(tp->t_log_res)); 5470e1a4e37cSDarrick J. Wong else 5471e1a4e37cSDarrick J. Wong max_len = len; 5472e1a4e37cSDarrick J. Wong 547330f712c9SDave Chinner if (!(ifp->if_flags & XFS_IFEXTENTS) && 547430f712c9SDave Chinner (error = xfs_iread_extents(tp, ip, whichfork))) 547530f712c9SDave Chinner return error; 54765d829300SEric Sandeen if (xfs_iext_count(ifp) == 0) { 54774453593bSDarrick J. Wong *rlen = 0; 547830f712c9SDave Chinner return 0; 547930f712c9SDave Chinner } 5480ff6d6af2SBill O'Donnell XFS_STATS_INC(mp, xs_blk_unmap); 548130f712c9SDave Chinner isrt = (whichfork == XFS_DATA_FORK) && XFS_IS_REALTIME_INODE(ip); 548230f712c9SDave Chinner start = bno; 548330f712c9SDave Chinner bno = start + len - 1; 548430f712c9SDave Chinner 548530f712c9SDave Chinner /* 548630f712c9SDave Chinner * Check to see if the given block number is past the end of the 548730f712c9SDave Chinner * file, back up to the last block if so... 548830f712c9SDave Chinner */ 54897efc7945SChristoph Hellwig if (!xfs_iext_lookup_extent(ip, ifp, bno, &lastx, &got)) { 54907efc7945SChristoph Hellwig ASSERT(lastx > 0); 54917efc7945SChristoph Hellwig xfs_iext_get_extent(ifp, --lastx, &got); 549230f712c9SDave Chinner bno = got.br_startoff + got.br_blockcount - 1; 549330f712c9SDave Chinner } 54947efc7945SChristoph Hellwig 549530f712c9SDave Chinner logflags = 0; 549630f712c9SDave Chinner if (ifp->if_flags & XFS_IFBROOT) { 549730f712c9SDave Chinner ASSERT(XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_BTREE); 549830f712c9SDave Chinner cur = xfs_bmbt_init_cursor(mp, tp, ip, whichfork); 549930f712c9SDave Chinner cur->bc_private.b.firstblock = *firstblock; 55002c3234d1SDarrick J. Wong cur->bc_private.b.dfops = dfops; 550130f712c9SDave Chinner cur->bc_private.b.flags = 0; 550230f712c9SDave Chinner } else 550330f712c9SDave Chinner cur = NULL; 550430f712c9SDave Chinner 550530f712c9SDave Chinner if (isrt) { 550630f712c9SDave Chinner /* 550730f712c9SDave Chinner * Synchronize by locking the bitmap inode. 550830f712c9SDave Chinner */ 5509f4a0660dSDarrick J. Wong xfs_ilock(mp->m_rbmip, XFS_ILOCK_EXCL|XFS_ILOCK_RTBITMAP); 551030f712c9SDave Chinner xfs_trans_ijoin(tp, mp->m_rbmip, XFS_ILOCK_EXCL); 5511f4a0660dSDarrick J. Wong xfs_ilock(mp->m_rsumip, XFS_ILOCK_EXCL|XFS_ILOCK_RTSUM); 5512f4a0660dSDarrick J. Wong xfs_trans_ijoin(tp, mp->m_rsumip, XFS_ILOCK_EXCL); 551330f712c9SDave Chinner } 551430f712c9SDave Chinner 551530f712c9SDave Chinner extno = 0; 551630f712c9SDave Chinner while (bno != (xfs_fileoff_t)-1 && bno >= start && lastx >= 0 && 5517e1a4e37cSDarrick J. Wong (nexts == 0 || extno < nexts) && max_len > 0) { 551830f712c9SDave Chinner /* 551930f712c9SDave Chinner * Is the found extent after a hole in which bno lives? 552030f712c9SDave Chinner * Just back up to the previous extent, if so. 552130f712c9SDave Chinner */ 552230f712c9SDave Chinner if (got.br_startoff > bno) { 552330f712c9SDave Chinner if (--lastx < 0) 552430f712c9SDave Chinner break; 55257efc7945SChristoph Hellwig xfs_iext_get_extent(ifp, lastx, &got); 552630f712c9SDave Chinner } 552730f712c9SDave Chinner /* 552830f712c9SDave Chinner * Is the last block of this extent before the range 552930f712c9SDave Chinner * we're supposed to delete? If so, we're done. 553030f712c9SDave Chinner */ 553130f712c9SDave Chinner bno = XFS_FILEOFF_MIN(bno, 553230f712c9SDave Chinner got.br_startoff + got.br_blockcount - 1); 553330f712c9SDave Chinner if (bno < start) 553430f712c9SDave Chinner break; 553530f712c9SDave Chinner /* 553630f712c9SDave Chinner * Then deal with the (possibly delayed) allocated space 553730f712c9SDave Chinner * we found. 553830f712c9SDave Chinner */ 553930f712c9SDave Chinner del = got; 554030f712c9SDave Chinner wasdel = isnullstartblock(del.br_startblock); 55415b094d6dSChristoph Hellwig 55425b094d6dSChristoph Hellwig /* 55435b094d6dSChristoph Hellwig * Make sure we don't touch multiple AGF headers out of order 55445b094d6dSChristoph Hellwig * in a single transaction, as that could cause AB-BA deadlocks. 55455b094d6dSChristoph Hellwig */ 55465b094d6dSChristoph Hellwig if (!wasdel) { 55475b094d6dSChristoph Hellwig agno = XFS_FSB_TO_AGNO(mp, del.br_startblock); 55485b094d6dSChristoph Hellwig if (prev_agno != NULLAGNUMBER && prev_agno > agno) 55495b094d6dSChristoph Hellwig break; 55505b094d6dSChristoph Hellwig prev_agno = agno; 55515b094d6dSChristoph Hellwig } 555230f712c9SDave Chinner if (got.br_startoff < start) { 555330f712c9SDave Chinner del.br_startoff = start; 555430f712c9SDave Chinner del.br_blockcount -= start - got.br_startoff; 555530f712c9SDave Chinner if (!wasdel) 555630f712c9SDave Chinner del.br_startblock += start - got.br_startoff; 555730f712c9SDave Chinner } 555830f712c9SDave Chinner if (del.br_startoff + del.br_blockcount > bno + 1) 555930f712c9SDave Chinner del.br_blockcount = bno + 1 - del.br_startoff; 5560e1a4e37cSDarrick J. Wong 5561e1a4e37cSDarrick J. Wong /* How much can we safely unmap? */ 5562e1a4e37cSDarrick J. Wong if (max_len < del.br_blockcount) { 5563e1a4e37cSDarrick J. Wong del.br_startoff += del.br_blockcount - max_len; 5564e1a4e37cSDarrick J. Wong if (!wasdel) 5565e1a4e37cSDarrick J. Wong del.br_startblock += del.br_blockcount - max_len; 5566e1a4e37cSDarrick J. Wong del.br_blockcount = max_len; 5567e1a4e37cSDarrick J. Wong } 5568e1a4e37cSDarrick J. Wong 556930f712c9SDave Chinner sum = del.br_startblock + del.br_blockcount; 557030f712c9SDave Chinner if (isrt && 557130f712c9SDave Chinner (mod = do_mod(sum, mp->m_sb.sb_rextsize))) { 557230f712c9SDave Chinner /* 557330f712c9SDave Chinner * Realtime extent not lined up at the end. 557430f712c9SDave Chinner * The extent could have been split into written 557530f712c9SDave Chinner * and unwritten pieces, or we could just be 557630f712c9SDave Chinner * unmapping part of it. But we can't really 557730f712c9SDave Chinner * get rid of part of a realtime extent. 557830f712c9SDave Chinner */ 557930f712c9SDave Chinner if (del.br_state == XFS_EXT_UNWRITTEN || 558030f712c9SDave Chinner !xfs_sb_version_hasextflgbit(&mp->m_sb)) { 558130f712c9SDave Chinner /* 558230f712c9SDave Chinner * This piece is unwritten, or we're not 558330f712c9SDave Chinner * using unwritten extents. Skip over it. 558430f712c9SDave Chinner */ 558530f712c9SDave Chinner ASSERT(bno >= mod); 558630f712c9SDave Chinner bno -= mod > del.br_blockcount ? 558730f712c9SDave Chinner del.br_blockcount : mod; 558830f712c9SDave Chinner if (bno < got.br_startoff) { 558930f712c9SDave Chinner if (--lastx >= 0) 559030f712c9SDave Chinner xfs_bmbt_get_all(xfs_iext_get_ext( 559130f712c9SDave Chinner ifp, lastx), &got); 559230f712c9SDave Chinner } 559330f712c9SDave Chinner continue; 559430f712c9SDave Chinner } 559530f712c9SDave Chinner /* 559630f712c9SDave Chinner * It's written, turn it unwritten. 559730f712c9SDave Chinner * This is better than zeroing it. 559830f712c9SDave Chinner */ 559930f712c9SDave Chinner ASSERT(del.br_state == XFS_EXT_NORM); 5600a7e5d03bSChristoph Hellwig ASSERT(tp->t_blk_res > 0); 560130f712c9SDave Chinner /* 560230f712c9SDave Chinner * If this spans a realtime extent boundary, 560330f712c9SDave Chinner * chop it back to the start of the one we end at. 560430f712c9SDave Chinner */ 560530f712c9SDave Chinner if (del.br_blockcount > mod) { 560630f712c9SDave Chinner del.br_startoff += del.br_blockcount - mod; 560730f712c9SDave Chinner del.br_startblock += del.br_blockcount - mod; 560830f712c9SDave Chinner del.br_blockcount = mod; 560930f712c9SDave Chinner } 561030f712c9SDave Chinner del.br_state = XFS_EXT_UNWRITTEN; 561130f712c9SDave Chinner error = xfs_bmap_add_extent_unwritten_real(tp, ip, 561205a630d7SDarrick J. Wong whichfork, &lastx, &cur, &del, 561305a630d7SDarrick J. Wong firstblock, dfops, &logflags); 561430f712c9SDave Chinner if (error) 561530f712c9SDave Chinner goto error0; 561630f712c9SDave Chinner goto nodelete; 561730f712c9SDave Chinner } 561830f712c9SDave Chinner if (isrt && (mod = do_mod(del.br_startblock, mp->m_sb.sb_rextsize))) { 561930f712c9SDave Chinner /* 562030f712c9SDave Chinner * Realtime extent is lined up at the end but not 562130f712c9SDave Chinner * at the front. We'll get rid of full extents if 562230f712c9SDave Chinner * we can. 562330f712c9SDave Chinner */ 562430f712c9SDave Chinner mod = mp->m_sb.sb_rextsize - mod; 562530f712c9SDave Chinner if (del.br_blockcount > mod) { 562630f712c9SDave Chinner del.br_blockcount -= mod; 562730f712c9SDave Chinner del.br_startoff += mod; 562830f712c9SDave Chinner del.br_startblock += mod; 562930f712c9SDave Chinner } else if ((del.br_startoff == start && 563030f712c9SDave Chinner (del.br_state == XFS_EXT_UNWRITTEN || 5631a7e5d03bSChristoph Hellwig tp->t_blk_res == 0)) || 563230f712c9SDave Chinner !xfs_sb_version_hasextflgbit(&mp->m_sb)) { 563330f712c9SDave Chinner /* 563430f712c9SDave Chinner * Can't make it unwritten. There isn't 563530f712c9SDave Chinner * a full extent here so just skip it. 563630f712c9SDave Chinner */ 563730f712c9SDave Chinner ASSERT(bno >= del.br_blockcount); 563830f712c9SDave Chinner bno -= del.br_blockcount; 56397efc7945SChristoph Hellwig if (got.br_startoff > bno && --lastx >= 0) 56407efc7945SChristoph Hellwig xfs_iext_get_extent(ifp, lastx, &got); 564130f712c9SDave Chinner continue; 564230f712c9SDave Chinner } else if (del.br_state == XFS_EXT_UNWRITTEN) { 56437efc7945SChristoph Hellwig struct xfs_bmbt_irec prev; 56447efc7945SChristoph Hellwig 564530f712c9SDave Chinner /* 564630f712c9SDave Chinner * This one is already unwritten. 564730f712c9SDave Chinner * It must have a written left neighbor. 564830f712c9SDave Chinner * Unwrite the killed part of that one and 564930f712c9SDave Chinner * try again. 565030f712c9SDave Chinner */ 565130f712c9SDave Chinner ASSERT(lastx > 0); 56527efc7945SChristoph Hellwig xfs_iext_get_extent(ifp, lastx - 1, &prev); 565330f712c9SDave Chinner ASSERT(prev.br_state == XFS_EXT_NORM); 565430f712c9SDave Chinner ASSERT(!isnullstartblock(prev.br_startblock)); 565530f712c9SDave Chinner ASSERT(del.br_startblock == 565630f712c9SDave Chinner prev.br_startblock + prev.br_blockcount); 565730f712c9SDave Chinner if (prev.br_startoff < start) { 565830f712c9SDave Chinner mod = start - prev.br_startoff; 565930f712c9SDave Chinner prev.br_blockcount -= mod; 566030f712c9SDave Chinner prev.br_startblock += mod; 566130f712c9SDave Chinner prev.br_startoff = start; 566230f712c9SDave Chinner } 566330f712c9SDave Chinner prev.br_state = XFS_EXT_UNWRITTEN; 566430f712c9SDave Chinner lastx--; 566530f712c9SDave Chinner error = xfs_bmap_add_extent_unwritten_real(tp, 566605a630d7SDarrick J. Wong ip, whichfork, &lastx, &cur, 566705a630d7SDarrick J. Wong &prev, firstblock, dfops, 566805a630d7SDarrick J. Wong &logflags); 566930f712c9SDave Chinner if (error) 567030f712c9SDave Chinner goto error0; 567130f712c9SDave Chinner goto nodelete; 567230f712c9SDave Chinner } else { 567330f712c9SDave Chinner ASSERT(del.br_state == XFS_EXT_NORM); 567430f712c9SDave Chinner del.br_state = XFS_EXT_UNWRITTEN; 567530f712c9SDave Chinner error = xfs_bmap_add_extent_unwritten_real(tp, 567605a630d7SDarrick J. Wong ip, whichfork, &lastx, &cur, 567705a630d7SDarrick J. Wong &del, firstblock, dfops, 567805a630d7SDarrick J. Wong &logflags); 567930f712c9SDave Chinner if (error) 568030f712c9SDave Chinner goto error0; 568130f712c9SDave Chinner goto nodelete; 568230f712c9SDave Chinner } 568330f712c9SDave Chinner } 568430f712c9SDave Chinner 568530f712c9SDave Chinner /* 568630f712c9SDave Chinner * If it's the case where the directory code is running 568730f712c9SDave Chinner * with no block reservation, and the deleted block is in 568830f712c9SDave Chinner * the middle of its extent, and the resulting insert 568930f712c9SDave Chinner * of an extent would cause transformation to btree format, 569030f712c9SDave Chinner * then reject it. The calling code will then swap 569130f712c9SDave Chinner * blocks around instead. 569230f712c9SDave Chinner * We have to do this now, rather than waiting for the 569330f712c9SDave Chinner * conversion to btree format, since the transaction 569430f712c9SDave Chinner * will be dirty. 569530f712c9SDave Chinner */ 5696a7e5d03bSChristoph Hellwig if (!wasdel && tp->t_blk_res == 0 && 569730f712c9SDave Chinner XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_EXTENTS && 569830f712c9SDave Chinner XFS_IFORK_NEXTENTS(ip, whichfork) >= /* Note the >= */ 569930f712c9SDave Chinner XFS_IFORK_MAXEXT(ip, whichfork) && 570030f712c9SDave Chinner del.br_startoff > got.br_startoff && 570130f712c9SDave Chinner del.br_startoff + del.br_blockcount < 570230f712c9SDave Chinner got.br_startoff + got.br_blockcount) { 57032451337dSDave Chinner error = -ENOSPC; 570430f712c9SDave Chinner goto error0; 570530f712c9SDave Chinner } 5706b2706a05SBrian Foster 5707b2706a05SBrian Foster /* 5708b2706a05SBrian Foster * Unreserve quota and update realtime free space, if 5709b2706a05SBrian Foster * appropriate. If delayed allocation, update the inode delalloc 5710b2706a05SBrian Foster * counter now and wait to update the sb counters as 5711b2706a05SBrian Foster * xfs_bmap_del_extent() might need to borrow some blocks. 5712b2706a05SBrian Foster */ 5713b2706a05SBrian Foster if (wasdel) { 5714b2706a05SBrian Foster ASSERT(startblockval(del.br_startblock) > 0); 5715b2706a05SBrian Foster if (isrt) { 5716b2706a05SBrian Foster xfs_filblks_t rtexts; 5717b2706a05SBrian Foster 5718b2706a05SBrian Foster rtexts = XFS_FSB_TO_B(mp, del.br_blockcount); 5719b2706a05SBrian Foster do_div(rtexts, mp->m_sb.sb_rextsize); 5720b2706a05SBrian Foster xfs_mod_frextents(mp, (int64_t)rtexts); 5721b2706a05SBrian Foster (void)xfs_trans_reserve_quota_nblks(NULL, 5722b2706a05SBrian Foster ip, -((long)del.br_blockcount), 0, 5723b2706a05SBrian Foster XFS_QMOPT_RES_RTBLKS); 5724b2706a05SBrian Foster } else { 5725b2706a05SBrian Foster (void)xfs_trans_reserve_quota_nblks(NULL, 5726b2706a05SBrian Foster ip, -((long)del.br_blockcount), 0, 5727b2706a05SBrian Foster XFS_QMOPT_RES_REGBLKS); 5728b2706a05SBrian Foster } 5729b2706a05SBrian Foster ip->i_delayed_blks -= del.br_blockcount; 5730b2706a05SBrian Foster if (cur) 5731b2706a05SBrian Foster cur->bc_private.b.flags |= 5732b2706a05SBrian Foster XFS_BTCUR_BPRV_WASDEL; 5733b2706a05SBrian Foster } else if (cur) 5734b2706a05SBrian Foster cur->bc_private.b.flags &= ~XFS_BTCUR_BPRV_WASDEL; 5735b2706a05SBrian Foster 57362c3234d1SDarrick J. Wong error = xfs_bmap_del_extent(ip, tp, &lastx, dfops, cur, &del, 57374847acf8SDarrick J. Wong &tmp_logflags, whichfork, flags); 573830f712c9SDave Chinner logflags |= tmp_logflags; 573930f712c9SDave Chinner if (error) 574030f712c9SDave Chinner goto error0; 5741b2706a05SBrian Foster 5742b2706a05SBrian Foster if (!isrt && wasdel) 5743b2706a05SBrian Foster xfs_mod_fdblocks(mp, (int64_t)del.br_blockcount, false); 5744b2706a05SBrian Foster 5745e1a4e37cSDarrick J. Wong max_len -= del.br_blockcount; 574630f712c9SDave Chinner bno = del.br_startoff - 1; 574730f712c9SDave Chinner nodelete: 574830f712c9SDave Chinner /* 574930f712c9SDave Chinner * If not done go on to the next (previous) record. 575030f712c9SDave Chinner */ 575130f712c9SDave Chinner if (bno != (xfs_fileoff_t)-1 && bno >= start) { 575230f712c9SDave Chinner if (lastx >= 0) { 57537efc7945SChristoph Hellwig xfs_iext_get_extent(ifp, lastx, &got); 57547efc7945SChristoph Hellwig if (got.br_startoff > bno && --lastx >= 0) 57557efc7945SChristoph Hellwig xfs_iext_get_extent(ifp, lastx, &got); 575630f712c9SDave Chinner } 575730f712c9SDave Chinner extno++; 575830f712c9SDave Chinner } 575930f712c9SDave Chinner } 57604453593bSDarrick J. Wong if (bno == (xfs_fileoff_t)-1 || bno < start || lastx < 0) 57614453593bSDarrick J. Wong *rlen = 0; 57624453593bSDarrick J. Wong else 57634453593bSDarrick J. Wong *rlen = bno - start + 1; 576430f712c9SDave Chinner 576530f712c9SDave Chinner /* 576630f712c9SDave Chinner * Convert to a btree if necessary. 576730f712c9SDave Chinner */ 576830f712c9SDave Chinner if (xfs_bmap_needs_btree(ip, whichfork)) { 576930f712c9SDave Chinner ASSERT(cur == NULL); 57702c3234d1SDarrick J. Wong error = xfs_bmap_extents_to_btree(tp, ip, firstblock, dfops, 577130f712c9SDave Chinner &cur, 0, &tmp_logflags, whichfork); 577230f712c9SDave Chinner logflags |= tmp_logflags; 577330f712c9SDave Chinner if (error) 577430f712c9SDave Chinner goto error0; 577530f712c9SDave Chinner } 577630f712c9SDave Chinner /* 577730f712c9SDave Chinner * transform from btree to extents, give it cur 577830f712c9SDave Chinner */ 577930f712c9SDave Chinner else if (xfs_bmap_wants_extents(ip, whichfork)) { 578030f712c9SDave Chinner ASSERT(cur != NULL); 578130f712c9SDave Chinner error = xfs_bmap_btree_to_extents(tp, ip, cur, &tmp_logflags, 578230f712c9SDave Chinner whichfork); 578330f712c9SDave Chinner logflags |= tmp_logflags; 578430f712c9SDave Chinner if (error) 578530f712c9SDave Chinner goto error0; 578630f712c9SDave Chinner } 578730f712c9SDave Chinner /* 578830f712c9SDave Chinner * transform from extents to local? 578930f712c9SDave Chinner */ 579030f712c9SDave Chinner error = 0; 579130f712c9SDave Chinner error0: 579230f712c9SDave Chinner /* 579330f712c9SDave Chinner * Log everything. Do this after conversion, there's no point in 579430f712c9SDave Chinner * logging the extent records if we've converted to btree format. 579530f712c9SDave Chinner */ 579630f712c9SDave Chinner if ((logflags & xfs_ilog_fext(whichfork)) && 579730f712c9SDave Chinner XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS) 579830f712c9SDave Chinner logflags &= ~xfs_ilog_fext(whichfork); 579930f712c9SDave Chinner else if ((logflags & xfs_ilog_fbroot(whichfork)) && 580030f712c9SDave Chinner XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE) 580130f712c9SDave Chinner logflags &= ~xfs_ilog_fbroot(whichfork); 580230f712c9SDave Chinner /* 580330f712c9SDave Chinner * Log inode even in the error case, if the transaction 580430f712c9SDave Chinner * is dirty we'll need to shut down the filesystem. 580530f712c9SDave Chinner */ 580630f712c9SDave Chinner if (logflags) 580730f712c9SDave Chinner xfs_trans_log_inode(tp, ip, logflags); 580830f712c9SDave Chinner if (cur) { 580930f712c9SDave Chinner if (!error) { 581030f712c9SDave Chinner *firstblock = cur->bc_private.b.firstblock; 581130f712c9SDave Chinner cur->bc_private.b.allocated = 0; 581230f712c9SDave Chinner } 581330f712c9SDave Chinner xfs_btree_del_cursor(cur, 581430f712c9SDave Chinner error ? XFS_BTREE_ERROR : XFS_BTREE_NOERROR); 581530f712c9SDave Chinner } 581630f712c9SDave Chinner return error; 581730f712c9SDave Chinner } 581830f712c9SDave Chinner 58194453593bSDarrick J. Wong /* Unmap a range of a file. */ 58204453593bSDarrick J. Wong int 58214453593bSDarrick J. Wong xfs_bunmapi( 58224453593bSDarrick J. Wong xfs_trans_t *tp, 58234453593bSDarrick J. Wong struct xfs_inode *ip, 58244453593bSDarrick J. Wong xfs_fileoff_t bno, 58254453593bSDarrick J. Wong xfs_filblks_t len, 58264453593bSDarrick J. Wong int flags, 58274453593bSDarrick J. Wong xfs_extnum_t nexts, 58284453593bSDarrick J. Wong xfs_fsblock_t *firstblock, 58294453593bSDarrick J. Wong struct xfs_defer_ops *dfops, 58304453593bSDarrick J. Wong int *done) 58314453593bSDarrick J. Wong { 58324453593bSDarrick J. Wong int error; 58334453593bSDarrick J. Wong 58344453593bSDarrick J. Wong error = __xfs_bunmapi(tp, ip, bno, &len, flags, nexts, firstblock, 58354453593bSDarrick J. Wong dfops); 58364453593bSDarrick J. Wong *done = (len == 0); 58374453593bSDarrick J. Wong return error; 58384453593bSDarrick J. Wong } 58394453593bSDarrick J. Wong 584030f712c9SDave Chinner /* 5841ddb19e31SBrian Foster * Determine whether an extent shift can be accomplished by a merge with the 5842ddb19e31SBrian Foster * extent that precedes the target hole of the shift. 5843ddb19e31SBrian Foster */ 5844ddb19e31SBrian Foster STATIC bool 5845ddb19e31SBrian Foster xfs_bmse_can_merge( 5846ddb19e31SBrian Foster struct xfs_bmbt_irec *left, /* preceding extent */ 5847ddb19e31SBrian Foster struct xfs_bmbt_irec *got, /* current extent to shift */ 5848ddb19e31SBrian Foster xfs_fileoff_t shift) /* shift fsb */ 5849ddb19e31SBrian Foster { 5850ddb19e31SBrian Foster xfs_fileoff_t startoff; 5851ddb19e31SBrian Foster 5852ddb19e31SBrian Foster startoff = got->br_startoff - shift; 5853ddb19e31SBrian Foster 5854ddb19e31SBrian Foster /* 5855ddb19e31SBrian Foster * The extent, once shifted, must be adjacent in-file and on-disk with 5856ddb19e31SBrian Foster * the preceding extent. 5857ddb19e31SBrian Foster */ 5858ddb19e31SBrian Foster if ((left->br_startoff + left->br_blockcount != startoff) || 5859ddb19e31SBrian Foster (left->br_startblock + left->br_blockcount != got->br_startblock) || 5860ddb19e31SBrian Foster (left->br_state != got->br_state) || 5861ddb19e31SBrian Foster (left->br_blockcount + got->br_blockcount > MAXEXTLEN)) 5862ddb19e31SBrian Foster return false; 5863ddb19e31SBrian Foster 5864ddb19e31SBrian Foster return true; 5865ddb19e31SBrian Foster } 5866ddb19e31SBrian Foster 5867ddb19e31SBrian Foster /* 5868ddb19e31SBrian Foster * A bmap extent shift adjusts the file offset of an extent to fill a preceding 5869ddb19e31SBrian Foster * hole in the file. If an extent shift would result in the extent being fully 5870ddb19e31SBrian Foster * adjacent to the extent that currently precedes the hole, we can merge with 5871ddb19e31SBrian Foster * the preceding extent rather than do the shift. 5872ddb19e31SBrian Foster * 5873ddb19e31SBrian Foster * This function assumes the caller has verified a shift-by-merge is possible 5874ddb19e31SBrian Foster * with the provided extents via xfs_bmse_can_merge(). 5875ddb19e31SBrian Foster */ 5876ddb19e31SBrian Foster STATIC int 5877ddb19e31SBrian Foster xfs_bmse_merge( 5878ddb19e31SBrian Foster struct xfs_inode *ip, 5879ddb19e31SBrian Foster int whichfork, 5880ddb19e31SBrian Foster xfs_fileoff_t shift, /* shift fsb */ 5881ddb19e31SBrian Foster int current_ext, /* idx of gotp */ 58824da6b514SChristoph Hellwig struct xfs_bmbt_irec *got, /* extent to shift */ 58834da6b514SChristoph Hellwig struct xfs_bmbt_irec *left, /* preceding extent */ 5884ddb19e31SBrian Foster struct xfs_btree_cur *cur, 58854da6b514SChristoph Hellwig int *logflags, /* output */ 58864da6b514SChristoph Hellwig struct xfs_defer_ops *dfops) 5887ddb19e31SBrian Foster { 58884da6b514SChristoph Hellwig struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, whichfork); 58894da6b514SChristoph Hellwig struct xfs_bmbt_irec new; 5890ddb19e31SBrian Foster xfs_filblks_t blockcount; 5891ddb19e31SBrian Foster int error, i; 58925fb5aeeeSEric Sandeen struct xfs_mount *mp = ip->i_mount; 5893ddb19e31SBrian Foster 58944da6b514SChristoph Hellwig blockcount = left->br_blockcount + got->br_blockcount; 5895ddb19e31SBrian Foster 5896ddb19e31SBrian Foster ASSERT(xfs_isilocked(ip, XFS_IOLOCK_EXCL)); 5897ddb19e31SBrian Foster ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL)); 58984da6b514SChristoph Hellwig ASSERT(xfs_bmse_can_merge(left, got, shift)); 5899ddb19e31SBrian Foster 59004da6b514SChristoph Hellwig new = *left; 59014da6b514SChristoph Hellwig new.br_blockcount = blockcount; 5902ddb19e31SBrian Foster 5903ddb19e31SBrian Foster /* 5904ddb19e31SBrian Foster * Update the on-disk extent count, the btree if necessary and log the 5905ddb19e31SBrian Foster * inode. 5906ddb19e31SBrian Foster */ 5907ddb19e31SBrian Foster XFS_IFORK_NEXT_SET(ip, whichfork, 5908ddb19e31SBrian Foster XFS_IFORK_NEXTENTS(ip, whichfork) - 1); 5909ddb19e31SBrian Foster *logflags |= XFS_ILOG_CORE; 5910ddb19e31SBrian Foster if (!cur) { 5911ddb19e31SBrian Foster *logflags |= XFS_ILOG_DEXT; 59124da6b514SChristoph Hellwig goto done; 5913ddb19e31SBrian Foster } 5914ddb19e31SBrian Foster 5915ddb19e31SBrian Foster /* lookup and remove the extent to merge */ 59164da6b514SChristoph Hellwig error = xfs_bmbt_lookup_eq(cur, got->br_startoff, got->br_startblock, 59174da6b514SChristoph Hellwig got->br_blockcount, &i); 5918ddb19e31SBrian Foster if (error) 59194db431f5SDave Chinner return error; 59205fb5aeeeSEric Sandeen XFS_WANT_CORRUPTED_RETURN(mp, i == 1); 5921ddb19e31SBrian Foster 5922ddb19e31SBrian Foster error = xfs_btree_delete(cur, &i); 5923ddb19e31SBrian Foster if (error) 59244db431f5SDave Chinner return error; 59255fb5aeeeSEric Sandeen XFS_WANT_CORRUPTED_RETURN(mp, i == 1); 5926ddb19e31SBrian Foster 5927ddb19e31SBrian Foster /* lookup and update size of the previous extent */ 59284da6b514SChristoph Hellwig error = xfs_bmbt_lookup_eq(cur, left->br_startoff, left->br_startblock, 59294da6b514SChristoph Hellwig left->br_blockcount, &i); 5930ddb19e31SBrian Foster if (error) 59314db431f5SDave Chinner return error; 59325fb5aeeeSEric Sandeen XFS_WANT_CORRUPTED_RETURN(mp, i == 1); 5933ddb19e31SBrian Foster 59344da6b514SChristoph Hellwig error = xfs_bmbt_update(cur, new.br_startoff, new.br_startblock, 59354da6b514SChristoph Hellwig new.br_blockcount, new.br_state); 59364da6b514SChristoph Hellwig if (error) 59374da6b514SChristoph Hellwig return error; 5938ddb19e31SBrian Foster 59394da6b514SChristoph Hellwig done: 59404da6b514SChristoph Hellwig xfs_iext_update_extent(ifp, current_ext - 1, &new); 59414da6b514SChristoph Hellwig xfs_iext_remove(ip, current_ext, 1, 0); 59424da6b514SChristoph Hellwig 59434cc1ee5eSDarrick J. Wong /* update reverse mapping. rmap functions merge the rmaps for us */ 59444da6b514SChristoph Hellwig error = xfs_rmap_unmap_extent(mp, dfops, ip, whichfork, got); 59454da6b514SChristoph Hellwig if (error) 59464da6b514SChristoph Hellwig return error; 59474cc1ee5eSDarrick J. Wong memcpy(&new, got, sizeof(new)); 59484cc1ee5eSDarrick J. Wong new.br_startoff = left->br_startoff + left->br_blockcount; 59494da6b514SChristoph Hellwig return xfs_rmap_map_extent(mp, dfops, ip, whichfork, &new); 5950ddb19e31SBrian Foster } 5951ddb19e31SBrian Foster 5952ddb19e31SBrian Foster /* 5953a979bdfeSBrian Foster * Shift a single extent. 5954a979bdfeSBrian Foster */ 5955a979bdfeSBrian Foster STATIC int 5956a979bdfeSBrian Foster xfs_bmse_shift_one( 5957a979bdfeSBrian Foster struct xfs_inode *ip, 5958a979bdfeSBrian Foster int whichfork, 5959a979bdfeSBrian Foster xfs_fileoff_t offset_shift_fsb, 5960a979bdfeSBrian Foster int *current_ext, 59614da6b514SChristoph Hellwig struct xfs_bmbt_irec *got, 5962a979bdfeSBrian Foster struct xfs_btree_cur *cur, 5963a904b1caSNamjae Jeon int *logflags, 59649c194644SDarrick J. Wong enum shift_direction direction, 59659c194644SDarrick J. Wong struct xfs_defer_ops *dfops) 5966a979bdfeSBrian Foster { 5967a979bdfeSBrian Foster struct xfs_ifork *ifp; 59685fb5aeeeSEric Sandeen struct xfs_mount *mp; 5969a979bdfeSBrian Foster xfs_fileoff_t startoff; 59704da6b514SChristoph Hellwig struct xfs_bmbt_irec adj_irec, new; 5971a979bdfeSBrian Foster int error; 5972a979bdfeSBrian Foster int i; 5973a904b1caSNamjae Jeon int total_extents; 5974a979bdfeSBrian Foster 59755fb5aeeeSEric Sandeen mp = ip->i_mount; 5976a979bdfeSBrian Foster ifp = XFS_IFORK_PTR(ip, whichfork); 59775d829300SEric Sandeen total_extents = xfs_iext_count(ifp); 5978a979bdfeSBrian Foster 5979f71721d0SBrian Foster /* delalloc extents should be prevented by caller */ 59804da6b514SChristoph Hellwig XFS_WANT_CORRUPTED_RETURN(mp, !isnullstartblock(got->br_startblock)); 5981f71721d0SBrian Foster 5982a904b1caSNamjae Jeon if (direction == SHIFT_LEFT) { 59834da6b514SChristoph Hellwig startoff = got->br_startoff - offset_shift_fsb; 5984a979bdfeSBrian Foster 5985a904b1caSNamjae Jeon /* 5986a904b1caSNamjae Jeon * Check for merge if we've got an extent to the left, 5987a904b1caSNamjae Jeon * otherwise make sure there's enough room at the start 5988a904b1caSNamjae Jeon * of the file for the shift. 5989a904b1caSNamjae Jeon */ 5990a904b1caSNamjae Jeon if (!*current_ext) { 59914da6b514SChristoph Hellwig if (got->br_startoff < offset_shift_fsb) 5992a904b1caSNamjae Jeon return -EINVAL; 5993a904b1caSNamjae Jeon goto update_current_ext; 5994a904b1caSNamjae Jeon } 5995a904b1caSNamjae Jeon 59964da6b514SChristoph Hellwig /* 59974da6b514SChristoph Hellwig * grab the left extent and check for a large enough hole. 59984da6b514SChristoph Hellwig */ 59994da6b514SChristoph Hellwig xfs_iext_get_extent(ifp, *current_ext - 1, &adj_irec); 60004da6b514SChristoph Hellwig if (startoff < adj_irec.br_startoff + adj_irec.br_blockcount) 6001a979bdfeSBrian Foster return -EINVAL; 6002a979bdfeSBrian Foster 6003a979bdfeSBrian Foster /* check whether to merge the extent or shift it down */ 60044da6b514SChristoph Hellwig if (xfs_bmse_can_merge(&adj_irec, got, offset_shift_fsb)) { 60054da6b514SChristoph Hellwig return xfs_bmse_merge(ip, whichfork, offset_shift_fsb, 60064da6b514SChristoph Hellwig *current_ext, got, &adj_irec, 60074da6b514SChristoph Hellwig cur, logflags, dfops); 6008b11bd671SDave Chinner } 6009a904b1caSNamjae Jeon } else { 60104da6b514SChristoph Hellwig startoff = got->br_startoff + offset_shift_fsb; 6011a904b1caSNamjae Jeon /* nothing to move if this is the last extent */ 6012a904b1caSNamjae Jeon if (*current_ext >= (total_extents - 1)) 6013a904b1caSNamjae Jeon goto update_current_ext; 60144da6b514SChristoph Hellwig 6015a904b1caSNamjae Jeon /* 6016a904b1caSNamjae Jeon * If this is not the last extent in the file, make sure there 6017a904b1caSNamjae Jeon * is enough room between current extent and next extent for 6018a904b1caSNamjae Jeon * accommodating the shift. 6019a904b1caSNamjae Jeon */ 60204da6b514SChristoph Hellwig xfs_iext_get_extent(ifp, *current_ext + 1, &adj_irec); 60214da6b514SChristoph Hellwig if (startoff + got->br_blockcount > adj_irec.br_startoff) 6022b11bd671SDave Chinner return -EINVAL; 60234da6b514SChristoph Hellwig 6024a904b1caSNamjae Jeon /* 6025a904b1caSNamjae Jeon * Unlike a left shift (which involves a hole punch), 6026a904b1caSNamjae Jeon * a right shift does not modify extent neighbors 6027a904b1caSNamjae Jeon * in any way. We should never find mergeable extents 6028a904b1caSNamjae Jeon * in this scenario. Check anyways and warn if we 6029a904b1caSNamjae Jeon * encounter two extents that could be one. 6030a904b1caSNamjae Jeon */ 60314da6b514SChristoph Hellwig if (xfs_bmse_can_merge(got, &adj_irec, offset_shift_fsb)) 6032a904b1caSNamjae Jeon WARN_ON_ONCE(1); 6033a904b1caSNamjae Jeon } 60344da6b514SChristoph Hellwig 6035a979bdfeSBrian Foster /* 6036a979bdfeSBrian Foster * Increment the extent index for the next iteration, update the start 6037a979bdfeSBrian Foster * offset of the in-core extent and update the btree if applicable. 6038a979bdfeSBrian Foster */ 6039a904b1caSNamjae Jeon update_current_ext: 6040a979bdfeSBrian Foster *logflags |= XFS_ILOG_CORE; 6041a979bdfeSBrian Foster 60424da6b514SChristoph Hellwig new = *got; 60434da6b514SChristoph Hellwig new.br_startoff = startoff; 60444da6b514SChristoph Hellwig 60454da6b514SChristoph Hellwig if (cur) { 60464da6b514SChristoph Hellwig error = xfs_bmbt_lookup_eq(cur, got->br_startoff, 60474da6b514SChristoph Hellwig got->br_startblock, got->br_blockcount, &i); 6048a979bdfeSBrian Foster if (error) 6049a979bdfeSBrian Foster return error; 60505fb5aeeeSEric Sandeen XFS_WANT_CORRUPTED_RETURN(mp, i == 1); 6051a979bdfeSBrian Foster 60524da6b514SChristoph Hellwig error = xfs_bmbt_update(cur, new.br_startoff, 60534da6b514SChristoph Hellwig new.br_startblock, new.br_blockcount, 60544da6b514SChristoph Hellwig new.br_state); 60559c194644SDarrick J. Wong if (error) 60569c194644SDarrick J. Wong return error; 60574da6b514SChristoph Hellwig } else { 60584da6b514SChristoph Hellwig *logflags |= XFS_ILOG_DEXT; 60594da6b514SChristoph Hellwig } 60609c194644SDarrick J. Wong 60614da6b514SChristoph Hellwig xfs_iext_update_extent(ifp, *current_ext, &new); 60624da6b514SChristoph Hellwig 60634da6b514SChristoph Hellwig if (direction == SHIFT_LEFT) 60644da6b514SChristoph Hellwig (*current_ext)++; 60654da6b514SChristoph Hellwig else 60664da6b514SChristoph Hellwig (*current_ext)--; 60674da6b514SChristoph Hellwig 60689c194644SDarrick J. Wong /* update reverse mapping */ 60694da6b514SChristoph Hellwig error = xfs_rmap_unmap_extent(mp, dfops, ip, whichfork, got); 60709c194644SDarrick J. Wong if (error) 60719c194644SDarrick J. Wong return error; 60724da6b514SChristoph Hellwig return xfs_rmap_map_extent(mp, dfops, ip, whichfork, &new); 6073a979bdfeSBrian Foster } 6074a979bdfeSBrian Foster 6075a979bdfeSBrian Foster /* 6076a904b1caSNamjae Jeon * Shift extent records to the left/right to cover/create a hole. 607730f712c9SDave Chinner * 60782c845f5aSBrian Foster * The maximum number of extents to be shifted in a single operation is 6079a904b1caSNamjae Jeon * @num_exts. @stop_fsb specifies the file offset at which to stop shift and the 60802c845f5aSBrian Foster * file offset where we've left off is returned in @next_fsb. @offset_shift_fsb 60812c845f5aSBrian Foster * is the length by which each extent is shifted. If there is no hole to shift 60822c845f5aSBrian Foster * the extents into, this will be considered invalid operation and we abort 60832c845f5aSBrian Foster * immediately. 608430f712c9SDave Chinner */ 608530f712c9SDave Chinner int 608630f712c9SDave Chinner xfs_bmap_shift_extents( 608730f712c9SDave Chinner struct xfs_trans *tp, 608830f712c9SDave Chinner struct xfs_inode *ip, 6089a904b1caSNamjae Jeon xfs_fileoff_t *next_fsb, 609030f712c9SDave Chinner xfs_fileoff_t offset_shift_fsb, 60912c845f5aSBrian Foster int *done, 6092a904b1caSNamjae Jeon xfs_fileoff_t stop_fsb, 609330f712c9SDave Chinner xfs_fsblock_t *firstblock, 60942c3234d1SDarrick J. Wong struct xfs_defer_ops *dfops, 6095a904b1caSNamjae Jeon enum shift_direction direction, 609630f712c9SDave Chinner int num_exts) 609730f712c9SDave Chinner { 6098ca446d88SBrian Foster struct xfs_btree_cur *cur = NULL; 609930f712c9SDave Chinner struct xfs_bmbt_irec got; 610030f712c9SDave Chinner struct xfs_mount *mp = ip->i_mount; 610130f712c9SDave Chinner struct xfs_ifork *ifp; 610230f712c9SDave Chinner xfs_extnum_t nexts = 0; 61032c845f5aSBrian Foster xfs_extnum_t current_ext; 6104a904b1caSNamjae Jeon xfs_extnum_t total_extents; 6105a904b1caSNamjae Jeon xfs_extnum_t stop_extent; 610630f712c9SDave Chinner int error = 0; 610730f712c9SDave Chinner int whichfork = XFS_DATA_FORK; 6108ca446d88SBrian Foster int logflags = 0; 610930f712c9SDave Chinner 611030f712c9SDave Chinner if (unlikely(XFS_TEST_ERROR( 611130f712c9SDave Chinner (XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS && 611230f712c9SDave Chinner XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE), 61139e24cfd0SDarrick J. Wong mp, XFS_ERRTAG_BMAPIFORMAT))) { 611430f712c9SDave Chinner XFS_ERROR_REPORT("xfs_bmap_shift_extents", 611530f712c9SDave Chinner XFS_ERRLEVEL_LOW, mp); 61162451337dSDave Chinner return -EFSCORRUPTED; 611730f712c9SDave Chinner } 611830f712c9SDave Chinner 611930f712c9SDave Chinner if (XFS_FORCED_SHUTDOWN(mp)) 61202451337dSDave Chinner return -EIO; 612130f712c9SDave Chinner 61222c845f5aSBrian Foster ASSERT(xfs_isilocked(ip, XFS_IOLOCK_EXCL)); 61232c845f5aSBrian Foster ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL)); 6124a904b1caSNamjae Jeon ASSERT(direction == SHIFT_LEFT || direction == SHIFT_RIGHT); 612530f712c9SDave Chinner 612630f712c9SDave Chinner ifp = XFS_IFORK_PTR(ip, whichfork); 612730f712c9SDave Chinner if (!(ifp->if_flags & XFS_IFEXTENTS)) { 612830f712c9SDave Chinner /* Read in all the extents */ 612930f712c9SDave Chinner error = xfs_iread_extents(tp, ip, whichfork); 613030f712c9SDave Chinner if (error) 613130f712c9SDave Chinner return error; 613230f712c9SDave Chinner } 613330f712c9SDave Chinner 6134ddb19e31SBrian Foster if (ifp->if_flags & XFS_IFBROOT) { 6135ddb19e31SBrian Foster cur = xfs_bmbt_init_cursor(mp, tp, ip, whichfork); 6136ddb19e31SBrian Foster cur->bc_private.b.firstblock = *firstblock; 61372c3234d1SDarrick J. Wong cur->bc_private.b.dfops = dfops; 6138ddb19e31SBrian Foster cur->bc_private.b.flags = 0; 6139ddb19e31SBrian Foster } 6140ddb19e31SBrian Foster 614130f712c9SDave Chinner /* 614230f712c9SDave Chinner * There may be delalloc extents in the data fork before the range we 61432c845f5aSBrian Foster * are collapsing out, so we cannot use the count of real extents here. 61442c845f5aSBrian Foster * Instead we have to calculate it from the incore fork. 614530f712c9SDave Chinner */ 61465d829300SEric Sandeen total_extents = xfs_iext_count(ifp); 6147a904b1caSNamjae Jeon if (total_extents == 0) { 6148a904b1caSNamjae Jeon *done = 1; 6149a904b1caSNamjae Jeon goto del_cursor; 6150a904b1caSNamjae Jeon } 6151a904b1caSNamjae Jeon 6152a904b1caSNamjae Jeon /* 6153a904b1caSNamjae Jeon * In case of first right shift, we need to initialize next_fsb 6154a904b1caSNamjae Jeon */ 6155a904b1caSNamjae Jeon if (*next_fsb == NULLFSBLOCK) { 615605b7c8abSChristoph Hellwig ASSERT(direction == SHIFT_RIGHT); 615705b7c8abSChristoph Hellwig 615805b7c8abSChristoph Hellwig current_ext = total_extents - 1; 61594da6b514SChristoph Hellwig xfs_iext_get_extent(ifp, current_ext, &got); 61604da6b514SChristoph Hellwig if (stop_fsb > got.br_startoff) { 6161a904b1caSNamjae Jeon *done = 1; 6162a904b1caSNamjae Jeon goto del_cursor; 6163a904b1caSNamjae Jeon } 61644da6b514SChristoph Hellwig *next_fsb = got.br_startoff; 616505b7c8abSChristoph Hellwig } else { 6166a904b1caSNamjae Jeon /* 6167a904b1caSNamjae Jeon * Look up the extent index for the fsb where we start shifting. We can 6168a904b1caSNamjae Jeon * henceforth iterate with current_ext as extent list changes are locked 6169a904b1caSNamjae Jeon * out via ilock. 6170a904b1caSNamjae Jeon * 61714da6b514SChristoph Hellwig * If next_fsb lies in a hole beyond which there are no extents we are 61724da6b514SChristoph Hellwig * done. 6173a904b1caSNamjae Jeon */ 61744da6b514SChristoph Hellwig if (!xfs_iext_lookup_extent(ip, ifp, *next_fsb, ¤t_ext, 61754da6b514SChristoph Hellwig &got)) { 6176a904b1caSNamjae Jeon *done = 1; 6177a904b1caSNamjae Jeon goto del_cursor; 6178a904b1caSNamjae Jeon } 617905b7c8abSChristoph Hellwig } 6180a904b1caSNamjae Jeon 618105b7c8abSChristoph Hellwig /* Lookup the extent index at which we have to stop */ 618205b7c8abSChristoph Hellwig if (direction == SHIFT_RIGHT) { 61834da6b514SChristoph Hellwig struct xfs_bmbt_irec s; 61844da6b514SChristoph Hellwig 61854da6b514SChristoph Hellwig xfs_iext_lookup_extent(ip, ifp, stop_fsb, &stop_extent, &s); 618605b7c8abSChristoph Hellwig /* Make stop_extent exclusive of shift range */ 618705b7c8abSChristoph Hellwig stop_extent--; 618805b7c8abSChristoph Hellwig if (current_ext <= stop_extent) { 6189a904b1caSNamjae Jeon error = -EIO; 6190a904b1caSNamjae Jeon goto del_cursor; 6191a904b1caSNamjae Jeon } 619205b7c8abSChristoph Hellwig } else { 619305b7c8abSChristoph Hellwig stop_extent = total_extents; 619405b7c8abSChristoph Hellwig if (current_ext >= stop_extent) { 619505b7c8abSChristoph Hellwig error = -EIO; 619605b7c8abSChristoph Hellwig goto del_cursor; 619705b7c8abSChristoph Hellwig } 619805b7c8abSChristoph Hellwig } 6199a904b1caSNamjae Jeon 6200a904b1caSNamjae Jeon while (nexts++ < num_exts) { 6201a979bdfeSBrian Foster error = xfs_bmse_shift_one(ip, whichfork, offset_shift_fsb, 62024da6b514SChristoph Hellwig ¤t_ext, &got, cur, &logflags, 62039c194644SDarrick J. Wong direction, dfops); 6204ddb19e31SBrian Foster if (error) 6205ddb19e31SBrian Foster goto del_cursor; 6206a904b1caSNamjae Jeon /* 6207a904b1caSNamjae Jeon * If there was an extent merge during the shift, the extent 6208a904b1caSNamjae Jeon * count can change. Update the total and grade the next record. 6209a904b1caSNamjae Jeon */ 6210a904b1caSNamjae Jeon if (direction == SHIFT_LEFT) { 62115d829300SEric Sandeen total_extents = xfs_iext_count(ifp); 6212a904b1caSNamjae Jeon stop_extent = total_extents; 6213a904b1caSNamjae Jeon } 6214a904b1caSNamjae Jeon 6215a904b1caSNamjae Jeon if (current_ext == stop_extent) { 6216a904b1caSNamjae Jeon *done = 1; 6217a904b1caSNamjae Jeon *next_fsb = NULLFSBLOCK; 6218ddb19e31SBrian Foster break; 6219a904b1caSNamjae Jeon } 62204da6b514SChristoph Hellwig xfs_iext_get_extent(ifp, current_ext, &got); 622130f712c9SDave Chinner } 622230f712c9SDave Chinner 62234da6b514SChristoph Hellwig if (!*done) 62242c845f5aSBrian Foster *next_fsb = got.br_startoff; 622530f712c9SDave Chinner 622630f712c9SDave Chinner del_cursor: 622730f712c9SDave Chinner if (cur) 622830f712c9SDave Chinner xfs_btree_del_cursor(cur, 622930f712c9SDave Chinner error ? XFS_BTREE_ERROR : XFS_BTREE_NOERROR); 623030f712c9SDave Chinner 6231ca446d88SBrian Foster if (logflags) 623230f712c9SDave Chinner xfs_trans_log_inode(tp, ip, logflags); 62332c845f5aSBrian Foster 623430f712c9SDave Chinner return error; 623530f712c9SDave Chinner } 6236a904b1caSNamjae Jeon 6237a904b1caSNamjae Jeon /* 6238a904b1caSNamjae Jeon * Splits an extent into two extents at split_fsb block such that it is 6239a904b1caSNamjae Jeon * the first block of the current_ext. @current_ext is a target extent 6240a904b1caSNamjae Jeon * to be split. @split_fsb is a block where the extents is split. 6241a904b1caSNamjae Jeon * If split_fsb lies in a hole or the first block of extents, just return 0. 6242a904b1caSNamjae Jeon */ 6243a904b1caSNamjae Jeon STATIC int 6244a904b1caSNamjae Jeon xfs_bmap_split_extent_at( 6245a904b1caSNamjae Jeon struct xfs_trans *tp, 6246a904b1caSNamjae Jeon struct xfs_inode *ip, 6247a904b1caSNamjae Jeon xfs_fileoff_t split_fsb, 6248a904b1caSNamjae Jeon xfs_fsblock_t *firstfsb, 62492c3234d1SDarrick J. Wong struct xfs_defer_ops *dfops) 6250a904b1caSNamjae Jeon { 6251a904b1caSNamjae Jeon int whichfork = XFS_DATA_FORK; 6252a904b1caSNamjae Jeon struct xfs_btree_cur *cur = NULL; 6253a904b1caSNamjae Jeon struct xfs_bmbt_irec got; 6254a904b1caSNamjae Jeon struct xfs_bmbt_irec new; /* split extent */ 6255a904b1caSNamjae Jeon struct xfs_mount *mp = ip->i_mount; 6256a904b1caSNamjae Jeon struct xfs_ifork *ifp; 6257a904b1caSNamjae Jeon xfs_fsblock_t gotblkcnt; /* new block count for got */ 6258a904b1caSNamjae Jeon xfs_extnum_t current_ext; 6259a904b1caSNamjae Jeon int error = 0; 6260a904b1caSNamjae Jeon int logflags = 0; 6261a904b1caSNamjae Jeon int i = 0; 6262a904b1caSNamjae Jeon 6263a904b1caSNamjae Jeon if (unlikely(XFS_TEST_ERROR( 6264a904b1caSNamjae Jeon (XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS && 6265a904b1caSNamjae Jeon XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE), 62669e24cfd0SDarrick J. Wong mp, XFS_ERRTAG_BMAPIFORMAT))) { 6267a904b1caSNamjae Jeon XFS_ERROR_REPORT("xfs_bmap_split_extent_at", 6268a904b1caSNamjae Jeon XFS_ERRLEVEL_LOW, mp); 6269a904b1caSNamjae Jeon return -EFSCORRUPTED; 6270a904b1caSNamjae Jeon } 6271a904b1caSNamjae Jeon 6272a904b1caSNamjae Jeon if (XFS_FORCED_SHUTDOWN(mp)) 6273a904b1caSNamjae Jeon return -EIO; 6274a904b1caSNamjae Jeon 6275a904b1caSNamjae Jeon ifp = XFS_IFORK_PTR(ip, whichfork); 6276a904b1caSNamjae Jeon if (!(ifp->if_flags & XFS_IFEXTENTS)) { 6277a904b1caSNamjae Jeon /* Read in all the extents */ 6278a904b1caSNamjae Jeon error = xfs_iread_extents(tp, ip, whichfork); 6279a904b1caSNamjae Jeon if (error) 6280a904b1caSNamjae Jeon return error; 6281a904b1caSNamjae Jeon } 6282a904b1caSNamjae Jeon 6283a904b1caSNamjae Jeon /* 62844c35445bSChristoph Hellwig * If there are not extents, or split_fsb lies in a hole we are done. 6285a904b1caSNamjae Jeon */ 62864c35445bSChristoph Hellwig if (!xfs_iext_lookup_extent(ip, ifp, split_fsb, ¤t_ext, &got) || 62874c35445bSChristoph Hellwig got.br_startoff >= split_fsb) 6288a904b1caSNamjae Jeon return 0; 6289a904b1caSNamjae Jeon 6290a904b1caSNamjae Jeon gotblkcnt = split_fsb - got.br_startoff; 6291a904b1caSNamjae Jeon new.br_startoff = split_fsb; 6292a904b1caSNamjae Jeon new.br_startblock = got.br_startblock + gotblkcnt; 6293a904b1caSNamjae Jeon new.br_blockcount = got.br_blockcount - gotblkcnt; 6294a904b1caSNamjae Jeon new.br_state = got.br_state; 6295a904b1caSNamjae Jeon 6296a904b1caSNamjae Jeon if (ifp->if_flags & XFS_IFBROOT) { 6297a904b1caSNamjae Jeon cur = xfs_bmbt_init_cursor(mp, tp, ip, whichfork); 6298a904b1caSNamjae Jeon cur->bc_private.b.firstblock = *firstfsb; 62992c3234d1SDarrick J. Wong cur->bc_private.b.dfops = dfops; 6300a904b1caSNamjae Jeon cur->bc_private.b.flags = 0; 6301a904b1caSNamjae Jeon error = xfs_bmbt_lookup_eq(cur, got.br_startoff, 6302a904b1caSNamjae Jeon got.br_startblock, 6303a904b1caSNamjae Jeon got.br_blockcount, 6304a904b1caSNamjae Jeon &i); 6305a904b1caSNamjae Jeon if (error) 6306a904b1caSNamjae Jeon goto del_cursor; 6307a904b1caSNamjae Jeon XFS_WANT_CORRUPTED_GOTO(mp, i == 1, del_cursor); 6308a904b1caSNamjae Jeon } 6309a904b1caSNamjae Jeon 6310a904b1caSNamjae Jeon got.br_blockcount = gotblkcnt; 63114c35445bSChristoph Hellwig xfs_iext_update_extent(ifp, current_ext, &got); 6312a904b1caSNamjae Jeon 6313a904b1caSNamjae Jeon logflags = XFS_ILOG_CORE; 6314a904b1caSNamjae Jeon if (cur) { 6315a904b1caSNamjae Jeon error = xfs_bmbt_update(cur, got.br_startoff, 6316a904b1caSNamjae Jeon got.br_startblock, 6317a904b1caSNamjae Jeon got.br_blockcount, 6318a904b1caSNamjae Jeon got.br_state); 6319a904b1caSNamjae Jeon if (error) 6320a904b1caSNamjae Jeon goto del_cursor; 6321a904b1caSNamjae Jeon } else 6322a904b1caSNamjae Jeon logflags |= XFS_ILOG_DEXT; 6323a904b1caSNamjae Jeon 6324a904b1caSNamjae Jeon /* Add new extent */ 6325a904b1caSNamjae Jeon current_ext++; 6326a904b1caSNamjae Jeon xfs_iext_insert(ip, current_ext, 1, &new, 0); 6327a904b1caSNamjae Jeon XFS_IFORK_NEXT_SET(ip, whichfork, 6328a904b1caSNamjae Jeon XFS_IFORK_NEXTENTS(ip, whichfork) + 1); 6329a904b1caSNamjae Jeon 6330a904b1caSNamjae Jeon if (cur) { 6331a904b1caSNamjae Jeon error = xfs_bmbt_lookup_eq(cur, new.br_startoff, 6332a904b1caSNamjae Jeon new.br_startblock, new.br_blockcount, 6333a904b1caSNamjae Jeon &i); 6334a904b1caSNamjae Jeon if (error) 6335a904b1caSNamjae Jeon goto del_cursor; 6336a904b1caSNamjae Jeon XFS_WANT_CORRUPTED_GOTO(mp, i == 0, del_cursor); 6337a904b1caSNamjae Jeon cur->bc_rec.b.br_state = new.br_state; 6338a904b1caSNamjae Jeon 6339a904b1caSNamjae Jeon error = xfs_btree_insert(cur, &i); 6340a904b1caSNamjae Jeon if (error) 6341a904b1caSNamjae Jeon goto del_cursor; 6342a904b1caSNamjae Jeon XFS_WANT_CORRUPTED_GOTO(mp, i == 1, del_cursor); 6343a904b1caSNamjae Jeon } 6344a904b1caSNamjae Jeon 6345a904b1caSNamjae Jeon /* 6346a904b1caSNamjae Jeon * Convert to a btree if necessary. 6347a904b1caSNamjae Jeon */ 6348a904b1caSNamjae Jeon if (xfs_bmap_needs_btree(ip, whichfork)) { 6349a904b1caSNamjae Jeon int tmp_logflags; /* partial log flag return val */ 6350a904b1caSNamjae Jeon 6351a904b1caSNamjae Jeon ASSERT(cur == NULL); 63522c3234d1SDarrick J. Wong error = xfs_bmap_extents_to_btree(tp, ip, firstfsb, dfops, 6353a904b1caSNamjae Jeon &cur, 0, &tmp_logflags, whichfork); 6354a904b1caSNamjae Jeon logflags |= tmp_logflags; 6355a904b1caSNamjae Jeon } 6356a904b1caSNamjae Jeon 6357a904b1caSNamjae Jeon del_cursor: 6358a904b1caSNamjae Jeon if (cur) { 6359a904b1caSNamjae Jeon cur->bc_private.b.allocated = 0; 6360a904b1caSNamjae Jeon xfs_btree_del_cursor(cur, 6361a904b1caSNamjae Jeon error ? XFS_BTREE_ERROR : XFS_BTREE_NOERROR); 6362a904b1caSNamjae Jeon } 6363a904b1caSNamjae Jeon 6364a904b1caSNamjae Jeon if (logflags) 6365a904b1caSNamjae Jeon xfs_trans_log_inode(tp, ip, logflags); 6366a904b1caSNamjae Jeon return error; 6367a904b1caSNamjae Jeon } 6368a904b1caSNamjae Jeon 6369a904b1caSNamjae Jeon int 6370a904b1caSNamjae Jeon xfs_bmap_split_extent( 6371a904b1caSNamjae Jeon struct xfs_inode *ip, 6372a904b1caSNamjae Jeon xfs_fileoff_t split_fsb) 6373a904b1caSNamjae Jeon { 6374a904b1caSNamjae Jeon struct xfs_mount *mp = ip->i_mount; 6375a904b1caSNamjae Jeon struct xfs_trans *tp; 63762c3234d1SDarrick J. Wong struct xfs_defer_ops dfops; 6377a904b1caSNamjae Jeon xfs_fsblock_t firstfsb; 6378a904b1caSNamjae Jeon int error; 6379a904b1caSNamjae Jeon 6380253f4911SChristoph Hellwig error = xfs_trans_alloc(mp, &M_RES(mp)->tr_write, 6381253f4911SChristoph Hellwig XFS_DIOSTRAT_SPACE_RES(mp, 0), 0, 0, &tp); 6382253f4911SChristoph Hellwig if (error) 6383a904b1caSNamjae Jeon return error; 6384a904b1caSNamjae Jeon 6385a904b1caSNamjae Jeon xfs_ilock(ip, XFS_ILOCK_EXCL); 6386a904b1caSNamjae Jeon xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL); 6387a904b1caSNamjae Jeon 63882c3234d1SDarrick J. Wong xfs_defer_init(&dfops, &firstfsb); 6389a904b1caSNamjae Jeon 6390a904b1caSNamjae Jeon error = xfs_bmap_split_extent_at(tp, ip, split_fsb, 63912c3234d1SDarrick J. Wong &firstfsb, &dfops); 6392a904b1caSNamjae Jeon if (error) 6393a904b1caSNamjae Jeon goto out; 6394a904b1caSNamjae Jeon 63958ad7c629SChristoph Hellwig error = xfs_defer_finish(&tp, &dfops); 6396a904b1caSNamjae Jeon if (error) 6397a904b1caSNamjae Jeon goto out; 6398a904b1caSNamjae Jeon 639970393313SChristoph Hellwig return xfs_trans_commit(tp); 6400a904b1caSNamjae Jeon 6401a904b1caSNamjae Jeon out: 64022c3234d1SDarrick J. Wong xfs_defer_cancel(&dfops); 64034906e215SChristoph Hellwig xfs_trans_cancel(tp); 6404a904b1caSNamjae Jeon return error; 6405a904b1caSNamjae Jeon } 64069f3afb57SDarrick J. Wong 64079f3afb57SDarrick J. Wong /* Deferred mapping is only for real extents in the data fork. */ 64089f3afb57SDarrick J. Wong static bool 64099f3afb57SDarrick J. Wong xfs_bmap_is_update_needed( 64109f3afb57SDarrick J. Wong struct xfs_bmbt_irec *bmap) 64119f3afb57SDarrick J. Wong { 64129f3afb57SDarrick J. Wong return bmap->br_startblock != HOLESTARTBLOCK && 64139f3afb57SDarrick J. Wong bmap->br_startblock != DELAYSTARTBLOCK; 64149f3afb57SDarrick J. Wong } 64159f3afb57SDarrick J. Wong 64169f3afb57SDarrick J. Wong /* Record a bmap intent. */ 64179f3afb57SDarrick J. Wong static int 64189f3afb57SDarrick J. Wong __xfs_bmap_add( 64199f3afb57SDarrick J. Wong struct xfs_mount *mp, 64209f3afb57SDarrick J. Wong struct xfs_defer_ops *dfops, 64219f3afb57SDarrick J. Wong enum xfs_bmap_intent_type type, 64229f3afb57SDarrick J. Wong struct xfs_inode *ip, 64239f3afb57SDarrick J. Wong int whichfork, 64249f3afb57SDarrick J. Wong struct xfs_bmbt_irec *bmap) 64259f3afb57SDarrick J. Wong { 64269f3afb57SDarrick J. Wong int error; 64279f3afb57SDarrick J. Wong struct xfs_bmap_intent *bi; 64289f3afb57SDarrick J. Wong 64299f3afb57SDarrick J. Wong trace_xfs_bmap_defer(mp, 64309f3afb57SDarrick J. Wong XFS_FSB_TO_AGNO(mp, bmap->br_startblock), 64319f3afb57SDarrick J. Wong type, 64329f3afb57SDarrick J. Wong XFS_FSB_TO_AGBNO(mp, bmap->br_startblock), 64339f3afb57SDarrick J. Wong ip->i_ino, whichfork, 64349f3afb57SDarrick J. Wong bmap->br_startoff, 64359f3afb57SDarrick J. Wong bmap->br_blockcount, 64369f3afb57SDarrick J. Wong bmap->br_state); 64379f3afb57SDarrick J. Wong 64389f3afb57SDarrick J. Wong bi = kmem_alloc(sizeof(struct xfs_bmap_intent), KM_SLEEP | KM_NOFS); 64399f3afb57SDarrick J. Wong INIT_LIST_HEAD(&bi->bi_list); 64409f3afb57SDarrick J. Wong bi->bi_type = type; 64419f3afb57SDarrick J. Wong bi->bi_owner = ip; 64429f3afb57SDarrick J. Wong bi->bi_whichfork = whichfork; 64439f3afb57SDarrick J. Wong bi->bi_bmap = *bmap; 64449f3afb57SDarrick J. Wong 6445882d8785SChristoph Hellwig error = xfs_defer_ijoin(dfops, bi->bi_owner); 64469f3afb57SDarrick J. Wong if (error) { 64479f3afb57SDarrick J. Wong kmem_free(bi); 64489f3afb57SDarrick J. Wong return error; 64499f3afb57SDarrick J. Wong } 64509f3afb57SDarrick J. Wong 64519f3afb57SDarrick J. Wong xfs_defer_add(dfops, XFS_DEFER_OPS_TYPE_BMAP, &bi->bi_list); 64529f3afb57SDarrick J. Wong return 0; 64539f3afb57SDarrick J. Wong } 64549f3afb57SDarrick J. Wong 64559f3afb57SDarrick J. Wong /* Map an extent into a file. */ 64569f3afb57SDarrick J. Wong int 64579f3afb57SDarrick J. Wong xfs_bmap_map_extent( 64589f3afb57SDarrick J. Wong struct xfs_mount *mp, 64599f3afb57SDarrick J. Wong struct xfs_defer_ops *dfops, 64609f3afb57SDarrick J. Wong struct xfs_inode *ip, 64619f3afb57SDarrick J. Wong struct xfs_bmbt_irec *PREV) 64629f3afb57SDarrick J. Wong { 64639f3afb57SDarrick J. Wong if (!xfs_bmap_is_update_needed(PREV)) 64649f3afb57SDarrick J. Wong return 0; 64659f3afb57SDarrick J. Wong 64669f3afb57SDarrick J. Wong return __xfs_bmap_add(mp, dfops, XFS_BMAP_MAP, ip, 64679f3afb57SDarrick J. Wong XFS_DATA_FORK, PREV); 64689f3afb57SDarrick J. Wong } 64699f3afb57SDarrick J. Wong 64709f3afb57SDarrick J. Wong /* Unmap an extent out of a file. */ 64719f3afb57SDarrick J. Wong int 64729f3afb57SDarrick J. Wong xfs_bmap_unmap_extent( 64739f3afb57SDarrick J. Wong struct xfs_mount *mp, 64749f3afb57SDarrick J. Wong struct xfs_defer_ops *dfops, 64759f3afb57SDarrick J. Wong struct xfs_inode *ip, 64769f3afb57SDarrick J. Wong struct xfs_bmbt_irec *PREV) 64779f3afb57SDarrick J. Wong { 64789f3afb57SDarrick J. Wong if (!xfs_bmap_is_update_needed(PREV)) 64799f3afb57SDarrick J. Wong return 0; 64809f3afb57SDarrick J. Wong 64819f3afb57SDarrick J. Wong return __xfs_bmap_add(mp, dfops, XFS_BMAP_UNMAP, ip, 64829f3afb57SDarrick J. Wong XFS_DATA_FORK, PREV); 64839f3afb57SDarrick J. Wong } 64849f3afb57SDarrick J. Wong 64859f3afb57SDarrick J. Wong /* 64869f3afb57SDarrick J. Wong * Process one of the deferred bmap operations. We pass back the 64879f3afb57SDarrick J. Wong * btree cursor to maintain our lock on the bmapbt between calls. 64889f3afb57SDarrick J. Wong */ 64899f3afb57SDarrick J. Wong int 64909f3afb57SDarrick J. Wong xfs_bmap_finish_one( 64919f3afb57SDarrick J. Wong struct xfs_trans *tp, 64929f3afb57SDarrick J. Wong struct xfs_defer_ops *dfops, 64939f3afb57SDarrick J. Wong struct xfs_inode *ip, 64949f3afb57SDarrick J. Wong enum xfs_bmap_intent_type type, 64959f3afb57SDarrick J. Wong int whichfork, 64969f3afb57SDarrick J. Wong xfs_fileoff_t startoff, 64979f3afb57SDarrick J. Wong xfs_fsblock_t startblock, 6498e1a4e37cSDarrick J. Wong xfs_filblks_t *blockcount, 64999f3afb57SDarrick J. Wong xfs_exntst_t state) 65009f3afb57SDarrick J. Wong { 6501e1a4e37cSDarrick J. Wong xfs_fsblock_t firstfsb; 6502e1a4e37cSDarrick J. Wong int error = 0; 65039f3afb57SDarrick J. Wong 65044c1a67bdSDarrick J. Wong /* 65054c1a67bdSDarrick J. Wong * firstfsb is tied to the transaction lifetime and is used to 65064c1a67bdSDarrick J. Wong * ensure correct AG locking order and schedule work item 65074c1a67bdSDarrick J. Wong * continuations. XFS_BUI_MAX_FAST_EXTENTS (== 1) restricts us 65084c1a67bdSDarrick J. Wong * to only making one bmap call per transaction, so it should 65094c1a67bdSDarrick J. Wong * be safe to have it as a local variable here. 65104c1a67bdSDarrick J. Wong */ 65114c1a67bdSDarrick J. Wong firstfsb = NULLFSBLOCK; 65124c1a67bdSDarrick J. Wong 65139f3afb57SDarrick J. Wong trace_xfs_bmap_deferred(tp->t_mountp, 65149f3afb57SDarrick J. Wong XFS_FSB_TO_AGNO(tp->t_mountp, startblock), type, 65159f3afb57SDarrick J. Wong XFS_FSB_TO_AGBNO(tp->t_mountp, startblock), 6516e1a4e37cSDarrick J. Wong ip->i_ino, whichfork, startoff, *blockcount, state); 65179f3afb57SDarrick J. Wong 651839e07daaSChristoph Hellwig if (WARN_ON_ONCE(whichfork != XFS_DATA_FORK)) 65199f3afb57SDarrick J. Wong return -EFSCORRUPTED; 65209f3afb57SDarrick J. Wong 65219f3afb57SDarrick J. Wong if (XFS_TEST_ERROR(false, tp->t_mountp, 65229e24cfd0SDarrick J. Wong XFS_ERRTAG_BMAP_FINISH_ONE)) 65239f3afb57SDarrick J. Wong return -EIO; 65249f3afb57SDarrick J. Wong 65259f3afb57SDarrick J. Wong switch (type) { 65269f3afb57SDarrick J. Wong case XFS_BMAP_MAP: 6527e1a4e37cSDarrick J. Wong error = xfs_bmapi_remap(tp, ip, startoff, *blockcount, 65286ebd5a44SChristoph Hellwig startblock, dfops); 6529e1a4e37cSDarrick J. Wong *blockcount = 0; 65309f3afb57SDarrick J. Wong break; 65319f3afb57SDarrick J. Wong case XFS_BMAP_UNMAP: 6532e1a4e37cSDarrick J. Wong error = __xfs_bunmapi(tp, ip, startoff, blockcount, 6533e1a4e37cSDarrick J. Wong XFS_BMAPI_REMAP, 1, &firstfsb, dfops); 65349f3afb57SDarrick J. Wong break; 65359f3afb57SDarrick J. Wong default: 65369f3afb57SDarrick J. Wong ASSERT(0); 65379f3afb57SDarrick J. Wong error = -EFSCORRUPTED; 65389f3afb57SDarrick J. Wong } 65399f3afb57SDarrick J. Wong 65409f3afb57SDarrick J. Wong return error; 65419f3afb57SDarrick J. Wong } 6542