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" 5230f712c9SDave Chinner 5330f712c9SDave Chinner 5430f712c9SDave Chinner kmem_zone_t *xfs_bmap_free_item_zone; 5530f712c9SDave Chinner 5630f712c9SDave Chinner /* 5730f712c9SDave Chinner * Miscellaneous helper functions 5830f712c9SDave Chinner */ 5930f712c9SDave Chinner 6030f712c9SDave Chinner /* 6130f712c9SDave Chinner * Compute and fill in the value of the maximum depth of a bmap btree 6230f712c9SDave Chinner * in this filesystem. Done once, during mount. 6330f712c9SDave Chinner */ 6430f712c9SDave Chinner void 6530f712c9SDave Chinner xfs_bmap_compute_maxlevels( 6630f712c9SDave Chinner xfs_mount_t *mp, /* file system mount structure */ 6730f712c9SDave Chinner int whichfork) /* data or attr fork */ 6830f712c9SDave Chinner { 6930f712c9SDave Chinner int level; /* btree level */ 7030f712c9SDave Chinner uint maxblocks; /* max blocks at this level */ 7130f712c9SDave Chinner uint maxleafents; /* max leaf entries possible */ 7230f712c9SDave Chinner int maxrootrecs; /* max records in root block */ 7330f712c9SDave Chinner int minleafrecs; /* min records in leaf block */ 7430f712c9SDave Chinner int minnoderecs; /* min records in node block */ 7530f712c9SDave Chinner int sz; /* root block size */ 7630f712c9SDave Chinner 7730f712c9SDave Chinner /* 7830f712c9SDave Chinner * The maximum number of extents in a file, hence the maximum 7930f712c9SDave Chinner * number of leaf entries, is controlled by the type of di_nextents 8030f712c9SDave Chinner * (a signed 32-bit number, xfs_extnum_t), or by di_anextents 8130f712c9SDave Chinner * (a signed 16-bit number, xfs_aextnum_t). 8230f712c9SDave Chinner * 8330f712c9SDave Chinner * Note that we can no longer assume that if we are in ATTR1 that 8430f712c9SDave Chinner * the fork offset of all the inodes will be 8530f712c9SDave Chinner * (xfs_default_attroffset(ip) >> 3) because we could have mounted 8630f712c9SDave Chinner * with ATTR2 and then mounted back with ATTR1, keeping the 8730f712c9SDave Chinner * di_forkoff's fixed but probably at various positions. Therefore, 8830f712c9SDave Chinner * for both ATTR1 and ATTR2 we have to assume the worst case scenario 8930f712c9SDave Chinner * of a minimum size available. 9030f712c9SDave Chinner */ 9130f712c9SDave Chinner if (whichfork == XFS_DATA_FORK) { 9230f712c9SDave Chinner maxleafents = MAXEXTNUM; 9330f712c9SDave Chinner sz = XFS_BMDR_SPACE_CALC(MINDBTPTRS); 9430f712c9SDave Chinner } else { 9530f712c9SDave Chinner maxleafents = MAXAEXTNUM; 9630f712c9SDave Chinner sz = XFS_BMDR_SPACE_CALC(MINABTPTRS); 9730f712c9SDave Chinner } 9830f712c9SDave Chinner maxrootrecs = xfs_bmdr_maxrecs(sz, 0); 9930f712c9SDave Chinner minleafrecs = mp->m_bmap_dmnr[0]; 10030f712c9SDave Chinner minnoderecs = mp->m_bmap_dmnr[1]; 10130f712c9SDave Chinner maxblocks = (maxleafents + minleafrecs - 1) / minleafrecs; 10230f712c9SDave Chinner for (level = 1; maxblocks > 1; level++) { 10330f712c9SDave Chinner if (maxblocks <= maxrootrecs) 10430f712c9SDave Chinner maxblocks = 1; 10530f712c9SDave Chinner else 10630f712c9SDave Chinner maxblocks = (maxblocks + minnoderecs - 1) / minnoderecs; 10730f712c9SDave Chinner } 10830f712c9SDave Chinner mp->m_bm_maxlevels[whichfork] = level; 10930f712c9SDave Chinner } 11030f712c9SDave Chinner 11130f712c9SDave Chinner STATIC int /* error */ 11230f712c9SDave Chinner xfs_bmbt_lookup_eq( 11330f712c9SDave Chinner struct xfs_btree_cur *cur, 11430f712c9SDave Chinner xfs_fileoff_t off, 11530f712c9SDave Chinner xfs_fsblock_t bno, 11630f712c9SDave Chinner xfs_filblks_t len, 11730f712c9SDave Chinner int *stat) /* success/failure */ 11830f712c9SDave Chinner { 11930f712c9SDave Chinner cur->bc_rec.b.br_startoff = off; 12030f712c9SDave Chinner cur->bc_rec.b.br_startblock = bno; 12130f712c9SDave Chinner cur->bc_rec.b.br_blockcount = len; 12230f712c9SDave Chinner return xfs_btree_lookup(cur, XFS_LOOKUP_EQ, stat); 12330f712c9SDave Chinner } 12430f712c9SDave Chinner 12530f712c9SDave Chinner STATIC int /* error */ 12630f712c9SDave Chinner xfs_bmbt_lookup_ge( 12730f712c9SDave Chinner struct xfs_btree_cur *cur, 12830f712c9SDave Chinner xfs_fileoff_t off, 12930f712c9SDave Chinner xfs_fsblock_t bno, 13030f712c9SDave Chinner xfs_filblks_t len, 13130f712c9SDave Chinner int *stat) /* success/failure */ 13230f712c9SDave Chinner { 13330f712c9SDave Chinner cur->bc_rec.b.br_startoff = off; 13430f712c9SDave Chinner cur->bc_rec.b.br_startblock = bno; 13530f712c9SDave Chinner cur->bc_rec.b.br_blockcount = len; 13630f712c9SDave Chinner return xfs_btree_lookup(cur, XFS_LOOKUP_GE, stat); 13730f712c9SDave Chinner } 13830f712c9SDave Chinner 13930f712c9SDave Chinner /* 14030f712c9SDave Chinner * Check if the inode needs to be converted to btree format. 14130f712c9SDave Chinner */ 14230f712c9SDave Chinner static inline bool xfs_bmap_needs_btree(struct xfs_inode *ip, int whichfork) 14330f712c9SDave Chinner { 14460b4984fSDarrick J. Wong return whichfork != XFS_COW_FORK && 14560b4984fSDarrick J. Wong XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_EXTENTS && 14630f712c9SDave Chinner XFS_IFORK_NEXTENTS(ip, whichfork) > 14730f712c9SDave Chinner XFS_IFORK_MAXEXT(ip, whichfork); 14830f712c9SDave Chinner } 14930f712c9SDave Chinner 15030f712c9SDave Chinner /* 15130f712c9SDave Chinner * Check if the inode should be converted to extent format. 15230f712c9SDave Chinner */ 15330f712c9SDave Chinner static inline bool xfs_bmap_wants_extents(struct xfs_inode *ip, int whichfork) 15430f712c9SDave Chinner { 15560b4984fSDarrick J. Wong return whichfork != XFS_COW_FORK && 15660b4984fSDarrick J. Wong XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_BTREE && 15730f712c9SDave Chinner XFS_IFORK_NEXTENTS(ip, whichfork) <= 15830f712c9SDave Chinner XFS_IFORK_MAXEXT(ip, whichfork); 15930f712c9SDave Chinner } 16030f712c9SDave Chinner 16130f712c9SDave Chinner /* 16230f712c9SDave Chinner * Update the record referred to by cur to the value given 16330f712c9SDave Chinner * by [off, bno, len, state]. 16430f712c9SDave Chinner * This either works (return 0) or gets an EFSCORRUPTED error. 16530f712c9SDave Chinner */ 16630f712c9SDave Chinner STATIC int 16730f712c9SDave Chinner xfs_bmbt_update( 16830f712c9SDave Chinner struct xfs_btree_cur *cur, 16930f712c9SDave Chinner xfs_fileoff_t off, 17030f712c9SDave Chinner xfs_fsblock_t bno, 17130f712c9SDave Chinner xfs_filblks_t len, 17230f712c9SDave Chinner xfs_exntst_t state) 17330f712c9SDave Chinner { 17430f712c9SDave Chinner union xfs_btree_rec rec; 17530f712c9SDave Chinner 17630f712c9SDave Chinner xfs_bmbt_disk_set_allf(&rec.bmbt, off, bno, len, state); 17730f712c9SDave Chinner return xfs_btree_update(cur, &rec); 17830f712c9SDave Chinner } 17930f712c9SDave Chinner 18030f712c9SDave Chinner /* 18130f712c9SDave Chinner * Compute the worst-case number of indirect blocks that will be used 18230f712c9SDave Chinner * for ip's delayed extent of length "len". 18330f712c9SDave Chinner */ 18430f712c9SDave Chinner STATIC xfs_filblks_t 18530f712c9SDave Chinner xfs_bmap_worst_indlen( 18630f712c9SDave Chinner xfs_inode_t *ip, /* incore inode pointer */ 18730f712c9SDave Chinner xfs_filblks_t len) /* delayed extent length */ 18830f712c9SDave Chinner { 18930f712c9SDave Chinner int level; /* btree level number */ 19030f712c9SDave Chinner int maxrecs; /* maximum record count at this level */ 19130f712c9SDave Chinner xfs_mount_t *mp; /* mount structure */ 19230f712c9SDave Chinner xfs_filblks_t rval; /* return value */ 19330f712c9SDave Chinner 19430f712c9SDave Chinner mp = ip->i_mount; 19530f712c9SDave Chinner maxrecs = mp->m_bmap_dmxr[0]; 19630f712c9SDave Chinner for (level = 0, rval = 0; 19730f712c9SDave Chinner level < XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK); 19830f712c9SDave Chinner level++) { 19930f712c9SDave Chinner len += maxrecs - 1; 20030f712c9SDave Chinner do_div(len, maxrecs); 20130f712c9SDave Chinner rval += len; 20230f712c9SDave Chinner if (len == 1) 20330f712c9SDave Chinner return rval + XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK) - 20430f712c9SDave Chinner level - 1; 20530f712c9SDave Chinner if (level == 0) 20630f712c9SDave Chinner maxrecs = mp->m_bmap_dmxr[1]; 20730f712c9SDave Chinner } 20830f712c9SDave Chinner return rval; 20930f712c9SDave Chinner } 21030f712c9SDave Chinner 21130f712c9SDave Chinner /* 21230f712c9SDave Chinner * Calculate the default attribute fork offset for newly created inodes. 21330f712c9SDave Chinner */ 21430f712c9SDave Chinner uint 21530f712c9SDave Chinner xfs_default_attroffset( 21630f712c9SDave Chinner struct xfs_inode *ip) 21730f712c9SDave Chinner { 21830f712c9SDave Chinner struct xfs_mount *mp = ip->i_mount; 21930f712c9SDave Chinner uint offset; 22030f712c9SDave Chinner 22130f712c9SDave Chinner if (mp->m_sb.sb_inodesize == 256) { 22230f712c9SDave Chinner offset = XFS_LITINO(mp, ip->i_d.di_version) - 22330f712c9SDave Chinner XFS_BMDR_SPACE_CALC(MINABTPTRS); 22430f712c9SDave Chinner } else { 22530f712c9SDave Chinner offset = XFS_BMDR_SPACE_CALC(6 * MINABTPTRS); 22630f712c9SDave Chinner } 22730f712c9SDave Chinner 22830f712c9SDave Chinner ASSERT(offset < XFS_LITINO(mp, ip->i_d.di_version)); 22930f712c9SDave Chinner return offset; 23030f712c9SDave Chinner } 23130f712c9SDave Chinner 23230f712c9SDave Chinner /* 23330f712c9SDave Chinner * Helper routine to reset inode di_forkoff field when switching 23430f712c9SDave Chinner * attribute fork from local to extent format - we reset it where 23530f712c9SDave Chinner * possible to make space available for inline data fork extents. 23630f712c9SDave Chinner */ 23730f712c9SDave Chinner STATIC void 23830f712c9SDave Chinner xfs_bmap_forkoff_reset( 23930f712c9SDave Chinner xfs_inode_t *ip, 24030f712c9SDave Chinner int whichfork) 24130f712c9SDave Chinner { 24230f712c9SDave Chinner if (whichfork == XFS_ATTR_FORK && 24330f712c9SDave Chinner ip->i_d.di_format != XFS_DINODE_FMT_DEV && 24430f712c9SDave Chinner ip->i_d.di_format != XFS_DINODE_FMT_UUID && 24530f712c9SDave Chinner ip->i_d.di_format != XFS_DINODE_FMT_BTREE) { 24630f712c9SDave Chinner uint dfl_forkoff = xfs_default_attroffset(ip) >> 3; 24730f712c9SDave Chinner 24830f712c9SDave Chinner if (dfl_forkoff > ip->i_d.di_forkoff) 24930f712c9SDave Chinner ip->i_d.di_forkoff = dfl_forkoff; 25030f712c9SDave Chinner } 25130f712c9SDave Chinner } 25230f712c9SDave Chinner 25330f712c9SDave Chinner #ifdef DEBUG 25430f712c9SDave Chinner STATIC struct xfs_buf * 25530f712c9SDave Chinner xfs_bmap_get_bp( 25630f712c9SDave Chinner struct xfs_btree_cur *cur, 25730f712c9SDave Chinner xfs_fsblock_t bno) 25830f712c9SDave Chinner { 25930f712c9SDave Chinner struct xfs_log_item_desc *lidp; 26030f712c9SDave Chinner int i; 26130f712c9SDave Chinner 26230f712c9SDave Chinner if (!cur) 26330f712c9SDave Chinner return NULL; 26430f712c9SDave Chinner 26530f712c9SDave Chinner for (i = 0; i < XFS_BTREE_MAXLEVELS; i++) { 26630f712c9SDave Chinner if (!cur->bc_bufs[i]) 26730f712c9SDave Chinner break; 26830f712c9SDave Chinner if (XFS_BUF_ADDR(cur->bc_bufs[i]) == bno) 26930f712c9SDave Chinner return cur->bc_bufs[i]; 27030f712c9SDave Chinner } 27130f712c9SDave Chinner 27230f712c9SDave Chinner /* Chase down all the log items to see if the bp is there */ 27330f712c9SDave Chinner list_for_each_entry(lidp, &cur->bc_tp->t_items, lid_trans) { 27430f712c9SDave Chinner struct xfs_buf_log_item *bip; 27530f712c9SDave Chinner bip = (struct xfs_buf_log_item *)lidp->lid_item; 27630f712c9SDave Chinner if (bip->bli_item.li_type == XFS_LI_BUF && 27730f712c9SDave Chinner XFS_BUF_ADDR(bip->bli_buf) == bno) 27830f712c9SDave Chinner return bip->bli_buf; 27930f712c9SDave Chinner } 28030f712c9SDave Chinner 28130f712c9SDave Chinner return NULL; 28230f712c9SDave Chinner } 28330f712c9SDave Chinner 28430f712c9SDave Chinner STATIC void 28530f712c9SDave Chinner xfs_check_block( 28630f712c9SDave Chinner struct xfs_btree_block *block, 28730f712c9SDave Chinner xfs_mount_t *mp, 28830f712c9SDave Chinner int root, 28930f712c9SDave Chinner short sz) 29030f712c9SDave Chinner { 29130f712c9SDave Chinner int i, j, dmxr; 29230f712c9SDave Chinner __be64 *pp, *thispa; /* pointer to block address */ 29330f712c9SDave Chinner xfs_bmbt_key_t *prevp, *keyp; 29430f712c9SDave Chinner 29530f712c9SDave Chinner ASSERT(be16_to_cpu(block->bb_level) > 0); 29630f712c9SDave Chinner 29730f712c9SDave Chinner prevp = NULL; 29830f712c9SDave Chinner for( i = 1; i <= xfs_btree_get_numrecs(block); i++) { 29930f712c9SDave Chinner dmxr = mp->m_bmap_dmxr[0]; 30030f712c9SDave Chinner keyp = XFS_BMBT_KEY_ADDR(mp, block, i); 30130f712c9SDave Chinner 30230f712c9SDave Chinner if (prevp) { 30330f712c9SDave Chinner ASSERT(be64_to_cpu(prevp->br_startoff) < 30430f712c9SDave Chinner be64_to_cpu(keyp->br_startoff)); 30530f712c9SDave Chinner } 30630f712c9SDave Chinner prevp = keyp; 30730f712c9SDave Chinner 30830f712c9SDave Chinner /* 30930f712c9SDave Chinner * Compare the block numbers to see if there are dups. 31030f712c9SDave Chinner */ 31130f712c9SDave Chinner if (root) 31230f712c9SDave Chinner pp = XFS_BMAP_BROOT_PTR_ADDR(mp, block, i, sz); 31330f712c9SDave Chinner else 31430f712c9SDave Chinner pp = XFS_BMBT_PTR_ADDR(mp, block, i, dmxr); 31530f712c9SDave Chinner 31630f712c9SDave Chinner for (j = i+1; j <= be16_to_cpu(block->bb_numrecs); j++) { 31730f712c9SDave Chinner if (root) 31830f712c9SDave Chinner thispa = XFS_BMAP_BROOT_PTR_ADDR(mp, block, j, sz); 31930f712c9SDave Chinner else 32030f712c9SDave Chinner thispa = XFS_BMBT_PTR_ADDR(mp, block, j, dmxr); 32130f712c9SDave Chinner if (*thispa == *pp) { 32230f712c9SDave Chinner xfs_warn(mp, "%s: thispa(%d) == pp(%d) %Ld", 32330f712c9SDave Chinner __func__, j, i, 32430f712c9SDave Chinner (unsigned long long)be64_to_cpu(*thispa)); 32530f712c9SDave Chinner panic("%s: ptrs are equal in node\n", 32630f712c9SDave Chinner __func__); 32730f712c9SDave Chinner } 32830f712c9SDave Chinner } 32930f712c9SDave Chinner } 33030f712c9SDave Chinner } 33130f712c9SDave Chinner 33230f712c9SDave Chinner /* 33330f712c9SDave Chinner * Check that the extents for the inode ip are in the right order in all 334e3543819SDave Chinner * btree leaves. THis becomes prohibitively expensive for large extent count 335e3543819SDave Chinner * files, so don't bother with inodes that have more than 10,000 extents in 336e3543819SDave Chinner * them. The btree record ordering checks will still be done, so for such large 337e3543819SDave Chinner * bmapbt constructs that is going to catch most corruptions. 33830f712c9SDave Chinner */ 33930f712c9SDave Chinner STATIC void 34030f712c9SDave Chinner xfs_bmap_check_leaf_extents( 34130f712c9SDave Chinner xfs_btree_cur_t *cur, /* btree cursor or null */ 34230f712c9SDave Chinner xfs_inode_t *ip, /* incore inode pointer */ 34330f712c9SDave Chinner int whichfork) /* data or attr fork */ 34430f712c9SDave Chinner { 34530f712c9SDave Chinner struct xfs_btree_block *block; /* current btree block */ 34630f712c9SDave Chinner xfs_fsblock_t bno; /* block # of "block" */ 34730f712c9SDave Chinner xfs_buf_t *bp; /* buffer for "block" */ 34830f712c9SDave Chinner int error; /* error return value */ 34930f712c9SDave Chinner xfs_extnum_t i=0, j; /* index into the extents list */ 35030f712c9SDave Chinner xfs_ifork_t *ifp; /* fork structure */ 35130f712c9SDave Chinner int level; /* btree level, for checking */ 35230f712c9SDave Chinner xfs_mount_t *mp; /* file system mount structure */ 35330f712c9SDave Chinner __be64 *pp; /* pointer to block address */ 35430f712c9SDave Chinner xfs_bmbt_rec_t *ep; /* pointer to current extent */ 35530f712c9SDave Chinner xfs_bmbt_rec_t last = {0, 0}; /* last extent in prev block */ 35630f712c9SDave Chinner xfs_bmbt_rec_t *nextp; /* pointer to next extent */ 35730f712c9SDave Chinner int bp_release = 0; 35830f712c9SDave Chinner 35930f712c9SDave Chinner if (XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE) { 36030f712c9SDave Chinner return; 36130f712c9SDave Chinner } 36230f712c9SDave Chinner 363e3543819SDave Chinner /* skip large extent count inodes */ 364e3543819SDave Chinner if (ip->i_d.di_nextents > 10000) 365e3543819SDave Chinner return; 366e3543819SDave Chinner 36730f712c9SDave Chinner bno = NULLFSBLOCK; 36830f712c9SDave Chinner mp = ip->i_mount; 36930f712c9SDave Chinner ifp = XFS_IFORK_PTR(ip, whichfork); 37030f712c9SDave Chinner block = ifp->if_broot; 37130f712c9SDave Chinner /* 37230f712c9SDave Chinner * Root level must use BMAP_BROOT_PTR_ADDR macro to get ptr out. 37330f712c9SDave Chinner */ 37430f712c9SDave Chinner level = be16_to_cpu(block->bb_level); 37530f712c9SDave Chinner ASSERT(level > 0); 37630f712c9SDave Chinner xfs_check_block(block, mp, 1, ifp->if_broot_bytes); 37730f712c9SDave Chinner pp = XFS_BMAP_BROOT_PTR_ADDR(mp, block, 1, ifp->if_broot_bytes); 37830f712c9SDave Chinner bno = be64_to_cpu(*pp); 37930f712c9SDave Chinner 380d5cf09baSChristoph Hellwig ASSERT(bno != NULLFSBLOCK); 38130f712c9SDave Chinner ASSERT(XFS_FSB_TO_AGNO(mp, bno) < mp->m_sb.sb_agcount); 38230f712c9SDave Chinner ASSERT(XFS_FSB_TO_AGBNO(mp, bno) < mp->m_sb.sb_agblocks); 38330f712c9SDave Chinner 38430f712c9SDave Chinner /* 38530f712c9SDave Chinner * Go down the tree until leaf level is reached, following the first 38630f712c9SDave Chinner * pointer (leftmost) at each level. 38730f712c9SDave Chinner */ 38830f712c9SDave Chinner while (level-- > 0) { 38930f712c9SDave Chinner /* See if buf is in cur first */ 39030f712c9SDave Chinner bp_release = 0; 39130f712c9SDave Chinner bp = xfs_bmap_get_bp(cur, XFS_FSB_TO_DADDR(mp, bno)); 39230f712c9SDave Chinner if (!bp) { 39330f712c9SDave Chinner bp_release = 1; 39430f712c9SDave Chinner error = xfs_btree_read_bufl(mp, NULL, bno, 0, &bp, 39530f712c9SDave Chinner XFS_BMAP_BTREE_REF, 39630f712c9SDave Chinner &xfs_bmbt_buf_ops); 39730f712c9SDave Chinner if (error) 39830f712c9SDave Chinner goto error_norelse; 39930f712c9SDave Chinner } 40030f712c9SDave Chinner block = XFS_BUF_TO_BLOCK(bp); 40130f712c9SDave Chinner if (level == 0) 40230f712c9SDave Chinner break; 40330f712c9SDave Chinner 40430f712c9SDave Chinner /* 40530f712c9SDave Chinner * Check this block for basic sanity (increasing keys and 40630f712c9SDave Chinner * no duplicate blocks). 40730f712c9SDave Chinner */ 40830f712c9SDave Chinner 40930f712c9SDave Chinner xfs_check_block(block, mp, 0, 0); 41030f712c9SDave Chinner pp = XFS_BMBT_PTR_ADDR(mp, block, 1, mp->m_bmap_dmxr[1]); 41130f712c9SDave Chinner bno = be64_to_cpu(*pp); 412c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, 413c29aad41SEric Sandeen XFS_FSB_SANITY_CHECK(mp, bno), error0); 41430f712c9SDave Chinner if (bp_release) { 41530f712c9SDave Chinner bp_release = 0; 41630f712c9SDave Chinner xfs_trans_brelse(NULL, bp); 41730f712c9SDave Chinner } 41830f712c9SDave Chinner } 41930f712c9SDave Chinner 42030f712c9SDave Chinner /* 42130f712c9SDave Chinner * Here with bp and block set to the leftmost leaf node in the tree. 42230f712c9SDave Chinner */ 42330f712c9SDave Chinner i = 0; 42430f712c9SDave Chinner 42530f712c9SDave Chinner /* 42630f712c9SDave Chinner * Loop over all leaf nodes checking that all extents are in the right order. 42730f712c9SDave Chinner */ 42830f712c9SDave Chinner for (;;) { 42930f712c9SDave Chinner xfs_fsblock_t nextbno; 43030f712c9SDave Chinner xfs_extnum_t num_recs; 43130f712c9SDave Chinner 43230f712c9SDave Chinner 43330f712c9SDave Chinner num_recs = xfs_btree_get_numrecs(block); 43430f712c9SDave Chinner 43530f712c9SDave Chinner /* 43630f712c9SDave Chinner * Read-ahead the next leaf block, if any. 43730f712c9SDave Chinner */ 43830f712c9SDave Chinner 43930f712c9SDave Chinner nextbno = be64_to_cpu(block->bb_u.l.bb_rightsib); 44030f712c9SDave Chinner 44130f712c9SDave Chinner /* 44230f712c9SDave Chinner * Check all the extents to make sure they are OK. 44330f712c9SDave Chinner * If we had a previous block, the last entry should 44430f712c9SDave Chinner * conform with the first entry in this one. 44530f712c9SDave Chinner */ 44630f712c9SDave Chinner 44730f712c9SDave Chinner ep = XFS_BMBT_REC_ADDR(mp, block, 1); 44830f712c9SDave Chinner if (i) { 44930f712c9SDave Chinner ASSERT(xfs_bmbt_disk_get_startoff(&last) + 45030f712c9SDave Chinner xfs_bmbt_disk_get_blockcount(&last) <= 45130f712c9SDave Chinner xfs_bmbt_disk_get_startoff(ep)); 45230f712c9SDave Chinner } 45330f712c9SDave Chinner for (j = 1; j < num_recs; j++) { 45430f712c9SDave Chinner nextp = XFS_BMBT_REC_ADDR(mp, block, j + 1); 45530f712c9SDave Chinner ASSERT(xfs_bmbt_disk_get_startoff(ep) + 45630f712c9SDave Chinner xfs_bmbt_disk_get_blockcount(ep) <= 45730f712c9SDave Chinner xfs_bmbt_disk_get_startoff(nextp)); 45830f712c9SDave Chinner ep = nextp; 45930f712c9SDave Chinner } 46030f712c9SDave Chinner 46130f712c9SDave Chinner last = *ep; 46230f712c9SDave Chinner i += num_recs; 46330f712c9SDave Chinner if (bp_release) { 46430f712c9SDave Chinner bp_release = 0; 46530f712c9SDave Chinner xfs_trans_brelse(NULL, bp); 46630f712c9SDave Chinner } 46730f712c9SDave Chinner bno = nextbno; 46830f712c9SDave Chinner /* 46930f712c9SDave Chinner * If we've reached the end, stop. 47030f712c9SDave Chinner */ 47130f712c9SDave Chinner if (bno == NULLFSBLOCK) 47230f712c9SDave Chinner break; 47330f712c9SDave Chinner 47430f712c9SDave Chinner bp_release = 0; 47530f712c9SDave Chinner bp = xfs_bmap_get_bp(cur, XFS_FSB_TO_DADDR(mp, bno)); 47630f712c9SDave Chinner if (!bp) { 47730f712c9SDave Chinner bp_release = 1; 47830f712c9SDave Chinner error = xfs_btree_read_bufl(mp, NULL, bno, 0, &bp, 47930f712c9SDave Chinner XFS_BMAP_BTREE_REF, 48030f712c9SDave Chinner &xfs_bmbt_buf_ops); 48130f712c9SDave Chinner if (error) 48230f712c9SDave Chinner goto error_norelse; 48330f712c9SDave Chinner } 48430f712c9SDave Chinner block = XFS_BUF_TO_BLOCK(bp); 48530f712c9SDave Chinner } 486a5fd276bSLuis de Bethencourt 48730f712c9SDave Chinner return; 48830f712c9SDave Chinner 48930f712c9SDave Chinner error0: 49030f712c9SDave Chinner xfs_warn(mp, "%s: at error0", __func__); 49130f712c9SDave Chinner if (bp_release) 49230f712c9SDave Chinner xfs_trans_brelse(NULL, bp); 49330f712c9SDave Chinner error_norelse: 49430f712c9SDave Chinner xfs_warn(mp, "%s: BAD after btree leaves for %d extents", 49530f712c9SDave Chinner __func__, i); 49630f712c9SDave Chinner panic("%s: CORRUPTED BTREE OR SOMETHING", __func__); 49730f712c9SDave Chinner return; 49830f712c9SDave Chinner } 49930f712c9SDave Chinner 50030f712c9SDave Chinner /* 50130f712c9SDave Chinner * Add bmap trace insert entries for all the contents of the extent records. 50230f712c9SDave Chinner */ 50330f712c9SDave Chinner void 50430f712c9SDave Chinner xfs_bmap_trace_exlist( 50530f712c9SDave Chinner xfs_inode_t *ip, /* incore inode pointer */ 50630f712c9SDave Chinner xfs_extnum_t cnt, /* count of entries in the list */ 50730f712c9SDave Chinner int whichfork, /* data or attr fork */ 50830f712c9SDave Chinner unsigned long caller_ip) 50930f712c9SDave Chinner { 51030f712c9SDave Chinner xfs_extnum_t idx; /* extent record index */ 51130f712c9SDave Chinner xfs_ifork_t *ifp; /* inode fork pointer */ 51230f712c9SDave Chinner int state = 0; 51330f712c9SDave Chinner 51430f712c9SDave Chinner if (whichfork == XFS_ATTR_FORK) 51530f712c9SDave Chinner state |= BMAP_ATTRFORK; 51630f712c9SDave Chinner 51730f712c9SDave Chinner ifp = XFS_IFORK_PTR(ip, whichfork); 51830f712c9SDave Chinner ASSERT(cnt == (ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t))); 51930f712c9SDave Chinner for (idx = 0; idx < cnt; idx++) 52030f712c9SDave Chinner trace_xfs_extlist(ip, idx, whichfork, caller_ip); 52130f712c9SDave Chinner } 52230f712c9SDave Chinner 52330f712c9SDave Chinner /* 52430f712c9SDave Chinner * Validate that the bmbt_irecs being returned from bmapi are valid 52530f712c9SDave Chinner * given the caller's original parameters. Specifically check the 52630f712c9SDave Chinner * ranges of the returned irecs to ensure that they only extend beyond 52730f712c9SDave Chinner * the given parameters if the XFS_BMAPI_ENTIRE flag was set. 52830f712c9SDave Chinner */ 52930f712c9SDave Chinner STATIC void 53030f712c9SDave Chinner xfs_bmap_validate_ret( 53130f712c9SDave Chinner xfs_fileoff_t bno, 53230f712c9SDave Chinner xfs_filblks_t len, 53330f712c9SDave Chinner int flags, 53430f712c9SDave Chinner xfs_bmbt_irec_t *mval, 53530f712c9SDave Chinner int nmap, 53630f712c9SDave Chinner int ret_nmap) 53730f712c9SDave Chinner { 53830f712c9SDave Chinner int i; /* index to map values */ 53930f712c9SDave Chinner 54030f712c9SDave Chinner ASSERT(ret_nmap <= nmap); 54130f712c9SDave Chinner 54230f712c9SDave Chinner for (i = 0; i < ret_nmap; i++) { 54330f712c9SDave Chinner ASSERT(mval[i].br_blockcount > 0); 54430f712c9SDave Chinner if (!(flags & XFS_BMAPI_ENTIRE)) { 54530f712c9SDave Chinner ASSERT(mval[i].br_startoff >= bno); 54630f712c9SDave Chinner ASSERT(mval[i].br_blockcount <= len); 54730f712c9SDave Chinner ASSERT(mval[i].br_startoff + mval[i].br_blockcount <= 54830f712c9SDave Chinner bno + len); 54930f712c9SDave Chinner } else { 55030f712c9SDave Chinner ASSERT(mval[i].br_startoff < bno + len); 55130f712c9SDave Chinner ASSERT(mval[i].br_startoff + mval[i].br_blockcount > 55230f712c9SDave Chinner bno); 55330f712c9SDave Chinner } 55430f712c9SDave Chinner ASSERT(i == 0 || 55530f712c9SDave Chinner mval[i - 1].br_startoff + mval[i - 1].br_blockcount == 55630f712c9SDave Chinner mval[i].br_startoff); 55730f712c9SDave Chinner ASSERT(mval[i].br_startblock != DELAYSTARTBLOCK && 55830f712c9SDave Chinner mval[i].br_startblock != HOLESTARTBLOCK); 55930f712c9SDave Chinner ASSERT(mval[i].br_state == XFS_EXT_NORM || 56030f712c9SDave Chinner mval[i].br_state == XFS_EXT_UNWRITTEN); 56130f712c9SDave Chinner } 56230f712c9SDave Chinner } 56330f712c9SDave Chinner 56430f712c9SDave Chinner #else 56530f712c9SDave Chinner #define xfs_bmap_check_leaf_extents(cur, ip, whichfork) do { } while (0) 56630f712c9SDave Chinner #define xfs_bmap_validate_ret(bno,len,flags,mval,onmap,nmap) 56730f712c9SDave Chinner #endif /* DEBUG */ 56830f712c9SDave Chinner 56930f712c9SDave Chinner /* 57030f712c9SDave Chinner * bmap free list manipulation functions 57130f712c9SDave Chinner */ 57230f712c9SDave Chinner 57330f712c9SDave Chinner /* 57430f712c9SDave Chinner * Add the extent to the list of extents to be free at transaction end. 57530f712c9SDave Chinner * The list is maintained sorted (by block number). 57630f712c9SDave Chinner */ 57730f712c9SDave Chinner void 57830f712c9SDave Chinner xfs_bmap_add_free( 579340785ccSDarrick J. Wong struct xfs_mount *mp, 580340785ccSDarrick J. Wong struct xfs_defer_ops *dfops, 581340785ccSDarrick J. Wong xfs_fsblock_t bno, 582340785ccSDarrick J. Wong xfs_filblks_t len, 583340785ccSDarrick J. Wong struct xfs_owner_info *oinfo) 58430f712c9SDave Chinner { 585310a75a3SDarrick J. Wong struct xfs_extent_free_item *new; /* new element */ 58630f712c9SDave Chinner #ifdef DEBUG 58730f712c9SDave Chinner xfs_agnumber_t agno; 58830f712c9SDave Chinner xfs_agblock_t agbno; 58930f712c9SDave Chinner 59030f712c9SDave Chinner ASSERT(bno != NULLFSBLOCK); 59130f712c9SDave Chinner ASSERT(len > 0); 59230f712c9SDave Chinner ASSERT(len <= MAXEXTLEN); 59330f712c9SDave Chinner ASSERT(!isnullstartblock(bno)); 59430f712c9SDave Chinner agno = XFS_FSB_TO_AGNO(mp, bno); 59530f712c9SDave Chinner agbno = XFS_FSB_TO_AGBNO(mp, bno); 59630f712c9SDave Chinner ASSERT(agno < mp->m_sb.sb_agcount); 59730f712c9SDave Chinner ASSERT(agbno < mp->m_sb.sb_agblocks); 59830f712c9SDave Chinner ASSERT(len < mp->m_sb.sb_agblocks); 59930f712c9SDave Chinner ASSERT(agbno + len <= mp->m_sb.sb_agblocks); 60030f712c9SDave Chinner #endif 60130f712c9SDave Chinner ASSERT(xfs_bmap_free_item_zone != NULL); 602340785ccSDarrick J. Wong 60330f712c9SDave Chinner new = kmem_zone_alloc(xfs_bmap_free_item_zone, KM_SLEEP); 604310a75a3SDarrick J. Wong new->xefi_startblock = bno; 605310a75a3SDarrick J. Wong new->xefi_blockcount = (xfs_extlen_t)len; 606340785ccSDarrick J. Wong if (oinfo) 607340785ccSDarrick J. Wong new->xefi_oinfo = *oinfo; 608340785ccSDarrick J. Wong else 609340785ccSDarrick J. Wong xfs_rmap_skip_owner_update(&new->xefi_oinfo); 610ba9e7802SDarrick J. Wong trace_xfs_bmap_free_defer(mp, XFS_FSB_TO_AGNO(mp, bno), 0, 611ba9e7802SDarrick J. Wong XFS_FSB_TO_AGBNO(mp, bno), len); 6122c3234d1SDarrick J. Wong xfs_defer_add(dfops, XFS_DEFER_OPS_TYPE_FREE, &new->xefi_list); 61330f712c9SDave Chinner } 61430f712c9SDave Chinner 61530f712c9SDave Chinner /* 61630f712c9SDave Chinner * Inode fork format manipulation functions 61730f712c9SDave Chinner */ 61830f712c9SDave Chinner 61930f712c9SDave Chinner /* 62030f712c9SDave Chinner * Transform a btree format file with only one leaf node, where the 62130f712c9SDave Chinner * extents list will fit in the inode, into an extents format file. 62230f712c9SDave Chinner * Since the file extents are already in-core, all we have to do is 62330f712c9SDave Chinner * give up the space for the btree root and pitch the leaf block. 62430f712c9SDave Chinner */ 62530f712c9SDave Chinner STATIC int /* error */ 62630f712c9SDave Chinner xfs_bmap_btree_to_extents( 62730f712c9SDave Chinner xfs_trans_t *tp, /* transaction pointer */ 62830f712c9SDave Chinner xfs_inode_t *ip, /* incore inode pointer */ 62930f712c9SDave Chinner xfs_btree_cur_t *cur, /* btree cursor */ 63030f712c9SDave Chinner int *logflagsp, /* inode logging flags */ 63130f712c9SDave Chinner int whichfork) /* data or attr fork */ 63230f712c9SDave Chinner { 63330f712c9SDave Chinner /* REFERENCED */ 63430f712c9SDave Chinner struct xfs_btree_block *cblock;/* child btree block */ 63530f712c9SDave Chinner xfs_fsblock_t cbno; /* child block number */ 63630f712c9SDave Chinner xfs_buf_t *cbp; /* child block's buffer */ 63730f712c9SDave Chinner int error; /* error return value */ 63830f712c9SDave Chinner xfs_ifork_t *ifp; /* inode fork data */ 63930f712c9SDave Chinner xfs_mount_t *mp; /* mount point structure */ 64030f712c9SDave Chinner __be64 *pp; /* ptr to block address */ 64130f712c9SDave Chinner struct xfs_btree_block *rblock;/* root btree block */ 642340785ccSDarrick J. Wong struct xfs_owner_info oinfo; 64330f712c9SDave Chinner 64430f712c9SDave Chinner mp = ip->i_mount; 64530f712c9SDave Chinner ifp = XFS_IFORK_PTR(ip, whichfork); 64660b4984fSDarrick J. Wong ASSERT(whichfork != XFS_COW_FORK); 64730f712c9SDave Chinner ASSERT(ifp->if_flags & XFS_IFEXTENTS); 64830f712c9SDave Chinner ASSERT(XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_BTREE); 64930f712c9SDave Chinner rblock = ifp->if_broot; 65030f712c9SDave Chinner ASSERT(be16_to_cpu(rblock->bb_level) == 1); 65130f712c9SDave Chinner ASSERT(be16_to_cpu(rblock->bb_numrecs) == 1); 65230f712c9SDave Chinner ASSERT(xfs_bmbt_maxrecs(mp, ifp->if_broot_bytes, 0) == 1); 65330f712c9SDave Chinner pp = XFS_BMAP_BROOT_PTR_ADDR(mp, rblock, 1, ifp->if_broot_bytes); 65430f712c9SDave Chinner cbno = be64_to_cpu(*pp); 65530f712c9SDave Chinner *logflagsp = 0; 65630f712c9SDave Chinner #ifdef DEBUG 65730f712c9SDave Chinner if ((error = xfs_btree_check_lptr(cur, cbno, 1))) 65830f712c9SDave Chinner return error; 65930f712c9SDave Chinner #endif 66030f712c9SDave Chinner error = xfs_btree_read_bufl(mp, tp, cbno, 0, &cbp, XFS_BMAP_BTREE_REF, 66130f712c9SDave Chinner &xfs_bmbt_buf_ops); 66230f712c9SDave Chinner if (error) 66330f712c9SDave Chinner return error; 66430f712c9SDave Chinner cblock = XFS_BUF_TO_BLOCK(cbp); 66530f712c9SDave Chinner if ((error = xfs_btree_check_block(cur, cblock, 0, cbp))) 66630f712c9SDave Chinner return error; 667340785ccSDarrick J. Wong xfs_rmap_ino_bmbt_owner(&oinfo, ip->i_ino, whichfork); 668340785ccSDarrick J. Wong xfs_bmap_add_free(mp, cur->bc_private.b.dfops, cbno, 1, &oinfo); 66930f712c9SDave Chinner ip->i_d.di_nblocks--; 67030f712c9SDave Chinner xfs_trans_mod_dquot_byino(tp, ip, XFS_TRANS_DQ_BCOUNT, -1L); 67130f712c9SDave Chinner xfs_trans_binval(tp, cbp); 67230f712c9SDave Chinner if (cur->bc_bufs[0] == cbp) 67330f712c9SDave Chinner cur->bc_bufs[0] = NULL; 67430f712c9SDave Chinner xfs_iroot_realloc(ip, -1, whichfork); 67530f712c9SDave Chinner ASSERT(ifp->if_broot == NULL); 67630f712c9SDave Chinner ASSERT((ifp->if_flags & XFS_IFBROOT) == 0); 67730f712c9SDave Chinner XFS_IFORK_FMT_SET(ip, whichfork, XFS_DINODE_FMT_EXTENTS); 67830f712c9SDave Chinner *logflagsp = XFS_ILOG_CORE | xfs_ilog_fext(whichfork); 67930f712c9SDave Chinner return 0; 68030f712c9SDave Chinner } 68130f712c9SDave Chinner 68230f712c9SDave Chinner /* 68330f712c9SDave Chinner * Convert an extents-format file into a btree-format file. 68430f712c9SDave Chinner * The new file will have a root block (in the inode) and a single child block. 68530f712c9SDave Chinner */ 68630f712c9SDave Chinner STATIC int /* error */ 68730f712c9SDave Chinner xfs_bmap_extents_to_btree( 68830f712c9SDave Chinner xfs_trans_t *tp, /* transaction pointer */ 68930f712c9SDave Chinner xfs_inode_t *ip, /* incore inode pointer */ 69030f712c9SDave Chinner xfs_fsblock_t *firstblock, /* first-block-allocated */ 6912c3234d1SDarrick J. Wong struct xfs_defer_ops *dfops, /* blocks freed in xaction */ 69230f712c9SDave Chinner xfs_btree_cur_t **curp, /* cursor returned to caller */ 69330f712c9SDave Chinner int wasdel, /* converting a delayed alloc */ 69430f712c9SDave Chinner int *logflagsp, /* inode logging flags */ 69530f712c9SDave Chinner int whichfork) /* data or attr fork */ 69630f712c9SDave Chinner { 69730f712c9SDave Chinner struct xfs_btree_block *ablock; /* allocated (child) bt block */ 69830f712c9SDave Chinner xfs_buf_t *abp; /* buffer for ablock */ 69930f712c9SDave Chinner xfs_alloc_arg_t args; /* allocation arguments */ 70030f712c9SDave Chinner xfs_bmbt_rec_t *arp; /* child record pointer */ 70130f712c9SDave Chinner struct xfs_btree_block *block; /* btree root block */ 70230f712c9SDave Chinner xfs_btree_cur_t *cur; /* bmap btree cursor */ 70330f712c9SDave Chinner xfs_bmbt_rec_host_t *ep; /* extent record pointer */ 70430f712c9SDave Chinner int error; /* error return value */ 70530f712c9SDave Chinner xfs_extnum_t i, cnt; /* extent record index */ 70630f712c9SDave Chinner xfs_ifork_t *ifp; /* inode fork pointer */ 70730f712c9SDave Chinner xfs_bmbt_key_t *kp; /* root block key pointer */ 70830f712c9SDave Chinner xfs_mount_t *mp; /* mount structure */ 70930f712c9SDave Chinner xfs_extnum_t nextents; /* number of file extents */ 71030f712c9SDave Chinner xfs_bmbt_ptr_t *pp; /* root block address pointer */ 71130f712c9SDave Chinner 71230f712c9SDave Chinner mp = ip->i_mount; 71360b4984fSDarrick J. Wong ASSERT(whichfork != XFS_COW_FORK); 71430f712c9SDave Chinner ifp = XFS_IFORK_PTR(ip, whichfork); 71530f712c9SDave Chinner ASSERT(XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_EXTENTS); 71630f712c9SDave Chinner 71730f712c9SDave Chinner /* 71830f712c9SDave Chinner * Make space in the inode incore. 71930f712c9SDave Chinner */ 72030f712c9SDave Chinner xfs_iroot_realloc(ip, 1, whichfork); 72130f712c9SDave Chinner ifp->if_flags |= XFS_IFBROOT; 72230f712c9SDave Chinner 72330f712c9SDave Chinner /* 72430f712c9SDave Chinner * Fill in the root. 72530f712c9SDave Chinner */ 72630f712c9SDave Chinner block = ifp->if_broot; 72730f712c9SDave Chinner if (xfs_sb_version_hascrc(&mp->m_sb)) 72830f712c9SDave Chinner xfs_btree_init_block_int(mp, block, XFS_BUF_DADDR_NULL, 72930f712c9SDave Chinner XFS_BMAP_CRC_MAGIC, 1, 1, ip->i_ino, 73030f712c9SDave Chinner XFS_BTREE_LONG_PTRS | XFS_BTREE_CRC_BLOCKS); 73130f712c9SDave Chinner else 73230f712c9SDave Chinner xfs_btree_init_block_int(mp, block, XFS_BUF_DADDR_NULL, 73330f712c9SDave Chinner XFS_BMAP_MAGIC, 1, 1, ip->i_ino, 73430f712c9SDave Chinner XFS_BTREE_LONG_PTRS); 73530f712c9SDave Chinner 73630f712c9SDave Chinner /* 73730f712c9SDave Chinner * Need a cursor. Can't allocate until bb_level is filled in. 73830f712c9SDave Chinner */ 73930f712c9SDave Chinner cur = xfs_bmbt_init_cursor(mp, tp, ip, whichfork); 74030f712c9SDave Chinner cur->bc_private.b.firstblock = *firstblock; 7412c3234d1SDarrick J. Wong cur->bc_private.b.dfops = dfops; 74230f712c9SDave Chinner cur->bc_private.b.flags = wasdel ? XFS_BTCUR_BPRV_WASDEL : 0; 74330f712c9SDave Chinner /* 74430f712c9SDave Chinner * Convert to a btree with two levels, one record in root. 74530f712c9SDave Chinner */ 74630f712c9SDave Chinner XFS_IFORK_FMT_SET(ip, whichfork, XFS_DINODE_FMT_BTREE); 74730f712c9SDave Chinner memset(&args, 0, sizeof(args)); 74830f712c9SDave Chinner args.tp = tp; 74930f712c9SDave Chinner args.mp = mp; 750340785ccSDarrick J. Wong xfs_rmap_ino_bmbt_owner(&args.oinfo, ip->i_ino, whichfork); 75130f712c9SDave Chinner args.firstblock = *firstblock; 75230f712c9SDave Chinner if (*firstblock == NULLFSBLOCK) { 75330f712c9SDave Chinner args.type = XFS_ALLOCTYPE_START_BNO; 75430f712c9SDave Chinner args.fsbno = XFS_INO_TO_FSB(mp, ip->i_ino); 7552c3234d1SDarrick J. Wong } else if (dfops->dop_low) { 75690e2056dSDarrick J. Wong try_another_ag: 75730f712c9SDave Chinner args.type = XFS_ALLOCTYPE_START_BNO; 75830f712c9SDave Chinner args.fsbno = *firstblock; 75930f712c9SDave Chinner } else { 76030f712c9SDave Chinner args.type = XFS_ALLOCTYPE_NEAR_BNO; 76130f712c9SDave Chinner args.fsbno = *firstblock; 76230f712c9SDave Chinner } 76330f712c9SDave Chinner args.minlen = args.maxlen = args.prod = 1; 76430f712c9SDave Chinner args.wasdel = wasdel; 76530f712c9SDave Chinner *logflagsp = 0; 76630f712c9SDave Chinner if ((error = xfs_alloc_vextent(&args))) { 76730f712c9SDave Chinner xfs_iroot_realloc(ip, -1, whichfork); 76830f712c9SDave Chinner xfs_btree_del_cursor(cur, XFS_BTREE_ERROR); 76930f712c9SDave Chinner return error; 77030f712c9SDave Chinner } 77190e2056dSDarrick J. Wong 77290e2056dSDarrick J. Wong /* 77390e2056dSDarrick J. Wong * During a CoW operation, the allocation and bmbt updates occur in 77490e2056dSDarrick J. Wong * different transactions. The mapping code tries to put new bmbt 77590e2056dSDarrick J. Wong * blocks near extents being mapped, but the only way to guarantee this 77690e2056dSDarrick J. Wong * is if the alloc and the mapping happen in a single transaction that 77790e2056dSDarrick J. Wong * has a block reservation. That isn't the case here, so if we run out 77890e2056dSDarrick J. Wong * of space we'll try again with another AG. 77990e2056dSDarrick J. Wong */ 78090e2056dSDarrick J. Wong if (xfs_sb_version_hasreflink(&cur->bc_mp->m_sb) && 78190e2056dSDarrick J. Wong args.fsbno == NULLFSBLOCK && 78290e2056dSDarrick J. Wong args.type == XFS_ALLOCTYPE_NEAR_BNO) { 78390e2056dSDarrick J. Wong dfops->dop_low = true; 78490e2056dSDarrick J. Wong goto try_another_ag; 78590e2056dSDarrick J. Wong } 78630f712c9SDave Chinner /* 78730f712c9SDave Chinner * Allocation can't fail, the space was reserved. 78830f712c9SDave Chinner */ 78930f712c9SDave Chinner ASSERT(args.fsbno != NULLFSBLOCK); 79030f712c9SDave Chinner ASSERT(*firstblock == NULLFSBLOCK || 79130f712c9SDave Chinner args.agno == XFS_FSB_TO_AGNO(mp, *firstblock) || 7922c3234d1SDarrick J. Wong (dfops->dop_low && 79330f712c9SDave Chinner args.agno > XFS_FSB_TO_AGNO(mp, *firstblock))); 79430f712c9SDave Chinner *firstblock = cur->bc_private.b.firstblock = args.fsbno; 79530f712c9SDave Chinner cur->bc_private.b.allocated++; 79630f712c9SDave Chinner ip->i_d.di_nblocks++; 79730f712c9SDave Chinner xfs_trans_mod_dquot_byino(tp, ip, XFS_TRANS_DQ_BCOUNT, 1L); 79830f712c9SDave Chinner abp = xfs_btree_get_bufl(mp, tp, args.fsbno, 0); 79930f712c9SDave Chinner /* 80030f712c9SDave Chinner * Fill in the child block. 80130f712c9SDave Chinner */ 80230f712c9SDave Chinner abp->b_ops = &xfs_bmbt_buf_ops; 80330f712c9SDave Chinner ablock = XFS_BUF_TO_BLOCK(abp); 80430f712c9SDave Chinner if (xfs_sb_version_hascrc(&mp->m_sb)) 80530f712c9SDave Chinner xfs_btree_init_block_int(mp, ablock, abp->b_bn, 80630f712c9SDave Chinner XFS_BMAP_CRC_MAGIC, 0, 0, ip->i_ino, 80730f712c9SDave Chinner XFS_BTREE_LONG_PTRS | XFS_BTREE_CRC_BLOCKS); 80830f712c9SDave Chinner else 80930f712c9SDave Chinner xfs_btree_init_block_int(mp, ablock, abp->b_bn, 81030f712c9SDave Chinner XFS_BMAP_MAGIC, 0, 0, ip->i_ino, 81130f712c9SDave Chinner XFS_BTREE_LONG_PTRS); 81230f712c9SDave Chinner 81330f712c9SDave Chinner arp = XFS_BMBT_REC_ADDR(mp, ablock, 1); 81430f712c9SDave Chinner nextents = ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t); 81530f712c9SDave Chinner for (cnt = i = 0; i < nextents; i++) { 81630f712c9SDave Chinner ep = xfs_iext_get_ext(ifp, i); 81730f712c9SDave Chinner if (!isnullstartblock(xfs_bmbt_get_startblock(ep))) { 81830f712c9SDave Chinner arp->l0 = cpu_to_be64(ep->l0); 81930f712c9SDave Chinner arp->l1 = cpu_to_be64(ep->l1); 82030f712c9SDave Chinner arp++; cnt++; 82130f712c9SDave Chinner } 82230f712c9SDave Chinner } 82330f712c9SDave Chinner ASSERT(cnt == XFS_IFORK_NEXTENTS(ip, whichfork)); 82430f712c9SDave Chinner xfs_btree_set_numrecs(ablock, cnt); 82530f712c9SDave Chinner 82630f712c9SDave Chinner /* 82730f712c9SDave Chinner * Fill in the root key and pointer. 82830f712c9SDave Chinner */ 82930f712c9SDave Chinner kp = XFS_BMBT_KEY_ADDR(mp, block, 1); 83030f712c9SDave Chinner arp = XFS_BMBT_REC_ADDR(mp, ablock, 1); 83130f712c9SDave Chinner kp->br_startoff = cpu_to_be64(xfs_bmbt_disk_get_startoff(arp)); 83230f712c9SDave Chinner pp = XFS_BMBT_PTR_ADDR(mp, block, 1, xfs_bmbt_get_maxrecs(cur, 83330f712c9SDave Chinner be16_to_cpu(block->bb_level))); 83430f712c9SDave Chinner *pp = cpu_to_be64(args.fsbno); 83530f712c9SDave Chinner 83630f712c9SDave Chinner /* 83730f712c9SDave Chinner * Do all this logging at the end so that 83830f712c9SDave Chinner * the root is at the right level. 83930f712c9SDave Chinner */ 84030f712c9SDave Chinner xfs_btree_log_block(cur, abp, XFS_BB_ALL_BITS); 84130f712c9SDave Chinner xfs_btree_log_recs(cur, abp, 1, be16_to_cpu(ablock->bb_numrecs)); 84230f712c9SDave Chinner ASSERT(*curp == NULL); 84330f712c9SDave Chinner *curp = cur; 84430f712c9SDave Chinner *logflagsp = XFS_ILOG_CORE | xfs_ilog_fbroot(whichfork); 84530f712c9SDave Chinner return 0; 84630f712c9SDave Chinner } 84730f712c9SDave Chinner 84830f712c9SDave Chinner /* 84930f712c9SDave Chinner * Convert a local file to an extents file. 85030f712c9SDave Chinner * This code is out of bounds for data forks of regular files, 85130f712c9SDave Chinner * since the file data needs to get logged so things will stay consistent. 85230f712c9SDave Chinner * (The bmap-level manipulations are ok, though). 85330f712c9SDave Chinner */ 85430f712c9SDave Chinner void 85530f712c9SDave Chinner xfs_bmap_local_to_extents_empty( 85630f712c9SDave Chinner struct xfs_inode *ip, 85730f712c9SDave Chinner int whichfork) 85830f712c9SDave Chinner { 85930f712c9SDave Chinner struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, whichfork); 86030f712c9SDave Chinner 86160b4984fSDarrick J. Wong ASSERT(whichfork != XFS_COW_FORK); 86230f712c9SDave Chinner ASSERT(XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_LOCAL); 86330f712c9SDave Chinner ASSERT(ifp->if_bytes == 0); 86430f712c9SDave Chinner ASSERT(XFS_IFORK_NEXTENTS(ip, whichfork) == 0); 86530f712c9SDave Chinner 86630f712c9SDave Chinner xfs_bmap_forkoff_reset(ip, whichfork); 86730f712c9SDave Chinner ifp->if_flags &= ~XFS_IFINLINE; 86830f712c9SDave Chinner ifp->if_flags |= XFS_IFEXTENTS; 86930f712c9SDave Chinner XFS_IFORK_FMT_SET(ip, whichfork, XFS_DINODE_FMT_EXTENTS); 87030f712c9SDave Chinner } 87130f712c9SDave Chinner 87230f712c9SDave Chinner 87330f712c9SDave Chinner STATIC int /* error */ 87430f712c9SDave Chinner xfs_bmap_local_to_extents( 87530f712c9SDave Chinner xfs_trans_t *tp, /* transaction pointer */ 87630f712c9SDave Chinner xfs_inode_t *ip, /* incore inode pointer */ 87730f712c9SDave Chinner xfs_fsblock_t *firstblock, /* first block allocated in xaction */ 87830f712c9SDave Chinner xfs_extlen_t total, /* total blocks needed by transaction */ 87930f712c9SDave Chinner int *logflagsp, /* inode logging flags */ 88030f712c9SDave Chinner int whichfork, 88130f712c9SDave Chinner void (*init_fn)(struct xfs_trans *tp, 88230f712c9SDave Chinner struct xfs_buf *bp, 88330f712c9SDave Chinner struct xfs_inode *ip, 88430f712c9SDave Chinner struct xfs_ifork *ifp)) 88530f712c9SDave Chinner { 88630f712c9SDave Chinner int error = 0; 88730f712c9SDave Chinner int flags; /* logging flags returned */ 88830f712c9SDave Chinner xfs_ifork_t *ifp; /* inode fork pointer */ 88930f712c9SDave Chinner xfs_alloc_arg_t args; /* allocation arguments */ 89030f712c9SDave Chinner xfs_buf_t *bp; /* buffer for extent block */ 89130f712c9SDave Chinner xfs_bmbt_rec_host_t *ep; /* extent record pointer */ 89230f712c9SDave Chinner 89330f712c9SDave Chinner /* 89430f712c9SDave Chinner * We don't want to deal with the case of keeping inode data inline yet. 89530f712c9SDave Chinner * So sending the data fork of a regular inode is invalid. 89630f712c9SDave Chinner */ 897c19b3b05SDave Chinner ASSERT(!(S_ISREG(VFS_I(ip)->i_mode) && whichfork == XFS_DATA_FORK)); 89830f712c9SDave Chinner ifp = XFS_IFORK_PTR(ip, whichfork); 89930f712c9SDave Chinner ASSERT(XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_LOCAL); 90030f712c9SDave Chinner 90130f712c9SDave Chinner if (!ifp->if_bytes) { 90230f712c9SDave Chinner xfs_bmap_local_to_extents_empty(ip, whichfork); 90330f712c9SDave Chinner flags = XFS_ILOG_CORE; 90430f712c9SDave Chinner goto done; 90530f712c9SDave Chinner } 90630f712c9SDave Chinner 90730f712c9SDave Chinner flags = 0; 90830f712c9SDave Chinner error = 0; 90930f712c9SDave Chinner ASSERT((ifp->if_flags & (XFS_IFINLINE|XFS_IFEXTENTS|XFS_IFEXTIREC)) == 91030f712c9SDave Chinner XFS_IFINLINE); 91130f712c9SDave Chinner memset(&args, 0, sizeof(args)); 91230f712c9SDave Chinner args.tp = tp; 91330f712c9SDave Chinner args.mp = ip->i_mount; 914340785ccSDarrick J. Wong xfs_rmap_ino_owner(&args.oinfo, ip->i_ino, whichfork, 0); 91530f712c9SDave Chinner args.firstblock = *firstblock; 91630f712c9SDave Chinner /* 91730f712c9SDave Chinner * Allocate a block. We know we need only one, since the 91830f712c9SDave Chinner * file currently fits in an inode. 91930f712c9SDave Chinner */ 92030f712c9SDave Chinner if (*firstblock == NULLFSBLOCK) { 92190e2056dSDarrick J. Wong try_another_ag: 92230f712c9SDave Chinner args.fsbno = XFS_INO_TO_FSB(args.mp, ip->i_ino); 92330f712c9SDave Chinner args.type = XFS_ALLOCTYPE_START_BNO; 92430f712c9SDave Chinner } else { 92530f712c9SDave Chinner args.fsbno = *firstblock; 92630f712c9SDave Chinner args.type = XFS_ALLOCTYPE_NEAR_BNO; 92730f712c9SDave Chinner } 92830f712c9SDave Chinner args.total = total; 92930f712c9SDave Chinner args.minlen = args.maxlen = args.prod = 1; 93030f712c9SDave Chinner error = xfs_alloc_vextent(&args); 93130f712c9SDave Chinner if (error) 93230f712c9SDave Chinner goto done; 93330f712c9SDave Chinner 93490e2056dSDarrick J. Wong /* 93590e2056dSDarrick J. Wong * During a CoW operation, the allocation and bmbt updates occur in 93690e2056dSDarrick J. Wong * different transactions. The mapping code tries to put new bmbt 93790e2056dSDarrick J. Wong * blocks near extents being mapped, but the only way to guarantee this 93890e2056dSDarrick J. Wong * is if the alloc and the mapping happen in a single transaction that 93990e2056dSDarrick J. Wong * has a block reservation. That isn't the case here, so if we run out 94090e2056dSDarrick J. Wong * of space we'll try again with another AG. 94190e2056dSDarrick J. Wong */ 94290e2056dSDarrick J. Wong if (xfs_sb_version_hasreflink(&ip->i_mount->m_sb) && 94390e2056dSDarrick J. Wong args.fsbno == NULLFSBLOCK && 94490e2056dSDarrick J. Wong args.type == XFS_ALLOCTYPE_NEAR_BNO) { 94590e2056dSDarrick J. Wong goto try_another_ag; 94690e2056dSDarrick J. Wong } 94730f712c9SDave Chinner /* Can't fail, the space was reserved. */ 94830f712c9SDave Chinner ASSERT(args.fsbno != NULLFSBLOCK); 94930f712c9SDave Chinner ASSERT(args.len == 1); 95030f712c9SDave Chinner *firstblock = args.fsbno; 95130f712c9SDave Chinner bp = xfs_btree_get_bufl(args.mp, tp, args.fsbno, 0); 95230f712c9SDave Chinner 953fe22d552SDave Chinner /* 954b7cdc66bSBrian Foster * Initialize the block, copy the data and log the remote buffer. 955fe22d552SDave Chinner * 956b7cdc66bSBrian Foster * The callout is responsible for logging because the remote format 957b7cdc66bSBrian Foster * might differ from the local format and thus we don't know how much to 958b7cdc66bSBrian Foster * log here. Note that init_fn must also set the buffer log item type 959b7cdc66bSBrian Foster * correctly. 960fe22d552SDave Chinner */ 96130f712c9SDave Chinner init_fn(tp, bp, ip, ifp); 96230f712c9SDave Chinner 963b7cdc66bSBrian Foster /* account for the change in fork size */ 96430f712c9SDave Chinner xfs_idata_realloc(ip, -ifp->if_bytes, whichfork); 96530f712c9SDave Chinner xfs_bmap_local_to_extents_empty(ip, whichfork); 96630f712c9SDave Chinner flags |= XFS_ILOG_CORE; 96730f712c9SDave Chinner 96830f712c9SDave Chinner xfs_iext_add(ifp, 0, 1); 96930f712c9SDave Chinner ep = xfs_iext_get_ext(ifp, 0); 97030f712c9SDave Chinner xfs_bmbt_set_allf(ep, 0, args.fsbno, 1, XFS_EXT_NORM); 97130f712c9SDave Chinner trace_xfs_bmap_post_update(ip, 0, 97230f712c9SDave Chinner whichfork == XFS_ATTR_FORK ? BMAP_ATTRFORK : 0, 97330f712c9SDave Chinner _THIS_IP_); 97430f712c9SDave Chinner XFS_IFORK_NEXT_SET(ip, whichfork, 1); 97530f712c9SDave Chinner ip->i_d.di_nblocks = 1; 97630f712c9SDave Chinner xfs_trans_mod_dquot_byino(tp, ip, 97730f712c9SDave Chinner XFS_TRANS_DQ_BCOUNT, 1L); 97830f712c9SDave Chinner flags |= xfs_ilog_fext(whichfork); 97930f712c9SDave Chinner 98030f712c9SDave Chinner done: 98130f712c9SDave Chinner *logflagsp = flags; 98230f712c9SDave Chinner return error; 98330f712c9SDave Chinner } 98430f712c9SDave Chinner 98530f712c9SDave Chinner /* 98630f712c9SDave Chinner * Called from xfs_bmap_add_attrfork to handle btree format files. 98730f712c9SDave Chinner */ 98830f712c9SDave Chinner STATIC int /* error */ 98930f712c9SDave Chinner xfs_bmap_add_attrfork_btree( 99030f712c9SDave Chinner xfs_trans_t *tp, /* transaction pointer */ 99130f712c9SDave Chinner xfs_inode_t *ip, /* incore inode pointer */ 99230f712c9SDave Chinner xfs_fsblock_t *firstblock, /* first block allocated */ 9932c3234d1SDarrick J. Wong struct xfs_defer_ops *dfops, /* blocks to free at commit */ 99430f712c9SDave Chinner int *flags) /* inode logging flags */ 99530f712c9SDave Chinner { 99630f712c9SDave Chinner xfs_btree_cur_t *cur; /* btree cursor */ 99730f712c9SDave Chinner int error; /* error return value */ 99830f712c9SDave Chinner xfs_mount_t *mp; /* file system mount struct */ 99930f712c9SDave Chinner int stat; /* newroot status */ 100030f712c9SDave Chinner 100130f712c9SDave Chinner mp = ip->i_mount; 100230f712c9SDave Chinner if (ip->i_df.if_broot_bytes <= XFS_IFORK_DSIZE(ip)) 100330f712c9SDave Chinner *flags |= XFS_ILOG_DBROOT; 100430f712c9SDave Chinner else { 100530f712c9SDave Chinner cur = xfs_bmbt_init_cursor(mp, tp, ip, XFS_DATA_FORK); 10062c3234d1SDarrick J. Wong cur->bc_private.b.dfops = dfops; 100730f712c9SDave Chinner cur->bc_private.b.firstblock = *firstblock; 100830f712c9SDave Chinner if ((error = xfs_bmbt_lookup_ge(cur, 0, 0, 0, &stat))) 100930f712c9SDave Chinner goto error0; 101030f712c9SDave Chinner /* must be at least one entry */ 1011c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, stat == 1, error0); 101230f712c9SDave Chinner if ((error = xfs_btree_new_iroot(cur, flags, &stat))) 101330f712c9SDave Chinner goto error0; 101430f712c9SDave Chinner if (stat == 0) { 101530f712c9SDave Chinner xfs_btree_del_cursor(cur, XFS_BTREE_NOERROR); 10162451337dSDave Chinner return -ENOSPC; 101730f712c9SDave Chinner } 101830f712c9SDave Chinner *firstblock = cur->bc_private.b.firstblock; 101930f712c9SDave Chinner cur->bc_private.b.allocated = 0; 102030f712c9SDave Chinner xfs_btree_del_cursor(cur, XFS_BTREE_NOERROR); 102130f712c9SDave Chinner } 102230f712c9SDave Chinner return 0; 102330f712c9SDave Chinner error0: 102430f712c9SDave Chinner xfs_btree_del_cursor(cur, XFS_BTREE_ERROR); 102530f712c9SDave Chinner return error; 102630f712c9SDave Chinner } 102730f712c9SDave Chinner 102830f712c9SDave Chinner /* 102930f712c9SDave Chinner * Called from xfs_bmap_add_attrfork to handle extents format files. 103030f712c9SDave Chinner */ 103130f712c9SDave Chinner STATIC int /* error */ 103230f712c9SDave Chinner xfs_bmap_add_attrfork_extents( 103330f712c9SDave Chinner xfs_trans_t *tp, /* transaction pointer */ 103430f712c9SDave Chinner xfs_inode_t *ip, /* incore inode pointer */ 103530f712c9SDave Chinner xfs_fsblock_t *firstblock, /* first block allocated */ 10362c3234d1SDarrick J. Wong struct xfs_defer_ops *dfops, /* blocks to free at commit */ 103730f712c9SDave Chinner int *flags) /* inode logging flags */ 103830f712c9SDave Chinner { 103930f712c9SDave Chinner xfs_btree_cur_t *cur; /* bmap btree cursor */ 104030f712c9SDave Chinner int error; /* error return value */ 104130f712c9SDave Chinner 104230f712c9SDave Chinner if (ip->i_d.di_nextents * sizeof(xfs_bmbt_rec_t) <= XFS_IFORK_DSIZE(ip)) 104330f712c9SDave Chinner return 0; 104430f712c9SDave Chinner cur = NULL; 10452c3234d1SDarrick J. Wong error = xfs_bmap_extents_to_btree(tp, ip, firstblock, dfops, &cur, 0, 104630f712c9SDave Chinner flags, XFS_DATA_FORK); 104730f712c9SDave Chinner if (cur) { 104830f712c9SDave Chinner cur->bc_private.b.allocated = 0; 104930f712c9SDave Chinner xfs_btree_del_cursor(cur, 105030f712c9SDave Chinner error ? XFS_BTREE_ERROR : XFS_BTREE_NOERROR); 105130f712c9SDave Chinner } 105230f712c9SDave Chinner return error; 105330f712c9SDave Chinner } 105430f712c9SDave Chinner 105530f712c9SDave Chinner /* 105630f712c9SDave Chinner * Called from xfs_bmap_add_attrfork to handle local format files. Each 105730f712c9SDave Chinner * different data fork content type needs a different callout to do the 105830f712c9SDave Chinner * conversion. Some are basic and only require special block initialisation 105930f712c9SDave Chinner * callouts for the data formating, others (directories) are so specialised they 106030f712c9SDave Chinner * handle everything themselves. 106130f712c9SDave Chinner * 106230f712c9SDave Chinner * XXX (dgc): investigate whether directory conversion can use the generic 106330f712c9SDave Chinner * formatting callout. It should be possible - it's just a very complex 106430f712c9SDave Chinner * formatter. 106530f712c9SDave Chinner */ 106630f712c9SDave Chinner STATIC int /* error */ 106730f712c9SDave Chinner xfs_bmap_add_attrfork_local( 106830f712c9SDave Chinner xfs_trans_t *tp, /* transaction pointer */ 106930f712c9SDave Chinner xfs_inode_t *ip, /* incore inode pointer */ 107030f712c9SDave Chinner xfs_fsblock_t *firstblock, /* first block allocated */ 10712c3234d1SDarrick J. Wong struct xfs_defer_ops *dfops, /* blocks to free at commit */ 107230f712c9SDave Chinner int *flags) /* inode logging flags */ 107330f712c9SDave Chinner { 107430f712c9SDave Chinner xfs_da_args_t dargs; /* args for dir/attr code */ 107530f712c9SDave Chinner 107630f712c9SDave Chinner if (ip->i_df.if_bytes <= XFS_IFORK_DSIZE(ip)) 107730f712c9SDave Chinner return 0; 107830f712c9SDave Chinner 1079c19b3b05SDave Chinner if (S_ISDIR(VFS_I(ip)->i_mode)) { 108030f712c9SDave Chinner memset(&dargs, 0, sizeof(dargs)); 108130f712c9SDave Chinner dargs.geo = ip->i_mount->m_dir_geo; 108230f712c9SDave Chinner dargs.dp = ip; 108330f712c9SDave Chinner dargs.firstblock = firstblock; 10842c3234d1SDarrick J. Wong dargs.dfops = dfops; 108530f712c9SDave Chinner dargs.total = dargs.geo->fsbcount; 108630f712c9SDave Chinner dargs.whichfork = XFS_DATA_FORK; 108730f712c9SDave Chinner dargs.trans = tp; 108830f712c9SDave Chinner return xfs_dir2_sf_to_block(&dargs); 108930f712c9SDave Chinner } 109030f712c9SDave Chinner 1091c19b3b05SDave Chinner if (S_ISLNK(VFS_I(ip)->i_mode)) 109230f712c9SDave Chinner return xfs_bmap_local_to_extents(tp, ip, firstblock, 1, 109330f712c9SDave Chinner flags, XFS_DATA_FORK, 109430f712c9SDave Chinner xfs_symlink_local_to_remote); 109530f712c9SDave Chinner 109630f712c9SDave Chinner /* should only be called for types that support local format data */ 109730f712c9SDave Chinner ASSERT(0); 10982451337dSDave Chinner return -EFSCORRUPTED; 109930f712c9SDave Chinner } 110030f712c9SDave Chinner 110130f712c9SDave Chinner /* 110230f712c9SDave Chinner * Convert inode from non-attributed to attributed. 110330f712c9SDave Chinner * Must not be in a transaction, ip must not be locked. 110430f712c9SDave Chinner */ 110530f712c9SDave Chinner int /* error code */ 110630f712c9SDave Chinner xfs_bmap_add_attrfork( 110730f712c9SDave Chinner xfs_inode_t *ip, /* incore inode pointer */ 110830f712c9SDave Chinner int size, /* space new attribute needs */ 110930f712c9SDave Chinner int rsvd) /* xact may use reserved blks */ 111030f712c9SDave Chinner { 111130f712c9SDave Chinner xfs_fsblock_t firstblock; /* 1st block/ag allocated */ 11122c3234d1SDarrick J. Wong struct xfs_defer_ops dfops; /* freed extent records */ 111330f712c9SDave Chinner xfs_mount_t *mp; /* mount structure */ 111430f712c9SDave Chinner xfs_trans_t *tp; /* transaction pointer */ 111530f712c9SDave Chinner int blks; /* space reservation */ 111630f712c9SDave Chinner int version = 1; /* superblock attr version */ 111730f712c9SDave Chinner int logflags; /* logging flags */ 111830f712c9SDave Chinner int error; /* error return value */ 111930f712c9SDave Chinner 112030f712c9SDave Chinner ASSERT(XFS_IFORK_Q(ip) == 0); 112130f712c9SDave Chinner 112230f712c9SDave Chinner mp = ip->i_mount; 112330f712c9SDave Chinner ASSERT(!XFS_NOT_DQATTACHED(mp, ip)); 1124253f4911SChristoph Hellwig 112530f712c9SDave Chinner blks = XFS_ADDAFORK_SPACE_RES(mp); 1126253f4911SChristoph Hellwig 1127253f4911SChristoph Hellwig error = xfs_trans_alloc(mp, &M_RES(mp)->tr_addafork, blks, 0, 1128253f4911SChristoph Hellwig rsvd ? XFS_TRANS_RESERVE : 0, &tp); 1129253f4911SChristoph Hellwig if (error) 113030f712c9SDave Chinner return error; 1131253f4911SChristoph Hellwig 113230f712c9SDave Chinner xfs_ilock(ip, XFS_ILOCK_EXCL); 113330f712c9SDave Chinner error = xfs_trans_reserve_quota_nblks(tp, ip, blks, 0, rsvd ? 113430f712c9SDave Chinner XFS_QMOPT_RES_REGBLKS | XFS_QMOPT_FORCE_RES : 113530f712c9SDave Chinner XFS_QMOPT_RES_REGBLKS); 113630f712c9SDave Chinner if (error) 113730f712c9SDave Chinner goto trans_cancel; 113830f712c9SDave Chinner if (XFS_IFORK_Q(ip)) 113930f712c9SDave Chinner goto trans_cancel; 114030f712c9SDave Chinner if (ip->i_d.di_aformat != XFS_DINODE_FMT_EXTENTS) { 114130f712c9SDave Chinner /* 114230f712c9SDave Chinner * For inodes coming from pre-6.2 filesystems. 114330f712c9SDave Chinner */ 114430f712c9SDave Chinner ASSERT(ip->i_d.di_aformat == 0); 114530f712c9SDave Chinner ip->i_d.di_aformat = XFS_DINODE_FMT_EXTENTS; 114630f712c9SDave Chinner } 114730f712c9SDave Chinner ASSERT(ip->i_d.di_anextents == 0); 114830f712c9SDave Chinner 114930f712c9SDave Chinner xfs_trans_ijoin(tp, ip, 0); 115030f712c9SDave Chinner xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE); 115130f712c9SDave Chinner 115230f712c9SDave Chinner switch (ip->i_d.di_format) { 115330f712c9SDave Chinner case XFS_DINODE_FMT_DEV: 115430f712c9SDave Chinner ip->i_d.di_forkoff = roundup(sizeof(xfs_dev_t), 8) >> 3; 115530f712c9SDave Chinner break; 115630f712c9SDave Chinner case XFS_DINODE_FMT_UUID: 115730f712c9SDave Chinner ip->i_d.di_forkoff = roundup(sizeof(uuid_t), 8) >> 3; 115830f712c9SDave Chinner break; 115930f712c9SDave Chinner case XFS_DINODE_FMT_LOCAL: 116030f712c9SDave Chinner case XFS_DINODE_FMT_EXTENTS: 116130f712c9SDave Chinner case XFS_DINODE_FMT_BTREE: 116230f712c9SDave Chinner ip->i_d.di_forkoff = xfs_attr_shortform_bytesfit(ip, size); 116330f712c9SDave Chinner if (!ip->i_d.di_forkoff) 116430f712c9SDave Chinner ip->i_d.di_forkoff = xfs_default_attroffset(ip) >> 3; 116530f712c9SDave Chinner else if (mp->m_flags & XFS_MOUNT_ATTR2) 116630f712c9SDave Chinner version = 2; 116730f712c9SDave Chinner break; 116830f712c9SDave Chinner default: 116930f712c9SDave Chinner ASSERT(0); 11702451337dSDave Chinner error = -EINVAL; 117130f712c9SDave Chinner goto trans_cancel; 117230f712c9SDave Chinner } 117330f712c9SDave Chinner 117430f712c9SDave Chinner ASSERT(ip->i_afp == NULL); 117530f712c9SDave Chinner ip->i_afp = kmem_zone_zalloc(xfs_ifork_zone, KM_SLEEP); 117630f712c9SDave Chinner ip->i_afp->if_flags = XFS_IFEXTENTS; 117730f712c9SDave Chinner logflags = 0; 11782c3234d1SDarrick J. Wong xfs_defer_init(&dfops, &firstblock); 117930f712c9SDave Chinner switch (ip->i_d.di_format) { 118030f712c9SDave Chinner case XFS_DINODE_FMT_LOCAL: 11812c3234d1SDarrick J. Wong error = xfs_bmap_add_attrfork_local(tp, ip, &firstblock, &dfops, 118230f712c9SDave Chinner &logflags); 118330f712c9SDave Chinner break; 118430f712c9SDave Chinner case XFS_DINODE_FMT_EXTENTS: 118530f712c9SDave Chinner error = xfs_bmap_add_attrfork_extents(tp, ip, &firstblock, 11862c3234d1SDarrick J. Wong &dfops, &logflags); 118730f712c9SDave Chinner break; 118830f712c9SDave Chinner case XFS_DINODE_FMT_BTREE: 11892c3234d1SDarrick J. Wong error = xfs_bmap_add_attrfork_btree(tp, ip, &firstblock, &dfops, 119030f712c9SDave Chinner &logflags); 119130f712c9SDave Chinner break; 119230f712c9SDave Chinner default: 119330f712c9SDave Chinner error = 0; 119430f712c9SDave Chinner break; 119530f712c9SDave Chinner } 119630f712c9SDave Chinner if (logflags) 119730f712c9SDave Chinner xfs_trans_log_inode(tp, ip, logflags); 119830f712c9SDave Chinner if (error) 119930f712c9SDave Chinner goto bmap_cancel; 120030f712c9SDave Chinner if (!xfs_sb_version_hasattr(&mp->m_sb) || 120130f712c9SDave Chinner (!xfs_sb_version_hasattr2(&mp->m_sb) && version == 2)) { 120261e63ecbSDave Chinner bool log_sb = false; 120330f712c9SDave Chinner 120430f712c9SDave Chinner spin_lock(&mp->m_sb_lock); 120530f712c9SDave Chinner if (!xfs_sb_version_hasattr(&mp->m_sb)) { 120630f712c9SDave Chinner xfs_sb_version_addattr(&mp->m_sb); 120761e63ecbSDave Chinner log_sb = true; 120830f712c9SDave Chinner } 120930f712c9SDave Chinner if (!xfs_sb_version_hasattr2(&mp->m_sb) && version == 2) { 121030f712c9SDave Chinner xfs_sb_version_addattr2(&mp->m_sb); 121161e63ecbSDave Chinner log_sb = true; 121230f712c9SDave Chinner } 121330f712c9SDave Chinner spin_unlock(&mp->m_sb_lock); 121461e63ecbSDave Chinner if (log_sb) 121561e63ecbSDave Chinner xfs_log_sb(tp); 121630f712c9SDave Chinner } 121730f712c9SDave Chinner 12182c3234d1SDarrick J. Wong error = xfs_defer_finish(&tp, &dfops, NULL); 121930f712c9SDave Chinner if (error) 122030f712c9SDave Chinner goto bmap_cancel; 122170393313SChristoph Hellwig error = xfs_trans_commit(tp); 122230f712c9SDave Chinner xfs_iunlock(ip, XFS_ILOCK_EXCL); 122330f712c9SDave Chinner return error; 122430f712c9SDave Chinner 122530f712c9SDave Chinner bmap_cancel: 12262c3234d1SDarrick J. Wong xfs_defer_cancel(&dfops); 122730f712c9SDave Chinner trans_cancel: 12284906e215SChristoph Hellwig xfs_trans_cancel(tp); 122930f712c9SDave Chinner xfs_iunlock(ip, XFS_ILOCK_EXCL); 123030f712c9SDave Chinner return error; 123130f712c9SDave Chinner } 123230f712c9SDave Chinner 123330f712c9SDave Chinner /* 123430f712c9SDave Chinner * Internal and external extent tree search functions. 123530f712c9SDave Chinner */ 123630f712c9SDave Chinner 123730f712c9SDave Chinner /* 123830f712c9SDave Chinner * Read in the extents to if_extents. 123930f712c9SDave Chinner * All inode fields are set up by caller, we just traverse the btree 124030f712c9SDave Chinner * and copy the records in. If the file system cannot contain unwritten 124130f712c9SDave Chinner * extents, the records are checked for no "state" flags. 124230f712c9SDave Chinner */ 124330f712c9SDave Chinner int /* error */ 124430f712c9SDave Chinner xfs_bmap_read_extents( 124530f712c9SDave Chinner xfs_trans_t *tp, /* transaction pointer */ 124630f712c9SDave Chinner xfs_inode_t *ip, /* incore inode */ 124730f712c9SDave Chinner int whichfork) /* data or attr fork */ 124830f712c9SDave Chinner { 124930f712c9SDave Chinner struct xfs_btree_block *block; /* current btree block */ 125030f712c9SDave Chinner xfs_fsblock_t bno; /* block # of "block" */ 125130f712c9SDave Chinner xfs_buf_t *bp; /* buffer for "block" */ 125230f712c9SDave Chinner int error; /* error return value */ 125330f712c9SDave Chinner xfs_exntfmt_t exntf; /* XFS_EXTFMT_NOSTATE, if checking */ 125430f712c9SDave Chinner xfs_extnum_t i, j; /* index into the extents list */ 125530f712c9SDave Chinner xfs_ifork_t *ifp; /* fork structure */ 125630f712c9SDave Chinner int level; /* btree level, for checking */ 125730f712c9SDave Chinner xfs_mount_t *mp; /* file system mount structure */ 125830f712c9SDave Chinner __be64 *pp; /* pointer to block address */ 125930f712c9SDave Chinner /* REFERENCED */ 126030f712c9SDave Chinner xfs_extnum_t room; /* number of entries there's room for */ 126130f712c9SDave Chinner 126230f712c9SDave Chinner bno = NULLFSBLOCK; 126330f712c9SDave Chinner mp = ip->i_mount; 126430f712c9SDave Chinner ifp = XFS_IFORK_PTR(ip, whichfork); 126530f712c9SDave Chinner exntf = (whichfork != XFS_DATA_FORK) ? XFS_EXTFMT_NOSTATE : 126630f712c9SDave Chinner XFS_EXTFMT_INODE(ip); 126730f712c9SDave Chinner block = ifp->if_broot; 126830f712c9SDave Chinner /* 126930f712c9SDave Chinner * Root level must use BMAP_BROOT_PTR_ADDR macro to get ptr out. 127030f712c9SDave Chinner */ 127130f712c9SDave Chinner level = be16_to_cpu(block->bb_level); 127230f712c9SDave Chinner ASSERT(level > 0); 127330f712c9SDave Chinner pp = XFS_BMAP_BROOT_PTR_ADDR(mp, block, 1, ifp->if_broot_bytes); 127430f712c9SDave Chinner bno = be64_to_cpu(*pp); 1275d5cf09baSChristoph Hellwig ASSERT(bno != NULLFSBLOCK); 127630f712c9SDave Chinner ASSERT(XFS_FSB_TO_AGNO(mp, bno) < mp->m_sb.sb_agcount); 127730f712c9SDave Chinner ASSERT(XFS_FSB_TO_AGBNO(mp, bno) < mp->m_sb.sb_agblocks); 127830f712c9SDave Chinner /* 127930f712c9SDave Chinner * Go down the tree until leaf level is reached, following the first 128030f712c9SDave Chinner * pointer (leftmost) at each level. 128130f712c9SDave Chinner */ 128230f712c9SDave Chinner while (level-- > 0) { 128330f712c9SDave Chinner error = xfs_btree_read_bufl(mp, tp, bno, 0, &bp, 128430f712c9SDave Chinner XFS_BMAP_BTREE_REF, &xfs_bmbt_buf_ops); 128530f712c9SDave Chinner if (error) 128630f712c9SDave Chinner return error; 128730f712c9SDave Chinner block = XFS_BUF_TO_BLOCK(bp); 128830f712c9SDave Chinner if (level == 0) 128930f712c9SDave Chinner break; 129030f712c9SDave Chinner pp = XFS_BMBT_PTR_ADDR(mp, block, 1, mp->m_bmap_dmxr[1]); 129130f712c9SDave Chinner bno = be64_to_cpu(*pp); 1292c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, 1293c29aad41SEric Sandeen XFS_FSB_SANITY_CHECK(mp, bno), error0); 129430f712c9SDave Chinner xfs_trans_brelse(tp, bp); 129530f712c9SDave Chinner } 129630f712c9SDave Chinner /* 129730f712c9SDave Chinner * Here with bp and block set to the leftmost leaf node in the tree. 129830f712c9SDave Chinner */ 129930f712c9SDave Chinner room = ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t); 130030f712c9SDave Chinner i = 0; 130130f712c9SDave Chinner /* 130230f712c9SDave Chinner * Loop over all leaf nodes. Copy information to the extent records. 130330f712c9SDave Chinner */ 130430f712c9SDave Chinner for (;;) { 130530f712c9SDave Chinner xfs_bmbt_rec_t *frp; 130630f712c9SDave Chinner xfs_fsblock_t nextbno; 130730f712c9SDave Chinner xfs_extnum_t num_recs; 130830f712c9SDave Chinner xfs_extnum_t start; 130930f712c9SDave Chinner 131030f712c9SDave Chinner num_recs = xfs_btree_get_numrecs(block); 131130f712c9SDave Chinner if (unlikely(i + num_recs > room)) { 131230f712c9SDave Chinner ASSERT(i + num_recs <= room); 131330f712c9SDave Chinner xfs_warn(ip->i_mount, 131430f712c9SDave Chinner "corrupt dinode %Lu, (btree extents).", 131530f712c9SDave Chinner (unsigned long long) ip->i_ino); 131630f712c9SDave Chinner XFS_CORRUPTION_ERROR("xfs_bmap_read_extents(1)", 131730f712c9SDave Chinner XFS_ERRLEVEL_LOW, ip->i_mount, block); 131830f712c9SDave Chinner goto error0; 131930f712c9SDave Chinner } 132030f712c9SDave Chinner /* 132130f712c9SDave Chinner * Read-ahead the next leaf block, if any. 132230f712c9SDave Chinner */ 132330f712c9SDave Chinner nextbno = be64_to_cpu(block->bb_u.l.bb_rightsib); 132430f712c9SDave Chinner if (nextbno != NULLFSBLOCK) 132530f712c9SDave Chinner xfs_btree_reada_bufl(mp, nextbno, 1, 132630f712c9SDave Chinner &xfs_bmbt_buf_ops); 132730f712c9SDave Chinner /* 132830f712c9SDave Chinner * Copy records into the extent records. 132930f712c9SDave Chinner */ 133030f712c9SDave Chinner frp = XFS_BMBT_REC_ADDR(mp, block, 1); 133130f712c9SDave Chinner start = i; 133230f712c9SDave Chinner for (j = 0; j < num_recs; j++, i++, frp++) { 133330f712c9SDave Chinner xfs_bmbt_rec_host_t *trp = xfs_iext_get_ext(ifp, i); 133430f712c9SDave Chinner trp->l0 = be64_to_cpu(frp->l0); 133530f712c9SDave Chinner trp->l1 = be64_to_cpu(frp->l1); 133630f712c9SDave Chinner } 133730f712c9SDave Chinner if (exntf == XFS_EXTFMT_NOSTATE) { 133830f712c9SDave Chinner /* 133930f712c9SDave Chinner * Check all attribute bmap btree records and 134030f712c9SDave Chinner * any "older" data bmap btree records for a 134130f712c9SDave Chinner * set bit in the "extent flag" position. 134230f712c9SDave Chinner */ 134330f712c9SDave Chinner if (unlikely(xfs_check_nostate_extents(ifp, 134430f712c9SDave Chinner start, num_recs))) { 134530f712c9SDave Chinner XFS_ERROR_REPORT("xfs_bmap_read_extents(2)", 134630f712c9SDave Chinner XFS_ERRLEVEL_LOW, 134730f712c9SDave Chinner ip->i_mount); 134830f712c9SDave Chinner goto error0; 134930f712c9SDave Chinner } 135030f712c9SDave Chinner } 135130f712c9SDave Chinner xfs_trans_brelse(tp, bp); 135230f712c9SDave Chinner bno = nextbno; 135330f712c9SDave Chinner /* 135430f712c9SDave Chinner * If we've reached the end, stop. 135530f712c9SDave Chinner */ 135630f712c9SDave Chinner if (bno == NULLFSBLOCK) 135730f712c9SDave Chinner break; 135830f712c9SDave Chinner error = xfs_btree_read_bufl(mp, tp, bno, 0, &bp, 135930f712c9SDave Chinner XFS_BMAP_BTREE_REF, &xfs_bmbt_buf_ops); 136030f712c9SDave Chinner if (error) 136130f712c9SDave Chinner return error; 136230f712c9SDave Chinner block = XFS_BUF_TO_BLOCK(bp); 136330f712c9SDave Chinner } 136430f712c9SDave Chinner ASSERT(i == (ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t))); 136530f712c9SDave Chinner ASSERT(i == XFS_IFORK_NEXTENTS(ip, whichfork)); 136630f712c9SDave Chinner XFS_BMAP_TRACE_EXLIST(ip, i, whichfork); 136730f712c9SDave Chinner return 0; 136830f712c9SDave Chinner error0: 136930f712c9SDave Chinner xfs_trans_brelse(tp, bp); 13702451337dSDave Chinner return -EFSCORRUPTED; 137130f712c9SDave Chinner } 137230f712c9SDave Chinner 137330f712c9SDave Chinner 137430f712c9SDave Chinner /* 137530f712c9SDave Chinner * Search the extent records for the entry containing block bno. 137630f712c9SDave Chinner * If bno lies in a hole, point to the next entry. If bno lies 137730f712c9SDave Chinner * past eof, *eofp will be set, and *prevp will contain the last 137830f712c9SDave Chinner * entry (null if none). Else, *lastxp will be set to the index 137930f712c9SDave Chinner * of the found entry; *gotp will contain the entry. 138030f712c9SDave Chinner */ 138130f712c9SDave Chinner STATIC xfs_bmbt_rec_host_t * /* pointer to found extent entry */ 138230f712c9SDave Chinner xfs_bmap_search_multi_extents( 138330f712c9SDave Chinner xfs_ifork_t *ifp, /* inode fork pointer */ 138430f712c9SDave Chinner xfs_fileoff_t bno, /* block number searched for */ 138530f712c9SDave Chinner int *eofp, /* out: end of file found */ 138630f712c9SDave Chinner xfs_extnum_t *lastxp, /* out: last extent index */ 138730f712c9SDave Chinner xfs_bmbt_irec_t *gotp, /* out: extent entry found */ 138830f712c9SDave Chinner xfs_bmbt_irec_t *prevp) /* out: previous extent entry found */ 138930f712c9SDave Chinner { 139030f712c9SDave Chinner xfs_bmbt_rec_host_t *ep; /* extent record pointer */ 139130f712c9SDave Chinner xfs_extnum_t lastx; /* last extent index */ 139230f712c9SDave Chinner 139330f712c9SDave Chinner /* 139430f712c9SDave Chinner * Initialize the extent entry structure to catch access to 139530f712c9SDave Chinner * uninitialized br_startblock field. 139630f712c9SDave Chinner */ 139730f712c9SDave Chinner gotp->br_startoff = 0xffa5a5a5a5a5a5a5LL; 139830f712c9SDave Chinner gotp->br_blockcount = 0xa55a5a5a5a5a5a5aLL; 139930f712c9SDave Chinner gotp->br_state = XFS_EXT_INVALID; 140030f712c9SDave Chinner gotp->br_startblock = 0xffffa5a5a5a5a5a5LL; 140130f712c9SDave Chinner prevp->br_startoff = NULLFILEOFF; 140230f712c9SDave Chinner 140330f712c9SDave Chinner ep = xfs_iext_bno_to_ext(ifp, bno, &lastx); 140430f712c9SDave Chinner if (lastx > 0) { 140530f712c9SDave Chinner xfs_bmbt_get_all(xfs_iext_get_ext(ifp, lastx - 1), prevp); 140630f712c9SDave Chinner } 140730f712c9SDave Chinner if (lastx < (ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t))) { 140830f712c9SDave Chinner xfs_bmbt_get_all(ep, gotp); 140930f712c9SDave Chinner *eofp = 0; 141030f712c9SDave Chinner } else { 141130f712c9SDave Chinner if (lastx > 0) { 141230f712c9SDave Chinner *gotp = *prevp; 141330f712c9SDave Chinner } 141430f712c9SDave Chinner *eofp = 1; 141530f712c9SDave Chinner ep = NULL; 141630f712c9SDave Chinner } 141730f712c9SDave Chinner *lastxp = lastx; 141830f712c9SDave Chinner return ep; 141930f712c9SDave Chinner } 142030f712c9SDave Chinner 142130f712c9SDave Chinner /* 142230f712c9SDave Chinner * Search the extents list for the inode, for the extent containing bno. 142330f712c9SDave Chinner * If bno lies in a hole, point to the next entry. If bno lies past eof, 142430f712c9SDave Chinner * *eofp will be set, and *prevp will contain the last entry (null if none). 142530f712c9SDave Chinner * Else, *lastxp will be set to the index of the found 142630f712c9SDave Chinner * entry; *gotp will contain the entry. 142730f712c9SDave Chinner */ 142851446f5bSChristoph Hellwig xfs_bmbt_rec_host_t * /* pointer to found extent entry */ 142930f712c9SDave Chinner xfs_bmap_search_extents( 143030f712c9SDave Chinner xfs_inode_t *ip, /* incore inode pointer */ 143130f712c9SDave Chinner xfs_fileoff_t bno, /* block number searched for */ 143230f712c9SDave Chinner int fork, /* data or attr fork */ 143330f712c9SDave Chinner int *eofp, /* out: end of file found */ 143430f712c9SDave Chinner xfs_extnum_t *lastxp, /* out: last extent index */ 143530f712c9SDave Chinner xfs_bmbt_irec_t *gotp, /* out: extent entry found */ 143630f712c9SDave Chinner xfs_bmbt_irec_t *prevp) /* out: previous extent entry found */ 143730f712c9SDave Chinner { 143830f712c9SDave Chinner xfs_ifork_t *ifp; /* inode fork pointer */ 143930f712c9SDave Chinner xfs_bmbt_rec_host_t *ep; /* extent record pointer */ 144030f712c9SDave Chinner 1441ff6d6af2SBill O'Donnell XFS_STATS_INC(ip->i_mount, xs_look_exlist); 144230f712c9SDave Chinner ifp = XFS_IFORK_PTR(ip, fork); 144330f712c9SDave Chinner 144430f712c9SDave Chinner ep = xfs_bmap_search_multi_extents(ifp, bno, eofp, lastxp, gotp, prevp); 144530f712c9SDave Chinner 144630f712c9SDave Chinner if (unlikely(!(gotp->br_startblock) && (*lastxp != NULLEXTNUM) && 144730f712c9SDave Chinner !(XFS_IS_REALTIME_INODE(ip) && fork == XFS_DATA_FORK))) { 144830f712c9SDave Chinner xfs_alert_tag(ip->i_mount, XFS_PTAG_FSBLOCK_ZERO, 144930f712c9SDave Chinner "Access to block zero in inode %llu " 145030f712c9SDave Chinner "start_block: %llx start_off: %llx " 145130f712c9SDave Chinner "blkcnt: %llx extent-state: %x lastx: %x", 145230f712c9SDave Chinner (unsigned long long)ip->i_ino, 145330f712c9SDave Chinner (unsigned long long)gotp->br_startblock, 145430f712c9SDave Chinner (unsigned long long)gotp->br_startoff, 145530f712c9SDave Chinner (unsigned long long)gotp->br_blockcount, 145630f712c9SDave Chinner gotp->br_state, *lastxp); 145730f712c9SDave Chinner *lastxp = NULLEXTNUM; 145830f712c9SDave Chinner *eofp = 1; 145930f712c9SDave Chinner return NULL; 146030f712c9SDave Chinner } 146130f712c9SDave Chinner return ep; 146230f712c9SDave Chinner } 146330f712c9SDave Chinner 146430f712c9SDave Chinner /* 146530f712c9SDave Chinner * Returns the file-relative block number of the first unused block(s) 146630f712c9SDave Chinner * in the file with at least "len" logically contiguous blocks free. 146730f712c9SDave Chinner * This is the lowest-address hole if the file has holes, else the first block 146830f712c9SDave Chinner * past the end of file. 146930f712c9SDave Chinner * Return 0 if the file is currently local (in-inode). 147030f712c9SDave Chinner */ 147130f712c9SDave Chinner int /* error */ 147230f712c9SDave Chinner xfs_bmap_first_unused( 147330f712c9SDave Chinner xfs_trans_t *tp, /* transaction pointer */ 147430f712c9SDave Chinner xfs_inode_t *ip, /* incore inode */ 147530f712c9SDave Chinner xfs_extlen_t len, /* size of hole to find */ 147630f712c9SDave Chinner xfs_fileoff_t *first_unused, /* unused block */ 147730f712c9SDave Chinner int whichfork) /* data or attr fork */ 147830f712c9SDave Chinner { 147930f712c9SDave Chinner int error; /* error return value */ 148030f712c9SDave Chinner int idx; /* extent record index */ 148130f712c9SDave Chinner xfs_ifork_t *ifp; /* inode fork pointer */ 148230f712c9SDave Chinner xfs_fileoff_t lastaddr; /* last block number seen */ 148330f712c9SDave Chinner xfs_fileoff_t lowest; /* lowest useful block */ 148430f712c9SDave Chinner xfs_fileoff_t max; /* starting useful block */ 148530f712c9SDave Chinner xfs_fileoff_t off; /* offset for this block */ 148630f712c9SDave Chinner xfs_extnum_t nextents; /* number of extent entries */ 148730f712c9SDave Chinner 148830f712c9SDave Chinner ASSERT(XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_BTREE || 148930f712c9SDave Chinner XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_EXTENTS || 149030f712c9SDave Chinner XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_LOCAL); 149130f712c9SDave Chinner if (XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_LOCAL) { 149230f712c9SDave Chinner *first_unused = 0; 149330f712c9SDave Chinner return 0; 149430f712c9SDave Chinner } 149530f712c9SDave Chinner ifp = XFS_IFORK_PTR(ip, whichfork); 149630f712c9SDave Chinner if (!(ifp->if_flags & XFS_IFEXTENTS) && 149730f712c9SDave Chinner (error = xfs_iread_extents(tp, ip, whichfork))) 149830f712c9SDave Chinner return error; 149930f712c9SDave Chinner lowest = *first_unused; 150030f712c9SDave Chinner nextents = ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t); 150130f712c9SDave Chinner for (idx = 0, lastaddr = 0, max = lowest; idx < nextents; idx++) { 150230f712c9SDave Chinner xfs_bmbt_rec_host_t *ep = xfs_iext_get_ext(ifp, idx); 150330f712c9SDave Chinner off = xfs_bmbt_get_startoff(ep); 150430f712c9SDave Chinner /* 150530f712c9SDave Chinner * See if the hole before this extent will work. 150630f712c9SDave Chinner */ 150730f712c9SDave Chinner if (off >= lowest + len && off - max >= len) { 150830f712c9SDave Chinner *first_unused = max; 150930f712c9SDave Chinner return 0; 151030f712c9SDave Chinner } 151130f712c9SDave Chinner lastaddr = off + xfs_bmbt_get_blockcount(ep); 151230f712c9SDave Chinner max = XFS_FILEOFF_MAX(lastaddr, lowest); 151330f712c9SDave Chinner } 151430f712c9SDave Chinner *first_unused = max; 151530f712c9SDave Chinner return 0; 151630f712c9SDave Chinner } 151730f712c9SDave Chinner 151830f712c9SDave Chinner /* 151930f712c9SDave Chinner * Returns the file-relative block number of the last block - 1 before 152030f712c9SDave Chinner * last_block (input value) in the file. 152130f712c9SDave Chinner * This is not based on i_size, it is based on the extent records. 152230f712c9SDave Chinner * Returns 0 for local files, as they do not have extent records. 152330f712c9SDave Chinner */ 152430f712c9SDave Chinner int /* error */ 152530f712c9SDave Chinner xfs_bmap_last_before( 152630f712c9SDave Chinner xfs_trans_t *tp, /* transaction pointer */ 152730f712c9SDave Chinner xfs_inode_t *ip, /* incore inode */ 152830f712c9SDave Chinner xfs_fileoff_t *last_block, /* last block */ 152930f712c9SDave Chinner int whichfork) /* data or attr fork */ 153030f712c9SDave Chinner { 153130f712c9SDave Chinner xfs_fileoff_t bno; /* input file offset */ 153230f712c9SDave Chinner int eof; /* hit end of file */ 153330f712c9SDave Chinner xfs_bmbt_rec_host_t *ep; /* pointer to last extent */ 153430f712c9SDave Chinner int error; /* error return value */ 153530f712c9SDave Chinner xfs_bmbt_irec_t got; /* current extent value */ 153630f712c9SDave Chinner xfs_ifork_t *ifp; /* inode fork pointer */ 153730f712c9SDave Chinner xfs_extnum_t lastx; /* last extent used */ 153830f712c9SDave Chinner xfs_bmbt_irec_t prev; /* previous extent value */ 153930f712c9SDave Chinner 154030f712c9SDave Chinner if (XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE && 154130f712c9SDave Chinner XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS && 154230f712c9SDave Chinner XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_LOCAL) 15432451337dSDave Chinner return -EIO; 154430f712c9SDave Chinner if (XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_LOCAL) { 154530f712c9SDave Chinner *last_block = 0; 154630f712c9SDave Chinner return 0; 154730f712c9SDave Chinner } 154830f712c9SDave Chinner ifp = XFS_IFORK_PTR(ip, whichfork); 154930f712c9SDave Chinner if (!(ifp->if_flags & XFS_IFEXTENTS) && 155030f712c9SDave Chinner (error = xfs_iread_extents(tp, ip, whichfork))) 155130f712c9SDave Chinner return error; 155230f712c9SDave Chinner bno = *last_block - 1; 155330f712c9SDave Chinner ep = xfs_bmap_search_extents(ip, bno, whichfork, &eof, &lastx, &got, 155430f712c9SDave Chinner &prev); 155530f712c9SDave Chinner if (eof || xfs_bmbt_get_startoff(ep) > bno) { 155630f712c9SDave Chinner if (prev.br_startoff == NULLFILEOFF) 155730f712c9SDave Chinner *last_block = 0; 155830f712c9SDave Chinner else 155930f712c9SDave Chinner *last_block = prev.br_startoff + prev.br_blockcount; 156030f712c9SDave Chinner } 156130f712c9SDave Chinner /* 156230f712c9SDave Chinner * Otherwise *last_block is already the right answer. 156330f712c9SDave Chinner */ 156430f712c9SDave Chinner return 0; 156530f712c9SDave Chinner } 156630f712c9SDave Chinner 156730f712c9SDave Chinner int 156830f712c9SDave Chinner xfs_bmap_last_extent( 156930f712c9SDave Chinner struct xfs_trans *tp, 157030f712c9SDave Chinner struct xfs_inode *ip, 157130f712c9SDave Chinner int whichfork, 157230f712c9SDave Chinner struct xfs_bmbt_irec *rec, 157330f712c9SDave Chinner int *is_empty) 157430f712c9SDave Chinner { 157530f712c9SDave Chinner struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, whichfork); 157630f712c9SDave Chinner int error; 157730f712c9SDave Chinner int nextents; 157830f712c9SDave Chinner 157930f712c9SDave Chinner if (!(ifp->if_flags & XFS_IFEXTENTS)) { 158030f712c9SDave Chinner error = xfs_iread_extents(tp, ip, whichfork); 158130f712c9SDave Chinner if (error) 158230f712c9SDave Chinner return error; 158330f712c9SDave Chinner } 158430f712c9SDave Chinner 158530f712c9SDave Chinner nextents = ifp->if_bytes / sizeof(xfs_bmbt_rec_t); 158630f712c9SDave Chinner if (nextents == 0) { 158730f712c9SDave Chinner *is_empty = 1; 158830f712c9SDave Chinner return 0; 158930f712c9SDave Chinner } 159030f712c9SDave Chinner 159130f712c9SDave Chinner xfs_bmbt_get_all(xfs_iext_get_ext(ifp, nextents - 1), rec); 159230f712c9SDave Chinner *is_empty = 0; 159330f712c9SDave Chinner return 0; 159430f712c9SDave Chinner } 159530f712c9SDave Chinner 159630f712c9SDave Chinner /* 159730f712c9SDave Chinner * Check the last inode extent to determine whether this allocation will result 159830f712c9SDave Chinner * in blocks being allocated at the end of the file. When we allocate new data 159930f712c9SDave Chinner * blocks at the end of the file which do not start at the previous data block, 160030f712c9SDave Chinner * we will try to align the new blocks at stripe unit boundaries. 160130f712c9SDave Chinner * 160230f712c9SDave Chinner * Returns 1 in bma->aeof if the file (fork) is empty as any new write will be 160330f712c9SDave Chinner * at, or past the EOF. 160430f712c9SDave Chinner */ 160530f712c9SDave Chinner STATIC int 160630f712c9SDave Chinner xfs_bmap_isaeof( 160730f712c9SDave Chinner struct xfs_bmalloca *bma, 160830f712c9SDave Chinner int whichfork) 160930f712c9SDave Chinner { 161030f712c9SDave Chinner struct xfs_bmbt_irec rec; 161130f712c9SDave Chinner int is_empty; 161230f712c9SDave Chinner int error; 161330f712c9SDave Chinner 161430f712c9SDave Chinner bma->aeof = 0; 161530f712c9SDave Chinner error = xfs_bmap_last_extent(NULL, bma->ip, whichfork, &rec, 161630f712c9SDave Chinner &is_empty); 161730f712c9SDave Chinner if (error) 161830f712c9SDave Chinner return error; 161930f712c9SDave Chinner 162030f712c9SDave Chinner if (is_empty) { 162130f712c9SDave Chinner bma->aeof = 1; 162230f712c9SDave Chinner return 0; 162330f712c9SDave Chinner } 162430f712c9SDave Chinner 162530f712c9SDave Chinner /* 162630f712c9SDave Chinner * Check if we are allocation or past the last extent, or at least into 162730f712c9SDave Chinner * the last delayed allocated extent. 162830f712c9SDave Chinner */ 162930f712c9SDave Chinner bma->aeof = bma->offset >= rec.br_startoff + rec.br_blockcount || 163030f712c9SDave Chinner (bma->offset >= rec.br_startoff && 163130f712c9SDave Chinner isnullstartblock(rec.br_startblock)); 163230f712c9SDave Chinner return 0; 163330f712c9SDave Chinner } 163430f712c9SDave Chinner 163530f712c9SDave Chinner /* 163630f712c9SDave Chinner * Returns the file-relative block number of the first block past eof in 163730f712c9SDave Chinner * the file. This is not based on i_size, it is based on the extent records. 163830f712c9SDave Chinner * Returns 0 for local files, as they do not have extent records. 163930f712c9SDave Chinner */ 164030f712c9SDave Chinner int 164130f712c9SDave Chinner xfs_bmap_last_offset( 164230f712c9SDave Chinner struct xfs_inode *ip, 164330f712c9SDave Chinner xfs_fileoff_t *last_block, 164430f712c9SDave Chinner int whichfork) 164530f712c9SDave Chinner { 164630f712c9SDave Chinner struct xfs_bmbt_irec rec; 164730f712c9SDave Chinner int is_empty; 164830f712c9SDave Chinner int error; 164930f712c9SDave Chinner 165030f712c9SDave Chinner *last_block = 0; 165130f712c9SDave Chinner 165230f712c9SDave Chinner if (XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_LOCAL) 165330f712c9SDave Chinner return 0; 165430f712c9SDave Chinner 165530f712c9SDave Chinner if (XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE && 165630f712c9SDave Chinner XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS) 16572451337dSDave Chinner return -EIO; 165830f712c9SDave Chinner 165930f712c9SDave Chinner error = xfs_bmap_last_extent(NULL, ip, whichfork, &rec, &is_empty); 166030f712c9SDave Chinner if (error || is_empty) 166130f712c9SDave Chinner return error; 166230f712c9SDave Chinner 166330f712c9SDave Chinner *last_block = rec.br_startoff + rec.br_blockcount; 166430f712c9SDave Chinner return 0; 166530f712c9SDave Chinner } 166630f712c9SDave Chinner 166730f712c9SDave Chinner /* 166830f712c9SDave Chinner * Returns whether the selected fork of the inode has exactly one 166930f712c9SDave Chinner * block or not. For the data fork we check this matches di_size, 167030f712c9SDave Chinner * implying the file's range is 0..bsize-1. 167130f712c9SDave Chinner */ 167230f712c9SDave Chinner int /* 1=>1 block, 0=>otherwise */ 167330f712c9SDave Chinner xfs_bmap_one_block( 167430f712c9SDave Chinner xfs_inode_t *ip, /* incore inode */ 167530f712c9SDave Chinner int whichfork) /* data or attr fork */ 167630f712c9SDave Chinner { 167730f712c9SDave Chinner xfs_bmbt_rec_host_t *ep; /* ptr to fork's extent */ 167830f712c9SDave Chinner xfs_ifork_t *ifp; /* inode fork pointer */ 167930f712c9SDave Chinner int rval; /* return value */ 168030f712c9SDave Chinner xfs_bmbt_irec_t s; /* internal version of extent */ 168130f712c9SDave Chinner 168230f712c9SDave Chinner #ifndef DEBUG 168330f712c9SDave Chinner if (whichfork == XFS_DATA_FORK) 168430f712c9SDave Chinner return XFS_ISIZE(ip) == ip->i_mount->m_sb.sb_blocksize; 168530f712c9SDave Chinner #endif /* !DEBUG */ 168630f712c9SDave Chinner if (XFS_IFORK_NEXTENTS(ip, whichfork) != 1) 168730f712c9SDave Chinner return 0; 168830f712c9SDave Chinner if (XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS) 168930f712c9SDave Chinner return 0; 169030f712c9SDave Chinner ifp = XFS_IFORK_PTR(ip, whichfork); 169130f712c9SDave Chinner ASSERT(ifp->if_flags & XFS_IFEXTENTS); 169230f712c9SDave Chinner ep = xfs_iext_get_ext(ifp, 0); 169330f712c9SDave Chinner xfs_bmbt_get_all(ep, &s); 169430f712c9SDave Chinner rval = s.br_startoff == 0 && s.br_blockcount == 1; 169530f712c9SDave Chinner if (rval && whichfork == XFS_DATA_FORK) 169630f712c9SDave Chinner ASSERT(XFS_ISIZE(ip) == ip->i_mount->m_sb.sb_blocksize); 169730f712c9SDave Chinner return rval; 169830f712c9SDave Chinner } 169930f712c9SDave Chinner 170030f712c9SDave Chinner /* 170130f712c9SDave Chinner * Extent tree manipulation functions used during allocation. 170230f712c9SDave Chinner */ 170330f712c9SDave Chinner 170430f712c9SDave Chinner /* 170530f712c9SDave Chinner * Convert a delayed allocation to a real allocation. 170630f712c9SDave Chinner */ 170730f712c9SDave Chinner STATIC int /* error */ 170830f712c9SDave Chinner xfs_bmap_add_extent_delay_real( 170960b4984fSDarrick J. Wong struct xfs_bmalloca *bma, 171060b4984fSDarrick J. Wong int whichfork) 171130f712c9SDave Chinner { 171230f712c9SDave Chinner struct xfs_bmbt_irec *new = &bma->got; 171330f712c9SDave Chinner int diff; /* temp value */ 171430f712c9SDave Chinner xfs_bmbt_rec_host_t *ep; /* extent entry for idx */ 171530f712c9SDave Chinner int error; /* error return value */ 171630f712c9SDave Chinner int i; /* temp state */ 171730f712c9SDave Chinner xfs_ifork_t *ifp; /* inode fork pointer */ 171830f712c9SDave Chinner xfs_fileoff_t new_endoff; /* end offset of new entry */ 171930f712c9SDave Chinner xfs_bmbt_irec_t r[3]; /* neighbor extent entries */ 172030f712c9SDave Chinner /* left is 0, right is 1, prev is 2 */ 172130f712c9SDave Chinner int rval=0; /* return value (logging flags) */ 172230f712c9SDave Chinner int state = 0;/* state bits, accessed thru macros */ 172330f712c9SDave Chinner xfs_filblks_t da_new; /* new count del alloc blocks used */ 172430f712c9SDave Chinner xfs_filblks_t da_old; /* old count del alloc blocks used */ 172530f712c9SDave Chinner xfs_filblks_t temp=0; /* value for da_new calculations */ 172630f712c9SDave Chinner xfs_filblks_t temp2=0;/* value for da_new calculations */ 172730f712c9SDave Chinner int tmp_rval; /* partial logging flags */ 1728c29aad41SEric Sandeen struct xfs_mount *mp; 172960b4984fSDarrick J. Wong xfs_extnum_t *nextents; 173030f712c9SDave Chinner 1731f1f96c49SEric Sandeen mp = bma->ip->i_mount; 17326d3eb1ecSDarrick J. Wong ifp = XFS_IFORK_PTR(bma->ip, whichfork); 173360b4984fSDarrick J. Wong ASSERT(whichfork != XFS_ATTR_FORK); 173460b4984fSDarrick J. Wong nextents = (whichfork == XFS_COW_FORK ? &bma->ip->i_cnextents : 173560b4984fSDarrick J. Wong &bma->ip->i_d.di_nextents); 173630f712c9SDave Chinner 173730f712c9SDave Chinner ASSERT(bma->idx >= 0); 173830f712c9SDave Chinner ASSERT(bma->idx <= ifp->if_bytes / sizeof(struct xfs_bmbt_rec)); 173930f712c9SDave Chinner ASSERT(!isnullstartblock(new->br_startblock)); 174030f712c9SDave Chinner ASSERT(!bma->cur || 174130f712c9SDave Chinner (bma->cur->bc_private.b.flags & XFS_BTCUR_BPRV_WASDEL)); 174230f712c9SDave Chinner 1743ff6d6af2SBill O'Donnell XFS_STATS_INC(mp, xs_add_exlist); 174430f712c9SDave Chinner 174530f712c9SDave Chinner #define LEFT r[0] 174630f712c9SDave Chinner #define RIGHT r[1] 174730f712c9SDave Chinner #define PREV r[2] 174830f712c9SDave Chinner 174960b4984fSDarrick J. Wong if (whichfork == XFS_COW_FORK) 175060b4984fSDarrick J. Wong state |= BMAP_COWFORK; 175160b4984fSDarrick J. Wong 175230f712c9SDave Chinner /* 175330f712c9SDave Chinner * Set up a bunch of variables to make the tests simpler. 175430f712c9SDave Chinner */ 175530f712c9SDave Chinner ep = xfs_iext_get_ext(ifp, bma->idx); 175630f712c9SDave Chinner xfs_bmbt_get_all(ep, &PREV); 175730f712c9SDave Chinner new_endoff = new->br_startoff + new->br_blockcount; 175830f712c9SDave Chinner ASSERT(PREV.br_startoff <= new->br_startoff); 175930f712c9SDave Chinner ASSERT(PREV.br_startoff + PREV.br_blockcount >= new_endoff); 176030f712c9SDave Chinner 176130f712c9SDave Chinner da_old = startblockval(PREV.br_startblock); 176230f712c9SDave Chinner da_new = 0; 176330f712c9SDave Chinner 176430f712c9SDave Chinner /* 176530f712c9SDave Chinner * Set flags determining what part of the previous delayed allocation 176630f712c9SDave Chinner * extent is being replaced by a real allocation. 176730f712c9SDave Chinner */ 176830f712c9SDave Chinner if (PREV.br_startoff == new->br_startoff) 176930f712c9SDave Chinner state |= BMAP_LEFT_FILLING; 177030f712c9SDave Chinner if (PREV.br_startoff + PREV.br_blockcount == new_endoff) 177130f712c9SDave Chinner state |= BMAP_RIGHT_FILLING; 177230f712c9SDave Chinner 177330f712c9SDave Chinner /* 177430f712c9SDave Chinner * Check and set flags if this segment has a left neighbor. 177530f712c9SDave Chinner * Don't set contiguous if the combined extent would be too large. 177630f712c9SDave Chinner */ 177730f712c9SDave Chinner if (bma->idx > 0) { 177830f712c9SDave Chinner state |= BMAP_LEFT_VALID; 177930f712c9SDave Chinner xfs_bmbt_get_all(xfs_iext_get_ext(ifp, bma->idx - 1), &LEFT); 178030f712c9SDave Chinner 178130f712c9SDave Chinner if (isnullstartblock(LEFT.br_startblock)) 178230f712c9SDave Chinner state |= BMAP_LEFT_DELAY; 178330f712c9SDave Chinner } 178430f712c9SDave Chinner 178530f712c9SDave Chinner if ((state & BMAP_LEFT_VALID) && !(state & BMAP_LEFT_DELAY) && 178630f712c9SDave Chinner LEFT.br_startoff + LEFT.br_blockcount == new->br_startoff && 178730f712c9SDave Chinner LEFT.br_startblock + LEFT.br_blockcount == new->br_startblock && 178830f712c9SDave Chinner LEFT.br_state == new->br_state && 178930f712c9SDave Chinner LEFT.br_blockcount + new->br_blockcount <= MAXEXTLEN) 179030f712c9SDave Chinner state |= BMAP_LEFT_CONTIG; 179130f712c9SDave Chinner 179230f712c9SDave Chinner /* 179330f712c9SDave Chinner * Check and set flags if this segment has a right neighbor. 179430f712c9SDave Chinner * Don't set contiguous if the combined extent would be too large. 179530f712c9SDave Chinner * Also check for all-three-contiguous being too large. 179630f712c9SDave Chinner */ 17976d3eb1ecSDarrick J. Wong if (bma->idx < ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t) - 1) { 179830f712c9SDave Chinner state |= BMAP_RIGHT_VALID; 179930f712c9SDave Chinner xfs_bmbt_get_all(xfs_iext_get_ext(ifp, bma->idx + 1), &RIGHT); 180030f712c9SDave Chinner 180130f712c9SDave Chinner if (isnullstartblock(RIGHT.br_startblock)) 180230f712c9SDave Chinner state |= BMAP_RIGHT_DELAY; 180330f712c9SDave Chinner } 180430f712c9SDave Chinner 180530f712c9SDave Chinner if ((state & BMAP_RIGHT_VALID) && !(state & BMAP_RIGHT_DELAY) && 180630f712c9SDave Chinner new_endoff == RIGHT.br_startoff && 180730f712c9SDave Chinner new->br_startblock + new->br_blockcount == RIGHT.br_startblock && 180830f712c9SDave Chinner new->br_state == RIGHT.br_state && 180930f712c9SDave Chinner new->br_blockcount + RIGHT.br_blockcount <= MAXEXTLEN && 181030f712c9SDave Chinner ((state & (BMAP_LEFT_CONTIG | BMAP_LEFT_FILLING | 181130f712c9SDave Chinner BMAP_RIGHT_FILLING)) != 181230f712c9SDave Chinner (BMAP_LEFT_CONTIG | BMAP_LEFT_FILLING | 181330f712c9SDave Chinner BMAP_RIGHT_FILLING) || 181430f712c9SDave Chinner LEFT.br_blockcount + new->br_blockcount + RIGHT.br_blockcount 181530f712c9SDave Chinner <= MAXEXTLEN)) 181630f712c9SDave Chinner state |= BMAP_RIGHT_CONTIG; 181730f712c9SDave Chinner 181830f712c9SDave Chinner error = 0; 181930f712c9SDave Chinner /* 182030f712c9SDave Chinner * Switch out based on the FILLING and CONTIG state bits. 182130f712c9SDave Chinner */ 182230f712c9SDave Chinner switch (state & (BMAP_LEFT_FILLING | BMAP_LEFT_CONTIG | 182330f712c9SDave Chinner BMAP_RIGHT_FILLING | BMAP_RIGHT_CONTIG)) { 182430f712c9SDave Chinner case BMAP_LEFT_FILLING | BMAP_LEFT_CONTIG | 182530f712c9SDave Chinner BMAP_RIGHT_FILLING | BMAP_RIGHT_CONTIG: 182630f712c9SDave Chinner /* 182730f712c9SDave Chinner * Filling in all of a previously delayed allocation extent. 182830f712c9SDave Chinner * The left and right neighbors are both contiguous with new. 182930f712c9SDave Chinner */ 183030f712c9SDave Chinner bma->idx--; 183130f712c9SDave Chinner trace_xfs_bmap_pre_update(bma->ip, bma->idx, state, _THIS_IP_); 183230f712c9SDave Chinner xfs_bmbt_set_blockcount(xfs_iext_get_ext(ifp, bma->idx), 183330f712c9SDave Chinner LEFT.br_blockcount + PREV.br_blockcount + 183430f712c9SDave Chinner RIGHT.br_blockcount); 183530f712c9SDave Chinner trace_xfs_bmap_post_update(bma->ip, bma->idx, state, _THIS_IP_); 183630f712c9SDave Chinner 183730f712c9SDave Chinner xfs_iext_remove(bma->ip, bma->idx + 1, 2, state); 183860b4984fSDarrick J. Wong (*nextents)--; 183930f712c9SDave Chinner if (bma->cur == NULL) 184030f712c9SDave Chinner rval = XFS_ILOG_CORE | XFS_ILOG_DEXT; 184130f712c9SDave Chinner else { 184230f712c9SDave Chinner rval = XFS_ILOG_CORE; 184330f712c9SDave Chinner error = xfs_bmbt_lookup_eq(bma->cur, RIGHT.br_startoff, 184430f712c9SDave Chinner RIGHT.br_startblock, 184530f712c9SDave Chinner RIGHT.br_blockcount, &i); 184630f712c9SDave Chinner if (error) 184730f712c9SDave Chinner goto done; 1848c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 184930f712c9SDave Chinner error = xfs_btree_delete(bma->cur, &i); 185030f712c9SDave Chinner if (error) 185130f712c9SDave Chinner goto done; 1852c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 185330f712c9SDave Chinner error = xfs_btree_decrement(bma->cur, 0, &i); 185430f712c9SDave Chinner if (error) 185530f712c9SDave Chinner goto done; 1856c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 185730f712c9SDave Chinner error = xfs_bmbt_update(bma->cur, LEFT.br_startoff, 185830f712c9SDave Chinner LEFT.br_startblock, 185930f712c9SDave Chinner LEFT.br_blockcount + 186030f712c9SDave Chinner PREV.br_blockcount + 186130f712c9SDave Chinner RIGHT.br_blockcount, LEFT.br_state); 186230f712c9SDave Chinner if (error) 186330f712c9SDave Chinner goto done; 186430f712c9SDave Chinner } 186530f712c9SDave Chinner break; 186630f712c9SDave Chinner 186730f712c9SDave Chinner case BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING | BMAP_LEFT_CONTIG: 186830f712c9SDave Chinner /* 186930f712c9SDave Chinner * Filling in all of a previously delayed allocation extent. 187030f712c9SDave Chinner * The left neighbor is contiguous, the right is not. 187130f712c9SDave Chinner */ 187230f712c9SDave Chinner bma->idx--; 187330f712c9SDave Chinner 187430f712c9SDave Chinner trace_xfs_bmap_pre_update(bma->ip, bma->idx, state, _THIS_IP_); 187530f712c9SDave Chinner xfs_bmbt_set_blockcount(xfs_iext_get_ext(ifp, bma->idx), 187630f712c9SDave Chinner LEFT.br_blockcount + PREV.br_blockcount); 187730f712c9SDave Chinner trace_xfs_bmap_post_update(bma->ip, bma->idx, state, _THIS_IP_); 187830f712c9SDave Chinner 187930f712c9SDave Chinner xfs_iext_remove(bma->ip, bma->idx + 1, 1, state); 188030f712c9SDave Chinner if (bma->cur == NULL) 188130f712c9SDave Chinner rval = XFS_ILOG_DEXT; 188230f712c9SDave Chinner else { 188330f712c9SDave Chinner rval = 0; 188430f712c9SDave Chinner error = xfs_bmbt_lookup_eq(bma->cur, LEFT.br_startoff, 188530f712c9SDave Chinner LEFT.br_startblock, LEFT.br_blockcount, 188630f712c9SDave Chinner &i); 188730f712c9SDave Chinner if (error) 188830f712c9SDave Chinner goto done; 1889c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 189030f712c9SDave Chinner error = xfs_bmbt_update(bma->cur, LEFT.br_startoff, 189130f712c9SDave Chinner LEFT.br_startblock, 189230f712c9SDave Chinner LEFT.br_blockcount + 189330f712c9SDave Chinner PREV.br_blockcount, LEFT.br_state); 189430f712c9SDave Chinner if (error) 189530f712c9SDave Chinner goto done; 189630f712c9SDave Chinner } 189730f712c9SDave Chinner break; 189830f712c9SDave Chinner 189930f712c9SDave Chinner case BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING | BMAP_RIGHT_CONTIG: 190030f712c9SDave Chinner /* 190130f712c9SDave Chinner * Filling in all of a previously delayed allocation extent. 190230f712c9SDave Chinner * The right neighbor is contiguous, the left is not. 190330f712c9SDave Chinner */ 190430f712c9SDave Chinner trace_xfs_bmap_pre_update(bma->ip, bma->idx, state, _THIS_IP_); 190530f712c9SDave Chinner xfs_bmbt_set_startblock(ep, new->br_startblock); 190630f712c9SDave Chinner xfs_bmbt_set_blockcount(ep, 190730f712c9SDave Chinner PREV.br_blockcount + RIGHT.br_blockcount); 190830f712c9SDave Chinner trace_xfs_bmap_post_update(bma->ip, bma->idx, state, _THIS_IP_); 190930f712c9SDave Chinner 191030f712c9SDave Chinner xfs_iext_remove(bma->ip, bma->idx + 1, 1, state); 191130f712c9SDave Chinner if (bma->cur == NULL) 191230f712c9SDave Chinner rval = XFS_ILOG_DEXT; 191330f712c9SDave Chinner else { 191430f712c9SDave Chinner rval = 0; 191530f712c9SDave Chinner error = xfs_bmbt_lookup_eq(bma->cur, RIGHT.br_startoff, 191630f712c9SDave Chinner RIGHT.br_startblock, 191730f712c9SDave Chinner RIGHT.br_blockcount, &i); 191830f712c9SDave Chinner if (error) 191930f712c9SDave Chinner goto done; 1920c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 192130f712c9SDave Chinner error = xfs_bmbt_update(bma->cur, PREV.br_startoff, 192230f712c9SDave Chinner new->br_startblock, 192330f712c9SDave Chinner PREV.br_blockcount + 192430f712c9SDave Chinner RIGHT.br_blockcount, PREV.br_state); 192530f712c9SDave Chinner if (error) 192630f712c9SDave Chinner goto done; 192730f712c9SDave Chinner } 192830f712c9SDave Chinner break; 192930f712c9SDave Chinner 193030f712c9SDave Chinner case BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING: 193130f712c9SDave Chinner /* 193230f712c9SDave Chinner * Filling in all of a previously delayed allocation extent. 193330f712c9SDave Chinner * Neither the left nor right neighbors are contiguous with 193430f712c9SDave Chinner * the new one. 193530f712c9SDave Chinner */ 193630f712c9SDave Chinner trace_xfs_bmap_pre_update(bma->ip, bma->idx, state, _THIS_IP_); 193730f712c9SDave Chinner xfs_bmbt_set_startblock(ep, new->br_startblock); 193830f712c9SDave Chinner trace_xfs_bmap_post_update(bma->ip, bma->idx, state, _THIS_IP_); 193930f712c9SDave Chinner 194060b4984fSDarrick J. Wong (*nextents)++; 194130f712c9SDave Chinner if (bma->cur == NULL) 194230f712c9SDave Chinner rval = XFS_ILOG_CORE | XFS_ILOG_DEXT; 194330f712c9SDave Chinner else { 194430f712c9SDave Chinner rval = XFS_ILOG_CORE; 194530f712c9SDave Chinner error = xfs_bmbt_lookup_eq(bma->cur, new->br_startoff, 194630f712c9SDave Chinner new->br_startblock, new->br_blockcount, 194730f712c9SDave Chinner &i); 194830f712c9SDave Chinner if (error) 194930f712c9SDave Chinner goto done; 1950c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 0, done); 195130f712c9SDave Chinner bma->cur->bc_rec.b.br_state = XFS_EXT_NORM; 195230f712c9SDave Chinner error = xfs_btree_insert(bma->cur, &i); 195330f712c9SDave Chinner if (error) 195430f712c9SDave Chinner goto done; 1955c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 195630f712c9SDave Chinner } 195730f712c9SDave Chinner break; 195830f712c9SDave Chinner 195930f712c9SDave Chinner case BMAP_LEFT_FILLING | BMAP_LEFT_CONTIG: 196030f712c9SDave Chinner /* 196130f712c9SDave Chinner * Filling in the first part of a previous delayed allocation. 196230f712c9SDave Chinner * The left neighbor is contiguous. 196330f712c9SDave Chinner */ 196430f712c9SDave Chinner trace_xfs_bmap_pre_update(bma->ip, bma->idx - 1, state, _THIS_IP_); 196530f712c9SDave Chinner xfs_bmbt_set_blockcount(xfs_iext_get_ext(ifp, bma->idx - 1), 196630f712c9SDave Chinner LEFT.br_blockcount + new->br_blockcount); 196730f712c9SDave Chinner xfs_bmbt_set_startoff(ep, 196830f712c9SDave Chinner PREV.br_startoff + new->br_blockcount); 196930f712c9SDave Chinner trace_xfs_bmap_post_update(bma->ip, bma->idx - 1, state, _THIS_IP_); 197030f712c9SDave Chinner 197130f712c9SDave Chinner temp = PREV.br_blockcount - new->br_blockcount; 197230f712c9SDave Chinner trace_xfs_bmap_pre_update(bma->ip, bma->idx, state, _THIS_IP_); 197330f712c9SDave Chinner xfs_bmbt_set_blockcount(ep, temp); 197430f712c9SDave Chinner if (bma->cur == NULL) 197530f712c9SDave Chinner rval = XFS_ILOG_DEXT; 197630f712c9SDave Chinner else { 197730f712c9SDave Chinner rval = 0; 197830f712c9SDave Chinner error = xfs_bmbt_lookup_eq(bma->cur, LEFT.br_startoff, 197930f712c9SDave Chinner LEFT.br_startblock, LEFT.br_blockcount, 198030f712c9SDave Chinner &i); 198130f712c9SDave Chinner if (error) 198230f712c9SDave Chinner goto done; 1983c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 198430f712c9SDave Chinner error = xfs_bmbt_update(bma->cur, LEFT.br_startoff, 198530f712c9SDave Chinner LEFT.br_startblock, 198630f712c9SDave Chinner LEFT.br_blockcount + 198730f712c9SDave Chinner new->br_blockcount, 198830f712c9SDave Chinner LEFT.br_state); 198930f712c9SDave Chinner if (error) 199030f712c9SDave Chinner goto done; 199130f712c9SDave Chinner } 199230f712c9SDave Chinner da_new = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(bma->ip, temp), 199330f712c9SDave Chinner startblockval(PREV.br_startblock)); 199430f712c9SDave Chinner xfs_bmbt_set_startblock(ep, nullstartblock(da_new)); 199530f712c9SDave Chinner trace_xfs_bmap_post_update(bma->ip, bma->idx, state, _THIS_IP_); 199630f712c9SDave Chinner 199730f712c9SDave Chinner bma->idx--; 199830f712c9SDave Chinner break; 199930f712c9SDave Chinner 200030f712c9SDave Chinner case BMAP_LEFT_FILLING: 200130f712c9SDave Chinner /* 200230f712c9SDave Chinner * Filling in the first part of a previous delayed allocation. 200330f712c9SDave Chinner * The left neighbor is not contiguous. 200430f712c9SDave Chinner */ 200530f712c9SDave Chinner trace_xfs_bmap_pre_update(bma->ip, bma->idx, state, _THIS_IP_); 200630f712c9SDave Chinner xfs_bmbt_set_startoff(ep, new_endoff); 200730f712c9SDave Chinner temp = PREV.br_blockcount - new->br_blockcount; 200830f712c9SDave Chinner xfs_bmbt_set_blockcount(ep, temp); 200930f712c9SDave Chinner xfs_iext_insert(bma->ip, bma->idx, 1, new, state); 201060b4984fSDarrick J. Wong (*nextents)++; 201130f712c9SDave Chinner if (bma->cur == NULL) 201230f712c9SDave Chinner rval = XFS_ILOG_CORE | XFS_ILOG_DEXT; 201330f712c9SDave Chinner else { 201430f712c9SDave Chinner rval = XFS_ILOG_CORE; 201530f712c9SDave Chinner error = xfs_bmbt_lookup_eq(bma->cur, new->br_startoff, 201630f712c9SDave Chinner new->br_startblock, new->br_blockcount, 201730f712c9SDave Chinner &i); 201830f712c9SDave Chinner if (error) 201930f712c9SDave Chinner goto done; 2020c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 0, done); 202130f712c9SDave Chinner bma->cur->bc_rec.b.br_state = XFS_EXT_NORM; 202230f712c9SDave Chinner error = xfs_btree_insert(bma->cur, &i); 202330f712c9SDave Chinner if (error) 202430f712c9SDave Chinner goto done; 2025c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 202630f712c9SDave Chinner } 202730f712c9SDave Chinner 20286d3eb1ecSDarrick J. Wong if (xfs_bmap_needs_btree(bma->ip, whichfork)) { 202930f712c9SDave Chinner error = xfs_bmap_extents_to_btree(bma->tp, bma->ip, 20302c3234d1SDarrick J. Wong bma->firstblock, bma->dfops, 20316d3eb1ecSDarrick J. Wong &bma->cur, 1, &tmp_rval, whichfork); 203230f712c9SDave Chinner rval |= tmp_rval; 203330f712c9SDave Chinner if (error) 203430f712c9SDave Chinner goto done; 203530f712c9SDave Chinner } 203630f712c9SDave Chinner da_new = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(bma->ip, temp), 203730f712c9SDave Chinner startblockval(PREV.br_startblock) - 203830f712c9SDave Chinner (bma->cur ? bma->cur->bc_private.b.allocated : 0)); 203930f712c9SDave Chinner ep = xfs_iext_get_ext(ifp, bma->idx + 1); 204030f712c9SDave Chinner xfs_bmbt_set_startblock(ep, nullstartblock(da_new)); 204130f712c9SDave Chinner trace_xfs_bmap_post_update(bma->ip, bma->idx + 1, state, _THIS_IP_); 204230f712c9SDave Chinner break; 204330f712c9SDave Chinner 204430f712c9SDave Chinner case BMAP_RIGHT_FILLING | BMAP_RIGHT_CONTIG: 204530f712c9SDave Chinner /* 204630f712c9SDave Chinner * Filling in the last part of a previous delayed allocation. 204730f712c9SDave Chinner * The right neighbor is contiguous with the new allocation. 204830f712c9SDave Chinner */ 204930f712c9SDave Chinner temp = PREV.br_blockcount - new->br_blockcount; 205030f712c9SDave Chinner trace_xfs_bmap_pre_update(bma->ip, bma->idx + 1, state, _THIS_IP_); 205130f712c9SDave Chinner xfs_bmbt_set_blockcount(ep, temp); 205230f712c9SDave Chinner xfs_bmbt_set_allf(xfs_iext_get_ext(ifp, bma->idx + 1), 205330f712c9SDave Chinner new->br_startoff, new->br_startblock, 205430f712c9SDave Chinner new->br_blockcount + RIGHT.br_blockcount, 205530f712c9SDave Chinner RIGHT.br_state); 205630f712c9SDave Chinner trace_xfs_bmap_post_update(bma->ip, bma->idx + 1, state, _THIS_IP_); 205730f712c9SDave Chinner if (bma->cur == NULL) 205830f712c9SDave Chinner rval = XFS_ILOG_DEXT; 205930f712c9SDave Chinner else { 206030f712c9SDave Chinner rval = 0; 206130f712c9SDave Chinner error = xfs_bmbt_lookup_eq(bma->cur, RIGHT.br_startoff, 206230f712c9SDave Chinner RIGHT.br_startblock, 206330f712c9SDave Chinner RIGHT.br_blockcount, &i); 206430f712c9SDave Chinner if (error) 206530f712c9SDave Chinner goto done; 2066c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 206730f712c9SDave Chinner error = xfs_bmbt_update(bma->cur, new->br_startoff, 206830f712c9SDave Chinner new->br_startblock, 206930f712c9SDave Chinner new->br_blockcount + 207030f712c9SDave Chinner RIGHT.br_blockcount, 207130f712c9SDave Chinner RIGHT.br_state); 207230f712c9SDave Chinner if (error) 207330f712c9SDave Chinner goto done; 207430f712c9SDave Chinner } 207530f712c9SDave Chinner 207630f712c9SDave Chinner da_new = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(bma->ip, temp), 207730f712c9SDave Chinner startblockval(PREV.br_startblock)); 207830f712c9SDave Chinner trace_xfs_bmap_pre_update(bma->ip, bma->idx, state, _THIS_IP_); 207930f712c9SDave Chinner xfs_bmbt_set_startblock(ep, nullstartblock(da_new)); 208030f712c9SDave Chinner trace_xfs_bmap_post_update(bma->ip, bma->idx, state, _THIS_IP_); 208130f712c9SDave Chinner 208230f712c9SDave Chinner bma->idx++; 208330f712c9SDave Chinner break; 208430f712c9SDave Chinner 208530f712c9SDave Chinner case BMAP_RIGHT_FILLING: 208630f712c9SDave Chinner /* 208730f712c9SDave Chinner * Filling in the last part of a previous delayed allocation. 208830f712c9SDave Chinner * The right neighbor is not contiguous. 208930f712c9SDave Chinner */ 209030f712c9SDave Chinner temp = PREV.br_blockcount - new->br_blockcount; 209130f712c9SDave Chinner trace_xfs_bmap_pre_update(bma->ip, bma->idx, state, _THIS_IP_); 209230f712c9SDave Chinner xfs_bmbt_set_blockcount(ep, temp); 209330f712c9SDave Chinner xfs_iext_insert(bma->ip, bma->idx + 1, 1, new, state); 209460b4984fSDarrick J. Wong (*nextents)++; 209530f712c9SDave Chinner if (bma->cur == NULL) 209630f712c9SDave Chinner rval = XFS_ILOG_CORE | XFS_ILOG_DEXT; 209730f712c9SDave Chinner else { 209830f712c9SDave Chinner rval = XFS_ILOG_CORE; 209930f712c9SDave Chinner error = xfs_bmbt_lookup_eq(bma->cur, new->br_startoff, 210030f712c9SDave Chinner new->br_startblock, new->br_blockcount, 210130f712c9SDave Chinner &i); 210230f712c9SDave Chinner if (error) 210330f712c9SDave Chinner goto done; 2104c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 0, done); 210530f712c9SDave Chinner bma->cur->bc_rec.b.br_state = XFS_EXT_NORM; 210630f712c9SDave Chinner error = xfs_btree_insert(bma->cur, &i); 210730f712c9SDave Chinner if (error) 210830f712c9SDave Chinner goto done; 2109c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 211030f712c9SDave Chinner } 211130f712c9SDave Chinner 21126d3eb1ecSDarrick J. Wong if (xfs_bmap_needs_btree(bma->ip, whichfork)) { 211330f712c9SDave Chinner error = xfs_bmap_extents_to_btree(bma->tp, bma->ip, 21142c3234d1SDarrick J. Wong bma->firstblock, bma->dfops, &bma->cur, 1, 21156d3eb1ecSDarrick J. Wong &tmp_rval, whichfork); 211630f712c9SDave Chinner rval |= tmp_rval; 211730f712c9SDave Chinner if (error) 211830f712c9SDave Chinner goto done; 211930f712c9SDave Chinner } 212030f712c9SDave Chinner da_new = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(bma->ip, temp), 212130f712c9SDave Chinner startblockval(PREV.br_startblock) - 212230f712c9SDave Chinner (bma->cur ? bma->cur->bc_private.b.allocated : 0)); 212330f712c9SDave Chinner ep = xfs_iext_get_ext(ifp, bma->idx); 212430f712c9SDave Chinner xfs_bmbt_set_startblock(ep, nullstartblock(da_new)); 212530f712c9SDave Chinner trace_xfs_bmap_post_update(bma->ip, bma->idx, state, _THIS_IP_); 212630f712c9SDave Chinner 212730f712c9SDave Chinner bma->idx++; 212830f712c9SDave Chinner break; 212930f712c9SDave Chinner 213030f712c9SDave Chinner case 0: 213130f712c9SDave Chinner /* 213230f712c9SDave Chinner * Filling in the middle part of a previous delayed allocation. 213330f712c9SDave Chinner * Contiguity is impossible here. 213430f712c9SDave Chinner * This case is avoided almost all the time. 213530f712c9SDave Chinner * 213630f712c9SDave Chinner * We start with a delayed allocation: 213730f712c9SDave Chinner * 213830f712c9SDave Chinner * +ddddddddddddddddddddddddddddddddddddddddddddddddddddddd+ 213930f712c9SDave Chinner * PREV @ idx 214030f712c9SDave Chinner * 214130f712c9SDave Chinner * and we are allocating: 214230f712c9SDave Chinner * +rrrrrrrrrrrrrrrrr+ 214330f712c9SDave Chinner * new 214430f712c9SDave Chinner * 214530f712c9SDave Chinner * and we set it up for insertion as: 214630f712c9SDave Chinner * +ddddddddddddddddddd+rrrrrrrrrrrrrrrrr+ddddddddddddddddd+ 214730f712c9SDave Chinner * new 214830f712c9SDave Chinner * PREV @ idx LEFT RIGHT 214930f712c9SDave Chinner * inserted at idx + 1 215030f712c9SDave Chinner */ 215130f712c9SDave Chinner temp = new->br_startoff - PREV.br_startoff; 215230f712c9SDave Chinner temp2 = PREV.br_startoff + PREV.br_blockcount - new_endoff; 215330f712c9SDave Chinner trace_xfs_bmap_pre_update(bma->ip, bma->idx, 0, _THIS_IP_); 215430f712c9SDave Chinner xfs_bmbt_set_blockcount(ep, temp); /* truncate PREV */ 215530f712c9SDave Chinner LEFT = *new; 215630f712c9SDave Chinner RIGHT.br_state = PREV.br_state; 215730f712c9SDave Chinner RIGHT.br_startblock = nullstartblock( 215830f712c9SDave Chinner (int)xfs_bmap_worst_indlen(bma->ip, temp2)); 215930f712c9SDave Chinner RIGHT.br_startoff = new_endoff; 216030f712c9SDave Chinner RIGHT.br_blockcount = temp2; 216130f712c9SDave Chinner /* insert LEFT (r[0]) and RIGHT (r[1]) at the same time */ 216230f712c9SDave Chinner xfs_iext_insert(bma->ip, bma->idx + 1, 2, &LEFT, state); 216360b4984fSDarrick J. Wong (*nextents)++; 216430f712c9SDave Chinner if (bma->cur == NULL) 216530f712c9SDave Chinner rval = XFS_ILOG_CORE | XFS_ILOG_DEXT; 216630f712c9SDave Chinner else { 216730f712c9SDave Chinner rval = XFS_ILOG_CORE; 216830f712c9SDave Chinner error = xfs_bmbt_lookup_eq(bma->cur, new->br_startoff, 216930f712c9SDave Chinner new->br_startblock, new->br_blockcount, 217030f712c9SDave Chinner &i); 217130f712c9SDave Chinner if (error) 217230f712c9SDave Chinner goto done; 2173c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 0, done); 217430f712c9SDave Chinner bma->cur->bc_rec.b.br_state = XFS_EXT_NORM; 217530f712c9SDave Chinner error = xfs_btree_insert(bma->cur, &i); 217630f712c9SDave Chinner if (error) 217730f712c9SDave Chinner goto done; 2178c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 217930f712c9SDave Chinner } 218030f712c9SDave Chinner 21816d3eb1ecSDarrick J. Wong if (xfs_bmap_needs_btree(bma->ip, whichfork)) { 218230f712c9SDave Chinner error = xfs_bmap_extents_to_btree(bma->tp, bma->ip, 21832c3234d1SDarrick J. Wong bma->firstblock, bma->dfops, &bma->cur, 21846d3eb1ecSDarrick J. Wong 1, &tmp_rval, whichfork); 218530f712c9SDave Chinner rval |= tmp_rval; 218630f712c9SDave Chinner if (error) 218730f712c9SDave Chinner goto done; 218830f712c9SDave Chinner } 218930f712c9SDave Chinner temp = xfs_bmap_worst_indlen(bma->ip, temp); 219030f712c9SDave Chinner temp2 = xfs_bmap_worst_indlen(bma->ip, temp2); 219130f712c9SDave Chinner diff = (int)(temp + temp2 - startblockval(PREV.br_startblock) - 219230f712c9SDave Chinner (bma->cur ? bma->cur->bc_private.b.allocated : 0)); 219330f712c9SDave Chinner if (diff > 0) { 21940d485adaSDave Chinner error = xfs_mod_fdblocks(bma->ip->i_mount, 21950d485adaSDave Chinner -((int64_t)diff), false); 219630f712c9SDave Chinner ASSERT(!error); 219730f712c9SDave Chinner if (error) 219830f712c9SDave Chinner goto done; 219930f712c9SDave Chinner } 220030f712c9SDave Chinner 220130f712c9SDave Chinner ep = xfs_iext_get_ext(ifp, bma->idx); 220230f712c9SDave Chinner xfs_bmbt_set_startblock(ep, nullstartblock((int)temp)); 220330f712c9SDave Chinner trace_xfs_bmap_post_update(bma->ip, bma->idx, state, _THIS_IP_); 220430f712c9SDave Chinner trace_xfs_bmap_pre_update(bma->ip, bma->idx + 2, state, _THIS_IP_); 220530f712c9SDave Chinner xfs_bmbt_set_startblock(xfs_iext_get_ext(ifp, bma->idx + 2), 220630f712c9SDave Chinner nullstartblock((int)temp2)); 220730f712c9SDave Chinner trace_xfs_bmap_post_update(bma->ip, bma->idx + 2, state, _THIS_IP_); 220830f712c9SDave Chinner 220930f712c9SDave Chinner bma->idx++; 221030f712c9SDave Chinner da_new = temp + temp2; 221130f712c9SDave Chinner break; 221230f712c9SDave Chinner 221330f712c9SDave Chinner case BMAP_LEFT_FILLING | BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG: 221430f712c9SDave Chinner case BMAP_RIGHT_FILLING | BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG: 221530f712c9SDave Chinner case BMAP_LEFT_FILLING | BMAP_RIGHT_CONTIG: 221630f712c9SDave Chinner case BMAP_RIGHT_FILLING | BMAP_LEFT_CONTIG: 221730f712c9SDave Chinner case BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG: 221830f712c9SDave Chinner case BMAP_LEFT_CONTIG: 221930f712c9SDave Chinner case BMAP_RIGHT_CONTIG: 222030f712c9SDave Chinner /* 222130f712c9SDave Chinner * These cases are all impossible. 222230f712c9SDave Chinner */ 222330f712c9SDave Chinner ASSERT(0); 222430f712c9SDave Chinner } 222530f712c9SDave Chinner 22269c194644SDarrick J. Wong /* add reverse mapping */ 22279c194644SDarrick J. Wong error = xfs_rmap_map_extent(mp, bma->dfops, bma->ip, whichfork, new); 22289c194644SDarrick J. Wong if (error) 22299c194644SDarrick J. Wong goto done; 22309c194644SDarrick J. Wong 223130f712c9SDave Chinner /* convert to a btree if necessary */ 22326d3eb1ecSDarrick J. Wong if (xfs_bmap_needs_btree(bma->ip, whichfork)) { 223330f712c9SDave Chinner int tmp_logflags; /* partial log flag return val */ 223430f712c9SDave Chinner 223530f712c9SDave Chinner ASSERT(bma->cur == NULL); 223630f712c9SDave Chinner error = xfs_bmap_extents_to_btree(bma->tp, bma->ip, 22372c3234d1SDarrick J. Wong bma->firstblock, bma->dfops, &bma->cur, 22386d3eb1ecSDarrick J. Wong da_old > 0, &tmp_logflags, whichfork); 223930f712c9SDave Chinner bma->logflags |= tmp_logflags; 224030f712c9SDave Chinner if (error) 224130f712c9SDave Chinner goto done; 224230f712c9SDave Chinner } 224330f712c9SDave Chinner 224430f712c9SDave Chinner /* adjust for changes in reserved delayed indirect blocks */ 224530f712c9SDave Chinner if (da_old || da_new) { 224630f712c9SDave Chinner temp = da_new; 224730f712c9SDave Chinner if (bma->cur) 224830f712c9SDave Chinner temp += bma->cur->bc_private.b.allocated; 224930f712c9SDave Chinner ASSERT(temp <= da_old); 225030f712c9SDave Chinner if (temp < da_old) 22510d485adaSDave Chinner xfs_mod_fdblocks(bma->ip->i_mount, 22520d485adaSDave Chinner (int64_t)(da_old - temp), false); 225330f712c9SDave Chinner } 225430f712c9SDave Chinner 225530f712c9SDave Chinner /* clear out the allocated field, done with it now in any case. */ 225630f712c9SDave Chinner if (bma->cur) 225730f712c9SDave Chinner bma->cur->bc_private.b.allocated = 0; 225830f712c9SDave Chinner 22596d3eb1ecSDarrick J. Wong xfs_bmap_check_leaf_extents(bma->cur, bma->ip, whichfork); 226030f712c9SDave Chinner done: 226160b4984fSDarrick J. Wong if (whichfork != XFS_COW_FORK) 226230f712c9SDave Chinner bma->logflags |= rval; 226330f712c9SDave Chinner return error; 226430f712c9SDave Chinner #undef LEFT 226530f712c9SDave Chinner #undef RIGHT 226630f712c9SDave Chinner #undef PREV 226730f712c9SDave Chinner } 226830f712c9SDave Chinner 226930f712c9SDave Chinner /* 227030f712c9SDave Chinner * Convert an unwritten allocation to a real allocation or vice versa. 227130f712c9SDave Chinner */ 227230f712c9SDave Chinner STATIC int /* error */ 227330f712c9SDave Chinner xfs_bmap_add_extent_unwritten_real( 227430f712c9SDave Chinner struct xfs_trans *tp, 227530f712c9SDave Chinner xfs_inode_t *ip, /* incore inode pointer */ 227630f712c9SDave Chinner xfs_extnum_t *idx, /* extent number to update/insert */ 227730f712c9SDave Chinner xfs_btree_cur_t **curp, /* if *curp is null, not a btree */ 227830f712c9SDave Chinner xfs_bmbt_irec_t *new, /* new data to add to file extents */ 227930f712c9SDave Chinner xfs_fsblock_t *first, /* pointer to firstblock variable */ 22802c3234d1SDarrick J. Wong struct xfs_defer_ops *dfops, /* list of extents to be freed */ 228130f712c9SDave Chinner int *logflagsp) /* inode logging flags */ 228230f712c9SDave Chinner { 228330f712c9SDave Chinner xfs_btree_cur_t *cur; /* btree cursor */ 228430f712c9SDave Chinner xfs_bmbt_rec_host_t *ep; /* extent entry for idx */ 228530f712c9SDave Chinner int error; /* error return value */ 228630f712c9SDave Chinner int i; /* temp state */ 228730f712c9SDave Chinner xfs_ifork_t *ifp; /* inode fork pointer */ 228830f712c9SDave Chinner xfs_fileoff_t new_endoff; /* end offset of new entry */ 228930f712c9SDave Chinner xfs_exntst_t newext; /* new extent state */ 229030f712c9SDave Chinner xfs_exntst_t oldext; /* old extent state */ 229130f712c9SDave Chinner xfs_bmbt_irec_t r[3]; /* neighbor extent entries */ 229230f712c9SDave Chinner /* left is 0, right is 1, prev is 2 */ 229330f712c9SDave Chinner int rval=0; /* return value (logging flags) */ 229430f712c9SDave Chinner int state = 0;/* state bits, accessed thru macros */ 2295c29aad41SEric Sandeen struct xfs_mount *mp = tp->t_mountp; 229630f712c9SDave Chinner 229730f712c9SDave Chinner *logflagsp = 0; 229830f712c9SDave Chinner 229930f712c9SDave Chinner cur = *curp; 230030f712c9SDave Chinner ifp = XFS_IFORK_PTR(ip, XFS_DATA_FORK); 230130f712c9SDave Chinner 230230f712c9SDave Chinner ASSERT(*idx >= 0); 230330f712c9SDave Chinner ASSERT(*idx <= ifp->if_bytes / sizeof(struct xfs_bmbt_rec)); 230430f712c9SDave Chinner ASSERT(!isnullstartblock(new->br_startblock)); 230530f712c9SDave Chinner 2306ff6d6af2SBill O'Donnell XFS_STATS_INC(mp, xs_add_exlist); 230730f712c9SDave Chinner 230830f712c9SDave Chinner #define LEFT r[0] 230930f712c9SDave Chinner #define RIGHT r[1] 231030f712c9SDave Chinner #define PREV r[2] 231130f712c9SDave Chinner 231230f712c9SDave Chinner /* 231330f712c9SDave Chinner * Set up a bunch of variables to make the tests simpler. 231430f712c9SDave Chinner */ 231530f712c9SDave Chinner error = 0; 231630f712c9SDave Chinner ep = xfs_iext_get_ext(ifp, *idx); 231730f712c9SDave Chinner xfs_bmbt_get_all(ep, &PREV); 231830f712c9SDave Chinner newext = new->br_state; 231930f712c9SDave Chinner oldext = (newext == XFS_EXT_UNWRITTEN) ? 232030f712c9SDave Chinner XFS_EXT_NORM : XFS_EXT_UNWRITTEN; 232130f712c9SDave Chinner ASSERT(PREV.br_state == oldext); 232230f712c9SDave Chinner new_endoff = new->br_startoff + new->br_blockcount; 232330f712c9SDave Chinner ASSERT(PREV.br_startoff <= new->br_startoff); 232430f712c9SDave Chinner ASSERT(PREV.br_startoff + PREV.br_blockcount >= new_endoff); 232530f712c9SDave Chinner 232630f712c9SDave Chinner /* 232730f712c9SDave Chinner * Set flags determining what part of the previous oldext allocation 232830f712c9SDave Chinner * extent is being replaced by a newext allocation. 232930f712c9SDave Chinner */ 233030f712c9SDave Chinner if (PREV.br_startoff == new->br_startoff) 233130f712c9SDave Chinner state |= BMAP_LEFT_FILLING; 233230f712c9SDave Chinner if (PREV.br_startoff + PREV.br_blockcount == new_endoff) 233330f712c9SDave Chinner state |= BMAP_RIGHT_FILLING; 233430f712c9SDave Chinner 233530f712c9SDave Chinner /* 233630f712c9SDave Chinner * Check and set flags if this segment has a left neighbor. 233730f712c9SDave Chinner * Don't set contiguous if the combined extent would be too large. 233830f712c9SDave Chinner */ 233930f712c9SDave Chinner if (*idx > 0) { 234030f712c9SDave Chinner state |= BMAP_LEFT_VALID; 234130f712c9SDave Chinner xfs_bmbt_get_all(xfs_iext_get_ext(ifp, *idx - 1), &LEFT); 234230f712c9SDave Chinner 234330f712c9SDave Chinner if (isnullstartblock(LEFT.br_startblock)) 234430f712c9SDave Chinner state |= BMAP_LEFT_DELAY; 234530f712c9SDave Chinner } 234630f712c9SDave Chinner 234730f712c9SDave Chinner if ((state & BMAP_LEFT_VALID) && !(state & BMAP_LEFT_DELAY) && 234830f712c9SDave Chinner LEFT.br_startoff + LEFT.br_blockcount == new->br_startoff && 234930f712c9SDave Chinner LEFT.br_startblock + LEFT.br_blockcount == new->br_startblock && 235030f712c9SDave Chinner LEFT.br_state == newext && 235130f712c9SDave Chinner LEFT.br_blockcount + new->br_blockcount <= MAXEXTLEN) 235230f712c9SDave Chinner state |= BMAP_LEFT_CONTIG; 235330f712c9SDave Chinner 235430f712c9SDave Chinner /* 235530f712c9SDave Chinner * Check and set flags if this segment has a right neighbor. 235630f712c9SDave Chinner * Don't set contiguous if the combined extent would be too large. 235730f712c9SDave Chinner * Also check for all-three-contiguous being too large. 235830f712c9SDave Chinner */ 235930f712c9SDave Chinner if (*idx < ip->i_df.if_bytes / (uint)sizeof(xfs_bmbt_rec_t) - 1) { 236030f712c9SDave Chinner state |= BMAP_RIGHT_VALID; 236130f712c9SDave Chinner xfs_bmbt_get_all(xfs_iext_get_ext(ifp, *idx + 1), &RIGHT); 236230f712c9SDave Chinner if (isnullstartblock(RIGHT.br_startblock)) 236330f712c9SDave Chinner state |= BMAP_RIGHT_DELAY; 236430f712c9SDave Chinner } 236530f712c9SDave Chinner 236630f712c9SDave Chinner if ((state & BMAP_RIGHT_VALID) && !(state & BMAP_RIGHT_DELAY) && 236730f712c9SDave Chinner new_endoff == RIGHT.br_startoff && 236830f712c9SDave Chinner new->br_startblock + new->br_blockcount == RIGHT.br_startblock && 236930f712c9SDave Chinner newext == RIGHT.br_state && 237030f712c9SDave Chinner new->br_blockcount + RIGHT.br_blockcount <= MAXEXTLEN && 237130f712c9SDave Chinner ((state & (BMAP_LEFT_CONTIG | BMAP_LEFT_FILLING | 237230f712c9SDave Chinner BMAP_RIGHT_FILLING)) != 237330f712c9SDave Chinner (BMAP_LEFT_CONTIG | BMAP_LEFT_FILLING | 237430f712c9SDave Chinner BMAP_RIGHT_FILLING) || 237530f712c9SDave Chinner LEFT.br_blockcount + new->br_blockcount + RIGHT.br_blockcount 237630f712c9SDave Chinner <= MAXEXTLEN)) 237730f712c9SDave Chinner state |= BMAP_RIGHT_CONTIG; 237830f712c9SDave Chinner 237930f712c9SDave Chinner /* 238030f712c9SDave Chinner * Switch out based on the FILLING and CONTIG state bits. 238130f712c9SDave Chinner */ 238230f712c9SDave Chinner switch (state & (BMAP_LEFT_FILLING | BMAP_LEFT_CONTIG | 238330f712c9SDave Chinner BMAP_RIGHT_FILLING | BMAP_RIGHT_CONTIG)) { 238430f712c9SDave Chinner case BMAP_LEFT_FILLING | BMAP_LEFT_CONTIG | 238530f712c9SDave Chinner BMAP_RIGHT_FILLING | BMAP_RIGHT_CONTIG: 238630f712c9SDave Chinner /* 238730f712c9SDave Chinner * Setting all of a previous oldext extent to newext. 238830f712c9SDave Chinner * The left and right neighbors are both contiguous with new. 238930f712c9SDave Chinner */ 239030f712c9SDave Chinner --*idx; 239130f712c9SDave Chinner 239230f712c9SDave Chinner trace_xfs_bmap_pre_update(ip, *idx, state, _THIS_IP_); 239330f712c9SDave Chinner xfs_bmbt_set_blockcount(xfs_iext_get_ext(ifp, *idx), 239430f712c9SDave Chinner LEFT.br_blockcount + PREV.br_blockcount + 239530f712c9SDave Chinner RIGHT.br_blockcount); 239630f712c9SDave Chinner trace_xfs_bmap_post_update(ip, *idx, state, _THIS_IP_); 239730f712c9SDave Chinner 239830f712c9SDave Chinner xfs_iext_remove(ip, *idx + 1, 2, state); 239930f712c9SDave Chinner ip->i_d.di_nextents -= 2; 240030f712c9SDave Chinner if (cur == NULL) 240130f712c9SDave Chinner rval = XFS_ILOG_CORE | XFS_ILOG_DEXT; 240230f712c9SDave Chinner else { 240330f712c9SDave Chinner rval = XFS_ILOG_CORE; 240430f712c9SDave Chinner if ((error = xfs_bmbt_lookup_eq(cur, RIGHT.br_startoff, 240530f712c9SDave Chinner RIGHT.br_startblock, 240630f712c9SDave Chinner RIGHT.br_blockcount, &i))) 240730f712c9SDave Chinner goto done; 2408c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 240930f712c9SDave Chinner if ((error = xfs_btree_delete(cur, &i))) 241030f712c9SDave Chinner goto done; 2411c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 241230f712c9SDave Chinner if ((error = xfs_btree_decrement(cur, 0, &i))) 241330f712c9SDave Chinner goto done; 2414c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 241530f712c9SDave Chinner if ((error = xfs_btree_delete(cur, &i))) 241630f712c9SDave Chinner goto done; 2417c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 241830f712c9SDave Chinner if ((error = xfs_btree_decrement(cur, 0, &i))) 241930f712c9SDave Chinner goto done; 2420c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 242130f712c9SDave Chinner if ((error = xfs_bmbt_update(cur, LEFT.br_startoff, 242230f712c9SDave Chinner LEFT.br_startblock, 242330f712c9SDave Chinner LEFT.br_blockcount + PREV.br_blockcount + 242430f712c9SDave Chinner RIGHT.br_blockcount, LEFT.br_state))) 242530f712c9SDave Chinner goto done; 242630f712c9SDave Chinner } 242730f712c9SDave Chinner break; 242830f712c9SDave Chinner 242930f712c9SDave Chinner case BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING | BMAP_LEFT_CONTIG: 243030f712c9SDave Chinner /* 243130f712c9SDave Chinner * Setting all of a previous oldext extent to newext. 243230f712c9SDave Chinner * The left neighbor is contiguous, the right is not. 243330f712c9SDave Chinner */ 243430f712c9SDave Chinner --*idx; 243530f712c9SDave Chinner 243630f712c9SDave Chinner trace_xfs_bmap_pre_update(ip, *idx, state, _THIS_IP_); 243730f712c9SDave Chinner xfs_bmbt_set_blockcount(xfs_iext_get_ext(ifp, *idx), 243830f712c9SDave Chinner LEFT.br_blockcount + PREV.br_blockcount); 243930f712c9SDave Chinner trace_xfs_bmap_post_update(ip, *idx, state, _THIS_IP_); 244030f712c9SDave Chinner 244130f712c9SDave Chinner xfs_iext_remove(ip, *idx + 1, 1, state); 244230f712c9SDave Chinner ip->i_d.di_nextents--; 244330f712c9SDave Chinner if (cur == NULL) 244430f712c9SDave Chinner rval = XFS_ILOG_CORE | XFS_ILOG_DEXT; 244530f712c9SDave Chinner else { 244630f712c9SDave Chinner rval = XFS_ILOG_CORE; 244730f712c9SDave Chinner if ((error = xfs_bmbt_lookup_eq(cur, PREV.br_startoff, 244830f712c9SDave Chinner PREV.br_startblock, PREV.br_blockcount, 244930f712c9SDave Chinner &i))) 245030f712c9SDave Chinner goto done; 2451c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 245230f712c9SDave Chinner if ((error = xfs_btree_delete(cur, &i))) 245330f712c9SDave Chinner goto done; 2454c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 245530f712c9SDave Chinner if ((error = xfs_btree_decrement(cur, 0, &i))) 245630f712c9SDave Chinner goto done; 2457c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 245830f712c9SDave Chinner if ((error = xfs_bmbt_update(cur, LEFT.br_startoff, 245930f712c9SDave Chinner LEFT.br_startblock, 246030f712c9SDave Chinner LEFT.br_blockcount + PREV.br_blockcount, 246130f712c9SDave Chinner LEFT.br_state))) 246230f712c9SDave Chinner goto done; 246330f712c9SDave Chinner } 246430f712c9SDave Chinner break; 246530f712c9SDave Chinner 246630f712c9SDave Chinner case BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING | BMAP_RIGHT_CONTIG: 246730f712c9SDave Chinner /* 246830f712c9SDave Chinner * Setting all of a previous oldext extent to newext. 246930f712c9SDave Chinner * The right neighbor is contiguous, the left is not. 247030f712c9SDave Chinner */ 247130f712c9SDave Chinner trace_xfs_bmap_pre_update(ip, *idx, state, _THIS_IP_); 247230f712c9SDave Chinner xfs_bmbt_set_blockcount(ep, 247330f712c9SDave Chinner PREV.br_blockcount + RIGHT.br_blockcount); 247430f712c9SDave Chinner xfs_bmbt_set_state(ep, newext); 247530f712c9SDave Chinner trace_xfs_bmap_post_update(ip, *idx, state, _THIS_IP_); 247630f712c9SDave Chinner xfs_iext_remove(ip, *idx + 1, 1, state); 247730f712c9SDave Chinner ip->i_d.di_nextents--; 247830f712c9SDave Chinner if (cur == NULL) 247930f712c9SDave Chinner rval = XFS_ILOG_CORE | XFS_ILOG_DEXT; 248030f712c9SDave Chinner else { 248130f712c9SDave Chinner rval = XFS_ILOG_CORE; 248230f712c9SDave Chinner if ((error = xfs_bmbt_lookup_eq(cur, RIGHT.br_startoff, 248330f712c9SDave Chinner RIGHT.br_startblock, 248430f712c9SDave Chinner RIGHT.br_blockcount, &i))) 248530f712c9SDave Chinner goto done; 2486c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 248730f712c9SDave Chinner if ((error = xfs_btree_delete(cur, &i))) 248830f712c9SDave Chinner goto done; 2489c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 249030f712c9SDave Chinner if ((error = xfs_btree_decrement(cur, 0, &i))) 249130f712c9SDave Chinner goto done; 2492c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 249330f712c9SDave Chinner if ((error = xfs_bmbt_update(cur, new->br_startoff, 249430f712c9SDave Chinner new->br_startblock, 249530f712c9SDave Chinner new->br_blockcount + RIGHT.br_blockcount, 249630f712c9SDave Chinner newext))) 249730f712c9SDave Chinner goto done; 249830f712c9SDave Chinner } 249930f712c9SDave Chinner break; 250030f712c9SDave Chinner 250130f712c9SDave Chinner case BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING: 250230f712c9SDave Chinner /* 250330f712c9SDave Chinner * Setting all of a previous oldext extent to newext. 250430f712c9SDave Chinner * Neither the left nor right neighbors are contiguous with 250530f712c9SDave Chinner * the new one. 250630f712c9SDave Chinner */ 250730f712c9SDave Chinner trace_xfs_bmap_pre_update(ip, *idx, state, _THIS_IP_); 250830f712c9SDave Chinner xfs_bmbt_set_state(ep, newext); 250930f712c9SDave Chinner trace_xfs_bmap_post_update(ip, *idx, state, _THIS_IP_); 251030f712c9SDave Chinner 251130f712c9SDave Chinner if (cur == NULL) 251230f712c9SDave Chinner rval = XFS_ILOG_DEXT; 251330f712c9SDave Chinner else { 251430f712c9SDave Chinner rval = 0; 251530f712c9SDave Chinner if ((error = xfs_bmbt_lookup_eq(cur, new->br_startoff, 251630f712c9SDave Chinner new->br_startblock, new->br_blockcount, 251730f712c9SDave Chinner &i))) 251830f712c9SDave Chinner goto done; 2519c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 252030f712c9SDave Chinner if ((error = xfs_bmbt_update(cur, new->br_startoff, 252130f712c9SDave Chinner new->br_startblock, new->br_blockcount, 252230f712c9SDave Chinner newext))) 252330f712c9SDave Chinner goto done; 252430f712c9SDave Chinner } 252530f712c9SDave Chinner break; 252630f712c9SDave Chinner 252730f712c9SDave Chinner case BMAP_LEFT_FILLING | BMAP_LEFT_CONTIG: 252830f712c9SDave Chinner /* 252930f712c9SDave Chinner * Setting the first part of a previous oldext extent to newext. 253030f712c9SDave Chinner * The left neighbor is contiguous. 253130f712c9SDave Chinner */ 253230f712c9SDave Chinner trace_xfs_bmap_pre_update(ip, *idx - 1, state, _THIS_IP_); 253330f712c9SDave Chinner xfs_bmbt_set_blockcount(xfs_iext_get_ext(ifp, *idx - 1), 253430f712c9SDave Chinner LEFT.br_blockcount + new->br_blockcount); 253530f712c9SDave Chinner xfs_bmbt_set_startoff(ep, 253630f712c9SDave Chinner PREV.br_startoff + new->br_blockcount); 253730f712c9SDave Chinner trace_xfs_bmap_post_update(ip, *idx - 1, state, _THIS_IP_); 253830f712c9SDave Chinner 253930f712c9SDave Chinner trace_xfs_bmap_pre_update(ip, *idx, state, _THIS_IP_); 254030f712c9SDave Chinner xfs_bmbt_set_startblock(ep, 254130f712c9SDave Chinner new->br_startblock + new->br_blockcount); 254230f712c9SDave Chinner xfs_bmbt_set_blockcount(ep, 254330f712c9SDave Chinner PREV.br_blockcount - new->br_blockcount); 254430f712c9SDave Chinner trace_xfs_bmap_post_update(ip, *idx, state, _THIS_IP_); 254530f712c9SDave Chinner 254630f712c9SDave Chinner --*idx; 254730f712c9SDave Chinner 254830f712c9SDave Chinner if (cur == NULL) 254930f712c9SDave Chinner rval = XFS_ILOG_DEXT; 255030f712c9SDave Chinner else { 255130f712c9SDave Chinner rval = 0; 255230f712c9SDave Chinner if ((error = xfs_bmbt_lookup_eq(cur, PREV.br_startoff, 255330f712c9SDave Chinner PREV.br_startblock, PREV.br_blockcount, 255430f712c9SDave Chinner &i))) 255530f712c9SDave Chinner goto done; 2556c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 255730f712c9SDave Chinner if ((error = xfs_bmbt_update(cur, 255830f712c9SDave Chinner PREV.br_startoff + new->br_blockcount, 255930f712c9SDave Chinner PREV.br_startblock + new->br_blockcount, 256030f712c9SDave Chinner PREV.br_blockcount - new->br_blockcount, 256130f712c9SDave Chinner oldext))) 256230f712c9SDave Chinner goto done; 256330f712c9SDave Chinner if ((error = xfs_btree_decrement(cur, 0, &i))) 256430f712c9SDave Chinner goto done; 256530f712c9SDave Chinner error = xfs_bmbt_update(cur, LEFT.br_startoff, 256630f712c9SDave Chinner LEFT.br_startblock, 256730f712c9SDave Chinner LEFT.br_blockcount + new->br_blockcount, 256830f712c9SDave Chinner LEFT.br_state); 256930f712c9SDave Chinner if (error) 257030f712c9SDave Chinner goto done; 257130f712c9SDave Chinner } 257230f712c9SDave Chinner break; 257330f712c9SDave Chinner 257430f712c9SDave Chinner case BMAP_LEFT_FILLING: 257530f712c9SDave Chinner /* 257630f712c9SDave Chinner * Setting the first part of a previous oldext extent to newext. 257730f712c9SDave Chinner * The left neighbor is not contiguous. 257830f712c9SDave Chinner */ 257930f712c9SDave Chinner trace_xfs_bmap_pre_update(ip, *idx, state, _THIS_IP_); 258030f712c9SDave Chinner ASSERT(ep && xfs_bmbt_get_state(ep) == oldext); 258130f712c9SDave Chinner xfs_bmbt_set_startoff(ep, new_endoff); 258230f712c9SDave Chinner xfs_bmbt_set_blockcount(ep, 258330f712c9SDave Chinner PREV.br_blockcount - new->br_blockcount); 258430f712c9SDave Chinner xfs_bmbt_set_startblock(ep, 258530f712c9SDave Chinner new->br_startblock + new->br_blockcount); 258630f712c9SDave Chinner trace_xfs_bmap_post_update(ip, *idx, state, _THIS_IP_); 258730f712c9SDave Chinner 258830f712c9SDave Chinner xfs_iext_insert(ip, *idx, 1, new, state); 258930f712c9SDave Chinner ip->i_d.di_nextents++; 259030f712c9SDave Chinner if (cur == NULL) 259130f712c9SDave Chinner rval = XFS_ILOG_CORE | XFS_ILOG_DEXT; 259230f712c9SDave Chinner else { 259330f712c9SDave Chinner rval = XFS_ILOG_CORE; 259430f712c9SDave Chinner if ((error = xfs_bmbt_lookup_eq(cur, PREV.br_startoff, 259530f712c9SDave Chinner PREV.br_startblock, PREV.br_blockcount, 259630f712c9SDave Chinner &i))) 259730f712c9SDave Chinner goto done; 2598c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 259930f712c9SDave Chinner if ((error = xfs_bmbt_update(cur, 260030f712c9SDave Chinner PREV.br_startoff + new->br_blockcount, 260130f712c9SDave Chinner PREV.br_startblock + new->br_blockcount, 260230f712c9SDave Chinner PREV.br_blockcount - new->br_blockcount, 260330f712c9SDave Chinner oldext))) 260430f712c9SDave Chinner goto done; 260530f712c9SDave Chinner cur->bc_rec.b = *new; 260630f712c9SDave Chinner if ((error = xfs_btree_insert(cur, &i))) 260730f712c9SDave Chinner goto done; 2608c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 260930f712c9SDave Chinner } 261030f712c9SDave Chinner break; 261130f712c9SDave Chinner 261230f712c9SDave Chinner case BMAP_RIGHT_FILLING | BMAP_RIGHT_CONTIG: 261330f712c9SDave Chinner /* 261430f712c9SDave Chinner * Setting the last part of a previous oldext extent to newext. 261530f712c9SDave Chinner * The right neighbor is contiguous with the new allocation. 261630f712c9SDave Chinner */ 261730f712c9SDave Chinner trace_xfs_bmap_pre_update(ip, *idx, state, _THIS_IP_); 261830f712c9SDave Chinner xfs_bmbt_set_blockcount(ep, 261930f712c9SDave Chinner PREV.br_blockcount - new->br_blockcount); 262030f712c9SDave Chinner trace_xfs_bmap_post_update(ip, *idx, state, _THIS_IP_); 262130f712c9SDave Chinner 262230f712c9SDave Chinner ++*idx; 262330f712c9SDave Chinner 262430f712c9SDave Chinner trace_xfs_bmap_pre_update(ip, *idx, state, _THIS_IP_); 262530f712c9SDave Chinner xfs_bmbt_set_allf(xfs_iext_get_ext(ifp, *idx), 262630f712c9SDave Chinner new->br_startoff, new->br_startblock, 262730f712c9SDave Chinner new->br_blockcount + RIGHT.br_blockcount, newext); 262830f712c9SDave Chinner trace_xfs_bmap_post_update(ip, *idx, state, _THIS_IP_); 262930f712c9SDave Chinner 263030f712c9SDave Chinner if (cur == NULL) 263130f712c9SDave Chinner rval = XFS_ILOG_DEXT; 263230f712c9SDave Chinner else { 263330f712c9SDave Chinner rval = 0; 263430f712c9SDave Chinner if ((error = xfs_bmbt_lookup_eq(cur, PREV.br_startoff, 263530f712c9SDave Chinner PREV.br_startblock, 263630f712c9SDave Chinner PREV.br_blockcount, &i))) 263730f712c9SDave Chinner goto done; 2638c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 263930f712c9SDave Chinner if ((error = xfs_bmbt_update(cur, PREV.br_startoff, 264030f712c9SDave Chinner PREV.br_startblock, 264130f712c9SDave Chinner PREV.br_blockcount - new->br_blockcount, 264230f712c9SDave Chinner oldext))) 264330f712c9SDave Chinner goto done; 264430f712c9SDave Chinner if ((error = xfs_btree_increment(cur, 0, &i))) 264530f712c9SDave Chinner goto done; 264630f712c9SDave Chinner if ((error = xfs_bmbt_update(cur, new->br_startoff, 264730f712c9SDave Chinner new->br_startblock, 264830f712c9SDave Chinner new->br_blockcount + RIGHT.br_blockcount, 264930f712c9SDave Chinner newext))) 265030f712c9SDave Chinner goto done; 265130f712c9SDave Chinner } 265230f712c9SDave Chinner break; 265330f712c9SDave Chinner 265430f712c9SDave Chinner case BMAP_RIGHT_FILLING: 265530f712c9SDave Chinner /* 265630f712c9SDave Chinner * Setting the last part of a previous oldext extent to newext. 265730f712c9SDave Chinner * The right neighbor is not contiguous. 265830f712c9SDave Chinner */ 265930f712c9SDave Chinner trace_xfs_bmap_pre_update(ip, *idx, state, _THIS_IP_); 266030f712c9SDave Chinner xfs_bmbt_set_blockcount(ep, 266130f712c9SDave Chinner PREV.br_blockcount - new->br_blockcount); 266230f712c9SDave Chinner trace_xfs_bmap_post_update(ip, *idx, state, _THIS_IP_); 266330f712c9SDave Chinner 266430f712c9SDave Chinner ++*idx; 266530f712c9SDave Chinner xfs_iext_insert(ip, *idx, 1, new, state); 266630f712c9SDave Chinner 266730f712c9SDave Chinner ip->i_d.di_nextents++; 266830f712c9SDave Chinner if (cur == NULL) 266930f712c9SDave Chinner rval = XFS_ILOG_CORE | XFS_ILOG_DEXT; 267030f712c9SDave Chinner else { 267130f712c9SDave Chinner rval = XFS_ILOG_CORE; 267230f712c9SDave Chinner if ((error = xfs_bmbt_lookup_eq(cur, PREV.br_startoff, 267330f712c9SDave Chinner PREV.br_startblock, PREV.br_blockcount, 267430f712c9SDave Chinner &i))) 267530f712c9SDave Chinner goto done; 2676c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 267730f712c9SDave Chinner if ((error = xfs_bmbt_update(cur, PREV.br_startoff, 267830f712c9SDave Chinner PREV.br_startblock, 267930f712c9SDave Chinner PREV.br_blockcount - new->br_blockcount, 268030f712c9SDave Chinner oldext))) 268130f712c9SDave Chinner goto done; 268230f712c9SDave Chinner if ((error = xfs_bmbt_lookup_eq(cur, new->br_startoff, 268330f712c9SDave Chinner new->br_startblock, new->br_blockcount, 268430f712c9SDave Chinner &i))) 268530f712c9SDave Chinner goto done; 2686c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 0, done); 268730f712c9SDave Chinner cur->bc_rec.b.br_state = XFS_EXT_NORM; 268830f712c9SDave Chinner if ((error = xfs_btree_insert(cur, &i))) 268930f712c9SDave Chinner goto done; 2690c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 269130f712c9SDave Chinner } 269230f712c9SDave Chinner break; 269330f712c9SDave Chinner 269430f712c9SDave Chinner case 0: 269530f712c9SDave Chinner /* 269630f712c9SDave Chinner * Setting the middle part of a previous oldext extent to 269730f712c9SDave Chinner * newext. Contiguity is impossible here. 269830f712c9SDave Chinner * One extent becomes three extents. 269930f712c9SDave Chinner */ 270030f712c9SDave Chinner trace_xfs_bmap_pre_update(ip, *idx, state, _THIS_IP_); 270130f712c9SDave Chinner xfs_bmbt_set_blockcount(ep, 270230f712c9SDave Chinner new->br_startoff - PREV.br_startoff); 270330f712c9SDave Chinner trace_xfs_bmap_post_update(ip, *idx, state, _THIS_IP_); 270430f712c9SDave Chinner 270530f712c9SDave Chinner r[0] = *new; 270630f712c9SDave Chinner r[1].br_startoff = new_endoff; 270730f712c9SDave Chinner r[1].br_blockcount = 270830f712c9SDave Chinner PREV.br_startoff + PREV.br_blockcount - new_endoff; 270930f712c9SDave Chinner r[1].br_startblock = new->br_startblock + new->br_blockcount; 271030f712c9SDave Chinner r[1].br_state = oldext; 271130f712c9SDave Chinner 271230f712c9SDave Chinner ++*idx; 271330f712c9SDave Chinner xfs_iext_insert(ip, *idx, 2, &r[0], state); 271430f712c9SDave Chinner 271530f712c9SDave Chinner ip->i_d.di_nextents += 2; 271630f712c9SDave Chinner if (cur == NULL) 271730f712c9SDave Chinner rval = XFS_ILOG_CORE | XFS_ILOG_DEXT; 271830f712c9SDave Chinner else { 271930f712c9SDave Chinner rval = XFS_ILOG_CORE; 272030f712c9SDave Chinner if ((error = xfs_bmbt_lookup_eq(cur, PREV.br_startoff, 272130f712c9SDave Chinner PREV.br_startblock, PREV.br_blockcount, 272230f712c9SDave Chinner &i))) 272330f712c9SDave Chinner goto done; 2724c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 272530f712c9SDave Chinner /* new right extent - oldext */ 272630f712c9SDave Chinner if ((error = xfs_bmbt_update(cur, r[1].br_startoff, 272730f712c9SDave Chinner r[1].br_startblock, r[1].br_blockcount, 272830f712c9SDave Chinner r[1].br_state))) 272930f712c9SDave Chinner goto done; 273030f712c9SDave Chinner /* new left extent - oldext */ 273130f712c9SDave Chinner cur->bc_rec.b = PREV; 273230f712c9SDave Chinner cur->bc_rec.b.br_blockcount = 273330f712c9SDave Chinner new->br_startoff - PREV.br_startoff; 273430f712c9SDave Chinner if ((error = xfs_btree_insert(cur, &i))) 273530f712c9SDave Chinner goto done; 2736c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 273730f712c9SDave Chinner /* 273830f712c9SDave Chinner * Reset the cursor to the position of the new extent 273930f712c9SDave Chinner * we are about to insert as we can't trust it after 274030f712c9SDave Chinner * the previous insert. 274130f712c9SDave Chinner */ 274230f712c9SDave Chinner if ((error = xfs_bmbt_lookup_eq(cur, new->br_startoff, 274330f712c9SDave Chinner new->br_startblock, new->br_blockcount, 274430f712c9SDave Chinner &i))) 274530f712c9SDave Chinner goto done; 2746c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 0, done); 274730f712c9SDave Chinner /* new middle extent - newext */ 274830f712c9SDave Chinner cur->bc_rec.b.br_state = new->br_state; 274930f712c9SDave Chinner if ((error = xfs_btree_insert(cur, &i))) 275030f712c9SDave Chinner goto done; 2751c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 275230f712c9SDave Chinner } 275330f712c9SDave Chinner break; 275430f712c9SDave Chinner 275530f712c9SDave Chinner case BMAP_LEFT_FILLING | BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG: 275630f712c9SDave Chinner case BMAP_RIGHT_FILLING | BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG: 275730f712c9SDave Chinner case BMAP_LEFT_FILLING | BMAP_RIGHT_CONTIG: 275830f712c9SDave Chinner case BMAP_RIGHT_FILLING | BMAP_LEFT_CONTIG: 275930f712c9SDave Chinner case BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG: 276030f712c9SDave Chinner case BMAP_LEFT_CONTIG: 276130f712c9SDave Chinner case BMAP_RIGHT_CONTIG: 276230f712c9SDave Chinner /* 276330f712c9SDave Chinner * These cases are all impossible. 276430f712c9SDave Chinner */ 276530f712c9SDave Chinner ASSERT(0); 276630f712c9SDave Chinner } 276730f712c9SDave Chinner 27689c194644SDarrick J. Wong /* update reverse mappings */ 27699c194644SDarrick J. Wong error = xfs_rmap_convert_extent(mp, dfops, ip, XFS_DATA_FORK, new); 27709c194644SDarrick J. Wong if (error) 27719c194644SDarrick J. Wong goto done; 27729c194644SDarrick J. Wong 277330f712c9SDave Chinner /* convert to a btree if necessary */ 277430f712c9SDave Chinner if (xfs_bmap_needs_btree(ip, XFS_DATA_FORK)) { 277530f712c9SDave Chinner int tmp_logflags; /* partial log flag return val */ 277630f712c9SDave Chinner 277730f712c9SDave Chinner ASSERT(cur == NULL); 27782c3234d1SDarrick J. Wong error = xfs_bmap_extents_to_btree(tp, ip, first, dfops, &cur, 277930f712c9SDave Chinner 0, &tmp_logflags, XFS_DATA_FORK); 278030f712c9SDave Chinner *logflagsp |= tmp_logflags; 278130f712c9SDave Chinner if (error) 278230f712c9SDave Chinner goto done; 278330f712c9SDave Chinner } 278430f712c9SDave Chinner 278530f712c9SDave Chinner /* clear out the allocated field, done with it now in any case. */ 278630f712c9SDave Chinner if (cur) { 278730f712c9SDave Chinner cur->bc_private.b.allocated = 0; 278830f712c9SDave Chinner *curp = cur; 278930f712c9SDave Chinner } 279030f712c9SDave Chinner 279130f712c9SDave Chinner xfs_bmap_check_leaf_extents(*curp, ip, XFS_DATA_FORK); 279230f712c9SDave Chinner done: 279330f712c9SDave Chinner *logflagsp |= rval; 279430f712c9SDave Chinner return error; 279530f712c9SDave Chinner #undef LEFT 279630f712c9SDave Chinner #undef RIGHT 279730f712c9SDave Chinner #undef PREV 279830f712c9SDave Chinner } 279930f712c9SDave Chinner 280030f712c9SDave Chinner /* 280130f712c9SDave Chinner * Convert a hole to a delayed allocation. 280230f712c9SDave Chinner */ 280330f712c9SDave Chinner STATIC void 280430f712c9SDave Chinner xfs_bmap_add_extent_hole_delay( 280530f712c9SDave Chinner xfs_inode_t *ip, /* incore inode pointer */ 2806be51f811SDarrick J. Wong int whichfork, 280730f712c9SDave Chinner xfs_extnum_t *idx, /* extent number to update/insert */ 280830f712c9SDave Chinner xfs_bmbt_irec_t *new) /* new data to add to file extents */ 280930f712c9SDave Chinner { 281030f712c9SDave Chinner xfs_ifork_t *ifp; /* inode fork pointer */ 281130f712c9SDave Chinner xfs_bmbt_irec_t left; /* left neighbor extent entry */ 281230f712c9SDave Chinner xfs_filblks_t newlen=0; /* new indirect size */ 281330f712c9SDave Chinner xfs_filblks_t oldlen=0; /* old indirect size */ 281430f712c9SDave Chinner xfs_bmbt_irec_t right; /* right neighbor extent entry */ 281530f712c9SDave Chinner int state; /* state bits, accessed thru macros */ 281630f712c9SDave Chinner xfs_filblks_t temp=0; /* temp for indirect calculations */ 281730f712c9SDave Chinner 2818be51f811SDarrick J. Wong ifp = XFS_IFORK_PTR(ip, whichfork); 281930f712c9SDave Chinner state = 0; 2820be51f811SDarrick J. Wong if (whichfork == XFS_COW_FORK) 2821be51f811SDarrick J. Wong state |= BMAP_COWFORK; 282230f712c9SDave Chinner ASSERT(isnullstartblock(new->br_startblock)); 282330f712c9SDave Chinner 282430f712c9SDave Chinner /* 282530f712c9SDave Chinner * Check and set flags if this segment has a left neighbor 282630f712c9SDave Chinner */ 282730f712c9SDave Chinner if (*idx > 0) { 282830f712c9SDave Chinner state |= BMAP_LEFT_VALID; 282930f712c9SDave Chinner xfs_bmbt_get_all(xfs_iext_get_ext(ifp, *idx - 1), &left); 283030f712c9SDave Chinner 283130f712c9SDave Chinner if (isnullstartblock(left.br_startblock)) 283230f712c9SDave Chinner state |= BMAP_LEFT_DELAY; 283330f712c9SDave Chinner } 283430f712c9SDave Chinner 283530f712c9SDave Chinner /* 283630f712c9SDave Chinner * Check and set flags if the current (right) segment exists. 283730f712c9SDave Chinner * If it doesn't exist, we're converting the hole at end-of-file. 283830f712c9SDave Chinner */ 2839be51f811SDarrick J. Wong if (*idx < ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t)) { 284030f712c9SDave Chinner state |= BMAP_RIGHT_VALID; 284130f712c9SDave Chinner xfs_bmbt_get_all(xfs_iext_get_ext(ifp, *idx), &right); 284230f712c9SDave Chinner 284330f712c9SDave Chinner if (isnullstartblock(right.br_startblock)) 284430f712c9SDave Chinner state |= BMAP_RIGHT_DELAY; 284530f712c9SDave Chinner } 284630f712c9SDave Chinner 284730f712c9SDave Chinner /* 284830f712c9SDave Chinner * Set contiguity flags on the left and right neighbors. 284930f712c9SDave Chinner * Don't let extents get too large, even if the pieces are contiguous. 285030f712c9SDave Chinner */ 285130f712c9SDave Chinner if ((state & BMAP_LEFT_VALID) && (state & BMAP_LEFT_DELAY) && 285230f712c9SDave Chinner left.br_startoff + left.br_blockcount == new->br_startoff && 285330f712c9SDave Chinner left.br_blockcount + new->br_blockcount <= MAXEXTLEN) 285430f712c9SDave Chinner state |= BMAP_LEFT_CONTIG; 285530f712c9SDave Chinner 285630f712c9SDave Chinner if ((state & BMAP_RIGHT_VALID) && (state & BMAP_RIGHT_DELAY) && 285730f712c9SDave Chinner new->br_startoff + new->br_blockcount == right.br_startoff && 285830f712c9SDave Chinner new->br_blockcount + right.br_blockcount <= MAXEXTLEN && 285930f712c9SDave Chinner (!(state & BMAP_LEFT_CONTIG) || 286030f712c9SDave Chinner (left.br_blockcount + new->br_blockcount + 286130f712c9SDave Chinner right.br_blockcount <= MAXEXTLEN))) 286230f712c9SDave Chinner state |= BMAP_RIGHT_CONTIG; 286330f712c9SDave Chinner 286430f712c9SDave Chinner /* 286530f712c9SDave Chinner * Switch out based on the contiguity flags. 286630f712c9SDave Chinner */ 286730f712c9SDave Chinner switch (state & (BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG)) { 286830f712c9SDave Chinner case BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG: 286930f712c9SDave Chinner /* 287030f712c9SDave Chinner * New allocation is contiguous with delayed allocations 287130f712c9SDave Chinner * on the left and on the right. 287230f712c9SDave Chinner * Merge all three into a single extent record. 287330f712c9SDave Chinner */ 287430f712c9SDave Chinner --*idx; 287530f712c9SDave Chinner temp = left.br_blockcount + new->br_blockcount + 287630f712c9SDave Chinner right.br_blockcount; 287730f712c9SDave Chinner 287830f712c9SDave Chinner trace_xfs_bmap_pre_update(ip, *idx, state, _THIS_IP_); 287930f712c9SDave Chinner xfs_bmbt_set_blockcount(xfs_iext_get_ext(ifp, *idx), temp); 288030f712c9SDave Chinner oldlen = startblockval(left.br_startblock) + 288130f712c9SDave Chinner startblockval(new->br_startblock) + 288230f712c9SDave Chinner startblockval(right.br_startblock); 288330f712c9SDave Chinner newlen = xfs_bmap_worst_indlen(ip, temp); 288430f712c9SDave Chinner xfs_bmbt_set_startblock(xfs_iext_get_ext(ifp, *idx), 288530f712c9SDave Chinner nullstartblock((int)newlen)); 288630f712c9SDave Chinner trace_xfs_bmap_post_update(ip, *idx, state, _THIS_IP_); 288730f712c9SDave Chinner 288830f712c9SDave Chinner xfs_iext_remove(ip, *idx + 1, 1, state); 288930f712c9SDave Chinner break; 289030f712c9SDave Chinner 289130f712c9SDave Chinner case BMAP_LEFT_CONTIG: 289230f712c9SDave Chinner /* 289330f712c9SDave Chinner * New allocation is contiguous with a delayed allocation 289430f712c9SDave Chinner * on the left. 289530f712c9SDave Chinner * Merge the new allocation with the left neighbor. 289630f712c9SDave Chinner */ 289730f712c9SDave Chinner --*idx; 289830f712c9SDave Chinner temp = left.br_blockcount + new->br_blockcount; 289930f712c9SDave Chinner 290030f712c9SDave Chinner trace_xfs_bmap_pre_update(ip, *idx, state, _THIS_IP_); 290130f712c9SDave Chinner xfs_bmbt_set_blockcount(xfs_iext_get_ext(ifp, *idx), temp); 290230f712c9SDave Chinner oldlen = startblockval(left.br_startblock) + 290330f712c9SDave Chinner startblockval(new->br_startblock); 290430f712c9SDave Chinner newlen = xfs_bmap_worst_indlen(ip, temp); 290530f712c9SDave Chinner xfs_bmbt_set_startblock(xfs_iext_get_ext(ifp, *idx), 290630f712c9SDave Chinner nullstartblock((int)newlen)); 290730f712c9SDave Chinner trace_xfs_bmap_post_update(ip, *idx, state, _THIS_IP_); 290830f712c9SDave Chinner break; 290930f712c9SDave Chinner 291030f712c9SDave Chinner case BMAP_RIGHT_CONTIG: 291130f712c9SDave Chinner /* 291230f712c9SDave Chinner * New allocation is contiguous with a delayed allocation 291330f712c9SDave Chinner * on the right. 291430f712c9SDave Chinner * Merge the new allocation with the right neighbor. 291530f712c9SDave Chinner */ 291630f712c9SDave Chinner trace_xfs_bmap_pre_update(ip, *idx, state, _THIS_IP_); 291730f712c9SDave Chinner temp = new->br_blockcount + right.br_blockcount; 291830f712c9SDave Chinner oldlen = startblockval(new->br_startblock) + 291930f712c9SDave Chinner startblockval(right.br_startblock); 292030f712c9SDave Chinner newlen = xfs_bmap_worst_indlen(ip, temp); 292130f712c9SDave Chinner xfs_bmbt_set_allf(xfs_iext_get_ext(ifp, *idx), 292230f712c9SDave Chinner new->br_startoff, 292330f712c9SDave Chinner nullstartblock((int)newlen), temp, right.br_state); 292430f712c9SDave Chinner trace_xfs_bmap_post_update(ip, *idx, state, _THIS_IP_); 292530f712c9SDave Chinner break; 292630f712c9SDave Chinner 292730f712c9SDave Chinner case 0: 292830f712c9SDave Chinner /* 292930f712c9SDave Chinner * New allocation is not contiguous with another 293030f712c9SDave Chinner * delayed allocation. 293130f712c9SDave Chinner * Insert a new entry. 293230f712c9SDave Chinner */ 293330f712c9SDave Chinner oldlen = newlen = 0; 293430f712c9SDave Chinner xfs_iext_insert(ip, *idx, 1, new, state); 293530f712c9SDave Chinner break; 293630f712c9SDave Chinner } 293730f712c9SDave Chinner if (oldlen != newlen) { 293830f712c9SDave Chinner ASSERT(oldlen > newlen); 29390d485adaSDave Chinner xfs_mod_fdblocks(ip->i_mount, (int64_t)(oldlen - newlen), 29400d485adaSDave Chinner false); 294130f712c9SDave Chinner /* 294230f712c9SDave Chinner * Nothing to do for disk quota accounting here. 294330f712c9SDave Chinner */ 294430f712c9SDave Chinner } 294530f712c9SDave Chinner } 294630f712c9SDave Chinner 294730f712c9SDave Chinner /* 294830f712c9SDave Chinner * Convert a hole to a real allocation. 294930f712c9SDave Chinner */ 295030f712c9SDave Chinner STATIC int /* error */ 295130f712c9SDave Chinner xfs_bmap_add_extent_hole_real( 295230f712c9SDave Chinner struct xfs_bmalloca *bma, 295330f712c9SDave Chinner int whichfork) 295430f712c9SDave Chinner { 295530f712c9SDave Chinner struct xfs_bmbt_irec *new = &bma->got; 295630f712c9SDave Chinner int error; /* error return value */ 295730f712c9SDave Chinner int i; /* temp state */ 295830f712c9SDave Chinner xfs_ifork_t *ifp; /* inode fork pointer */ 295930f712c9SDave Chinner xfs_bmbt_irec_t left; /* left neighbor extent entry */ 296030f712c9SDave Chinner xfs_bmbt_irec_t right; /* right neighbor extent entry */ 296130f712c9SDave Chinner int rval=0; /* return value (logging flags) */ 296230f712c9SDave Chinner int state; /* state bits, accessed thru macros */ 2963c29aad41SEric Sandeen struct xfs_mount *mp; 296430f712c9SDave Chinner 2965f1f96c49SEric Sandeen mp = bma->ip->i_mount; 296630f712c9SDave Chinner ifp = XFS_IFORK_PTR(bma->ip, whichfork); 296730f712c9SDave Chinner 296830f712c9SDave Chinner ASSERT(bma->idx >= 0); 296930f712c9SDave Chinner ASSERT(bma->idx <= ifp->if_bytes / sizeof(struct xfs_bmbt_rec)); 297030f712c9SDave Chinner ASSERT(!isnullstartblock(new->br_startblock)); 297130f712c9SDave Chinner ASSERT(!bma->cur || 297230f712c9SDave Chinner !(bma->cur->bc_private.b.flags & XFS_BTCUR_BPRV_WASDEL)); 29733993baebSDarrick J. Wong ASSERT(whichfork != XFS_COW_FORK); 297430f712c9SDave Chinner 2975ff6d6af2SBill O'Donnell XFS_STATS_INC(mp, xs_add_exlist); 297630f712c9SDave Chinner 297730f712c9SDave Chinner state = 0; 297830f712c9SDave Chinner if (whichfork == XFS_ATTR_FORK) 297930f712c9SDave Chinner state |= BMAP_ATTRFORK; 298030f712c9SDave Chinner 298130f712c9SDave Chinner /* 298230f712c9SDave Chinner * Check and set flags if this segment has a left neighbor. 298330f712c9SDave Chinner */ 298430f712c9SDave Chinner if (bma->idx > 0) { 298530f712c9SDave Chinner state |= BMAP_LEFT_VALID; 298630f712c9SDave Chinner xfs_bmbt_get_all(xfs_iext_get_ext(ifp, bma->idx - 1), &left); 298730f712c9SDave Chinner if (isnullstartblock(left.br_startblock)) 298830f712c9SDave Chinner state |= BMAP_LEFT_DELAY; 298930f712c9SDave Chinner } 299030f712c9SDave Chinner 299130f712c9SDave Chinner /* 299230f712c9SDave Chinner * Check and set flags if this segment has a current value. 299330f712c9SDave Chinner * Not true if we're inserting into the "hole" at eof. 299430f712c9SDave Chinner */ 299530f712c9SDave Chinner if (bma->idx < ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t)) { 299630f712c9SDave Chinner state |= BMAP_RIGHT_VALID; 299730f712c9SDave Chinner xfs_bmbt_get_all(xfs_iext_get_ext(ifp, bma->idx), &right); 299830f712c9SDave Chinner if (isnullstartblock(right.br_startblock)) 299930f712c9SDave Chinner state |= BMAP_RIGHT_DELAY; 300030f712c9SDave Chinner } 300130f712c9SDave Chinner 300230f712c9SDave Chinner /* 300330f712c9SDave Chinner * We're inserting a real allocation between "left" and "right". 300430f712c9SDave Chinner * Set the contiguity flags. Don't let extents get too large. 300530f712c9SDave Chinner */ 300630f712c9SDave Chinner if ((state & BMAP_LEFT_VALID) && !(state & BMAP_LEFT_DELAY) && 300730f712c9SDave Chinner left.br_startoff + left.br_blockcount == new->br_startoff && 300830f712c9SDave Chinner left.br_startblock + left.br_blockcount == new->br_startblock && 300930f712c9SDave Chinner left.br_state == new->br_state && 301030f712c9SDave Chinner left.br_blockcount + new->br_blockcount <= MAXEXTLEN) 301130f712c9SDave Chinner state |= BMAP_LEFT_CONTIG; 301230f712c9SDave Chinner 301330f712c9SDave Chinner if ((state & BMAP_RIGHT_VALID) && !(state & BMAP_RIGHT_DELAY) && 301430f712c9SDave Chinner new->br_startoff + new->br_blockcount == right.br_startoff && 301530f712c9SDave Chinner new->br_startblock + new->br_blockcount == right.br_startblock && 301630f712c9SDave Chinner new->br_state == right.br_state && 301730f712c9SDave Chinner new->br_blockcount + right.br_blockcount <= MAXEXTLEN && 301830f712c9SDave Chinner (!(state & BMAP_LEFT_CONTIG) || 301930f712c9SDave Chinner left.br_blockcount + new->br_blockcount + 302030f712c9SDave Chinner right.br_blockcount <= MAXEXTLEN)) 302130f712c9SDave Chinner state |= BMAP_RIGHT_CONTIG; 302230f712c9SDave Chinner 302330f712c9SDave Chinner error = 0; 302430f712c9SDave Chinner /* 302530f712c9SDave Chinner * Select which case we're in here, and implement it. 302630f712c9SDave Chinner */ 302730f712c9SDave Chinner switch (state & (BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG)) { 302830f712c9SDave Chinner case BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG: 302930f712c9SDave Chinner /* 303030f712c9SDave Chinner * New allocation is contiguous with real allocations on the 303130f712c9SDave Chinner * left and on the right. 303230f712c9SDave Chinner * Merge all three into a single extent record. 303330f712c9SDave Chinner */ 303430f712c9SDave Chinner --bma->idx; 303530f712c9SDave Chinner trace_xfs_bmap_pre_update(bma->ip, bma->idx, state, _THIS_IP_); 303630f712c9SDave Chinner xfs_bmbt_set_blockcount(xfs_iext_get_ext(ifp, bma->idx), 303730f712c9SDave Chinner left.br_blockcount + new->br_blockcount + 303830f712c9SDave Chinner right.br_blockcount); 303930f712c9SDave Chinner trace_xfs_bmap_post_update(bma->ip, bma->idx, state, _THIS_IP_); 304030f712c9SDave Chinner 304130f712c9SDave Chinner xfs_iext_remove(bma->ip, bma->idx + 1, 1, state); 304230f712c9SDave Chinner 304330f712c9SDave Chinner XFS_IFORK_NEXT_SET(bma->ip, whichfork, 304430f712c9SDave Chinner XFS_IFORK_NEXTENTS(bma->ip, whichfork) - 1); 304530f712c9SDave Chinner if (bma->cur == NULL) { 304630f712c9SDave Chinner rval = XFS_ILOG_CORE | xfs_ilog_fext(whichfork); 304730f712c9SDave Chinner } else { 304830f712c9SDave Chinner rval = XFS_ILOG_CORE; 304930f712c9SDave Chinner error = xfs_bmbt_lookup_eq(bma->cur, right.br_startoff, 305030f712c9SDave Chinner right.br_startblock, right.br_blockcount, 305130f712c9SDave Chinner &i); 305230f712c9SDave Chinner if (error) 305330f712c9SDave Chinner goto done; 3054c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 305530f712c9SDave Chinner error = xfs_btree_delete(bma->cur, &i); 305630f712c9SDave Chinner if (error) 305730f712c9SDave Chinner goto done; 3058c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 305930f712c9SDave Chinner error = xfs_btree_decrement(bma->cur, 0, &i); 306030f712c9SDave Chinner if (error) 306130f712c9SDave Chinner goto done; 3062c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 306330f712c9SDave Chinner error = xfs_bmbt_update(bma->cur, left.br_startoff, 306430f712c9SDave Chinner left.br_startblock, 306530f712c9SDave Chinner left.br_blockcount + 306630f712c9SDave Chinner new->br_blockcount + 306730f712c9SDave Chinner right.br_blockcount, 306830f712c9SDave Chinner left.br_state); 306930f712c9SDave Chinner if (error) 307030f712c9SDave Chinner goto done; 307130f712c9SDave Chinner } 307230f712c9SDave Chinner break; 307330f712c9SDave Chinner 307430f712c9SDave Chinner case BMAP_LEFT_CONTIG: 307530f712c9SDave Chinner /* 307630f712c9SDave Chinner * New allocation is contiguous with a real allocation 307730f712c9SDave Chinner * on the left. 307830f712c9SDave Chinner * Merge the new allocation with the left neighbor. 307930f712c9SDave Chinner */ 308030f712c9SDave Chinner --bma->idx; 308130f712c9SDave Chinner trace_xfs_bmap_pre_update(bma->ip, bma->idx, state, _THIS_IP_); 308230f712c9SDave Chinner xfs_bmbt_set_blockcount(xfs_iext_get_ext(ifp, bma->idx), 308330f712c9SDave Chinner left.br_blockcount + new->br_blockcount); 308430f712c9SDave Chinner trace_xfs_bmap_post_update(bma->ip, bma->idx, state, _THIS_IP_); 308530f712c9SDave Chinner 308630f712c9SDave Chinner if (bma->cur == NULL) { 308730f712c9SDave Chinner rval = xfs_ilog_fext(whichfork); 308830f712c9SDave Chinner } else { 308930f712c9SDave Chinner rval = 0; 309030f712c9SDave Chinner error = xfs_bmbt_lookup_eq(bma->cur, left.br_startoff, 309130f712c9SDave Chinner left.br_startblock, left.br_blockcount, 309230f712c9SDave Chinner &i); 309330f712c9SDave Chinner if (error) 309430f712c9SDave Chinner goto done; 3095c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 309630f712c9SDave Chinner error = xfs_bmbt_update(bma->cur, left.br_startoff, 309730f712c9SDave Chinner left.br_startblock, 309830f712c9SDave Chinner left.br_blockcount + 309930f712c9SDave Chinner new->br_blockcount, 310030f712c9SDave Chinner left.br_state); 310130f712c9SDave Chinner if (error) 310230f712c9SDave Chinner goto done; 310330f712c9SDave Chinner } 310430f712c9SDave Chinner break; 310530f712c9SDave Chinner 310630f712c9SDave Chinner case BMAP_RIGHT_CONTIG: 310730f712c9SDave Chinner /* 310830f712c9SDave Chinner * New allocation is contiguous with a real allocation 310930f712c9SDave Chinner * on the right. 311030f712c9SDave Chinner * Merge the new allocation with the right neighbor. 311130f712c9SDave Chinner */ 311230f712c9SDave Chinner trace_xfs_bmap_pre_update(bma->ip, bma->idx, state, _THIS_IP_); 311330f712c9SDave Chinner xfs_bmbt_set_allf(xfs_iext_get_ext(ifp, bma->idx), 311430f712c9SDave Chinner new->br_startoff, new->br_startblock, 311530f712c9SDave Chinner new->br_blockcount + right.br_blockcount, 311630f712c9SDave Chinner right.br_state); 311730f712c9SDave Chinner trace_xfs_bmap_post_update(bma->ip, bma->idx, state, _THIS_IP_); 311830f712c9SDave Chinner 311930f712c9SDave Chinner if (bma->cur == NULL) { 312030f712c9SDave Chinner rval = xfs_ilog_fext(whichfork); 312130f712c9SDave Chinner } else { 312230f712c9SDave Chinner rval = 0; 312330f712c9SDave Chinner error = xfs_bmbt_lookup_eq(bma->cur, 312430f712c9SDave Chinner right.br_startoff, 312530f712c9SDave Chinner right.br_startblock, 312630f712c9SDave Chinner right.br_blockcount, &i); 312730f712c9SDave Chinner if (error) 312830f712c9SDave Chinner goto done; 3129c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 313030f712c9SDave Chinner error = xfs_bmbt_update(bma->cur, new->br_startoff, 313130f712c9SDave Chinner new->br_startblock, 313230f712c9SDave Chinner new->br_blockcount + 313330f712c9SDave Chinner right.br_blockcount, 313430f712c9SDave Chinner right.br_state); 313530f712c9SDave Chinner if (error) 313630f712c9SDave Chinner goto done; 313730f712c9SDave Chinner } 313830f712c9SDave Chinner break; 313930f712c9SDave Chinner 314030f712c9SDave Chinner case 0: 314130f712c9SDave Chinner /* 314230f712c9SDave Chinner * New allocation is not contiguous with another 314330f712c9SDave Chinner * real allocation. 314430f712c9SDave Chinner * Insert a new entry. 314530f712c9SDave Chinner */ 314630f712c9SDave Chinner xfs_iext_insert(bma->ip, bma->idx, 1, new, state); 314730f712c9SDave Chinner XFS_IFORK_NEXT_SET(bma->ip, whichfork, 314830f712c9SDave Chinner XFS_IFORK_NEXTENTS(bma->ip, whichfork) + 1); 314930f712c9SDave Chinner if (bma->cur == NULL) { 315030f712c9SDave Chinner rval = XFS_ILOG_CORE | xfs_ilog_fext(whichfork); 315130f712c9SDave Chinner } else { 315230f712c9SDave Chinner rval = XFS_ILOG_CORE; 315330f712c9SDave Chinner error = xfs_bmbt_lookup_eq(bma->cur, 315430f712c9SDave Chinner new->br_startoff, 315530f712c9SDave Chinner new->br_startblock, 315630f712c9SDave Chinner new->br_blockcount, &i); 315730f712c9SDave Chinner if (error) 315830f712c9SDave Chinner goto done; 3159c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 0, done); 316030f712c9SDave Chinner bma->cur->bc_rec.b.br_state = new->br_state; 316130f712c9SDave Chinner error = xfs_btree_insert(bma->cur, &i); 316230f712c9SDave Chinner if (error) 316330f712c9SDave Chinner goto done; 3164c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 316530f712c9SDave Chinner } 316630f712c9SDave Chinner break; 316730f712c9SDave Chinner } 316830f712c9SDave Chinner 31699c194644SDarrick J. Wong /* add reverse mapping */ 31709c194644SDarrick J. Wong error = xfs_rmap_map_extent(mp, bma->dfops, bma->ip, whichfork, new); 31719c194644SDarrick J. Wong if (error) 31729c194644SDarrick J. Wong goto done; 31739c194644SDarrick J. Wong 317430f712c9SDave Chinner /* convert to a btree if necessary */ 317530f712c9SDave Chinner if (xfs_bmap_needs_btree(bma->ip, whichfork)) { 317630f712c9SDave Chinner int tmp_logflags; /* partial log flag return val */ 317730f712c9SDave Chinner 317830f712c9SDave Chinner ASSERT(bma->cur == NULL); 317930f712c9SDave Chinner error = xfs_bmap_extents_to_btree(bma->tp, bma->ip, 31802c3234d1SDarrick J. Wong bma->firstblock, bma->dfops, &bma->cur, 318130f712c9SDave Chinner 0, &tmp_logflags, whichfork); 318230f712c9SDave Chinner bma->logflags |= tmp_logflags; 318330f712c9SDave Chinner if (error) 318430f712c9SDave Chinner goto done; 318530f712c9SDave Chinner } 318630f712c9SDave Chinner 318730f712c9SDave Chinner /* clear out the allocated field, done with it now in any case. */ 318830f712c9SDave Chinner if (bma->cur) 318930f712c9SDave Chinner bma->cur->bc_private.b.allocated = 0; 319030f712c9SDave Chinner 319130f712c9SDave Chinner xfs_bmap_check_leaf_extents(bma->cur, bma->ip, whichfork); 319230f712c9SDave Chinner done: 319330f712c9SDave Chinner bma->logflags |= rval; 319430f712c9SDave Chinner return error; 319530f712c9SDave Chinner } 319630f712c9SDave Chinner 319730f712c9SDave Chinner /* 319830f712c9SDave Chinner * Functions used in the extent read, allocate and remove paths 319930f712c9SDave Chinner */ 320030f712c9SDave Chinner 320130f712c9SDave Chinner /* 320230f712c9SDave Chinner * Adjust the size of the new extent based on di_extsize and rt extsize. 320330f712c9SDave Chinner */ 320430f712c9SDave Chinner int 320530f712c9SDave Chinner xfs_bmap_extsize_align( 320630f712c9SDave Chinner xfs_mount_t *mp, 320730f712c9SDave Chinner xfs_bmbt_irec_t *gotp, /* next extent pointer */ 320830f712c9SDave Chinner xfs_bmbt_irec_t *prevp, /* previous extent pointer */ 320930f712c9SDave Chinner xfs_extlen_t extsz, /* align to this extent size */ 321030f712c9SDave Chinner int rt, /* is this a realtime inode? */ 321130f712c9SDave Chinner int eof, /* is extent at end-of-file? */ 321230f712c9SDave Chinner int delay, /* creating delalloc extent? */ 321330f712c9SDave Chinner int convert, /* overwriting unwritten extent? */ 321430f712c9SDave Chinner xfs_fileoff_t *offp, /* in/out: aligned offset */ 321530f712c9SDave Chinner xfs_extlen_t *lenp) /* in/out: aligned length */ 321630f712c9SDave Chinner { 321730f712c9SDave Chinner xfs_fileoff_t orig_off; /* original offset */ 321830f712c9SDave Chinner xfs_extlen_t orig_alen; /* original length */ 321930f712c9SDave Chinner xfs_fileoff_t orig_end; /* original off+len */ 322030f712c9SDave Chinner xfs_fileoff_t nexto; /* next file offset */ 322130f712c9SDave Chinner xfs_fileoff_t prevo; /* previous file offset */ 322230f712c9SDave Chinner xfs_fileoff_t align_off; /* temp for offset */ 322330f712c9SDave Chinner xfs_extlen_t align_alen; /* temp for length */ 322430f712c9SDave Chinner xfs_extlen_t temp; /* temp for calculations */ 322530f712c9SDave Chinner 322630f712c9SDave Chinner if (convert) 322730f712c9SDave Chinner return 0; 322830f712c9SDave Chinner 322930f712c9SDave Chinner orig_off = align_off = *offp; 323030f712c9SDave Chinner orig_alen = align_alen = *lenp; 323130f712c9SDave Chinner orig_end = orig_off + orig_alen; 323230f712c9SDave Chinner 323330f712c9SDave Chinner /* 323430f712c9SDave Chinner * If this request overlaps an existing extent, then don't 323530f712c9SDave Chinner * attempt to perform any additional alignment. 323630f712c9SDave Chinner */ 323730f712c9SDave Chinner if (!delay && !eof && 323830f712c9SDave Chinner (orig_off >= gotp->br_startoff) && 323930f712c9SDave Chinner (orig_end <= gotp->br_startoff + gotp->br_blockcount)) { 324030f712c9SDave Chinner return 0; 324130f712c9SDave Chinner } 324230f712c9SDave Chinner 324330f712c9SDave Chinner /* 324430f712c9SDave Chinner * If the file offset is unaligned vs. the extent size 324530f712c9SDave Chinner * we need to align it. This will be possible unless 324630f712c9SDave Chinner * the file was previously written with a kernel that didn't 324730f712c9SDave Chinner * perform this alignment, or if a truncate shot us in the 324830f712c9SDave Chinner * foot. 324930f712c9SDave Chinner */ 325030f712c9SDave Chinner temp = do_mod(orig_off, extsz); 325130f712c9SDave Chinner if (temp) { 325230f712c9SDave Chinner align_alen += temp; 325330f712c9SDave Chinner align_off -= temp; 325430f712c9SDave Chinner } 32556dea405eSDave Chinner 32566dea405eSDave Chinner /* Same adjustment for the end of the requested area. */ 32576dea405eSDave Chinner temp = (align_alen % extsz); 32586dea405eSDave Chinner if (temp) 325930f712c9SDave Chinner align_alen += extsz - temp; 32606dea405eSDave Chinner 32616dea405eSDave Chinner /* 32626dea405eSDave Chinner * For large extent hint sizes, the aligned extent might be larger than 32636dea405eSDave Chinner * MAXEXTLEN. In that case, reduce the size by an extsz so that it pulls 32646dea405eSDave Chinner * the length back under MAXEXTLEN. The outer allocation loops handle 32656dea405eSDave Chinner * short allocation just fine, so it is safe to do this. We only want to 32666dea405eSDave Chinner * do it when we are forced to, though, because it means more allocation 32676dea405eSDave Chinner * operations are required. 32686dea405eSDave Chinner */ 32696dea405eSDave Chinner while (align_alen > MAXEXTLEN) 32706dea405eSDave Chinner align_alen -= extsz; 32716dea405eSDave Chinner ASSERT(align_alen <= MAXEXTLEN); 32726dea405eSDave Chinner 327330f712c9SDave Chinner /* 327430f712c9SDave Chinner * If the previous block overlaps with this proposed allocation 327530f712c9SDave Chinner * then move the start forward without adjusting the length. 327630f712c9SDave Chinner */ 327730f712c9SDave Chinner if (prevp->br_startoff != NULLFILEOFF) { 327830f712c9SDave Chinner if (prevp->br_startblock == HOLESTARTBLOCK) 327930f712c9SDave Chinner prevo = prevp->br_startoff; 328030f712c9SDave Chinner else 328130f712c9SDave Chinner prevo = prevp->br_startoff + prevp->br_blockcount; 328230f712c9SDave Chinner } else 328330f712c9SDave Chinner prevo = 0; 328430f712c9SDave Chinner if (align_off != orig_off && align_off < prevo) 328530f712c9SDave Chinner align_off = prevo; 328630f712c9SDave Chinner /* 328730f712c9SDave Chinner * If the next block overlaps with this proposed allocation 328830f712c9SDave Chinner * then move the start back without adjusting the length, 328930f712c9SDave Chinner * but not before offset 0. 329030f712c9SDave Chinner * This may of course make the start overlap previous block, 329130f712c9SDave Chinner * and if we hit the offset 0 limit then the next block 329230f712c9SDave Chinner * can still overlap too. 329330f712c9SDave Chinner */ 329430f712c9SDave Chinner if (!eof && gotp->br_startoff != NULLFILEOFF) { 329530f712c9SDave Chinner if ((delay && gotp->br_startblock == HOLESTARTBLOCK) || 329630f712c9SDave Chinner (!delay && gotp->br_startblock == DELAYSTARTBLOCK)) 329730f712c9SDave Chinner nexto = gotp->br_startoff + gotp->br_blockcount; 329830f712c9SDave Chinner else 329930f712c9SDave Chinner nexto = gotp->br_startoff; 330030f712c9SDave Chinner } else 330130f712c9SDave Chinner nexto = NULLFILEOFF; 330230f712c9SDave Chinner if (!eof && 330330f712c9SDave Chinner align_off + align_alen != orig_end && 330430f712c9SDave Chinner align_off + align_alen > nexto) 330530f712c9SDave Chinner align_off = nexto > align_alen ? nexto - align_alen : 0; 330630f712c9SDave Chinner /* 330730f712c9SDave Chinner * If we're now overlapping the next or previous extent that 330830f712c9SDave Chinner * means we can't fit an extsz piece in this hole. Just move 330930f712c9SDave Chinner * the start forward to the first valid spot and set 331030f712c9SDave Chinner * the length so we hit the end. 331130f712c9SDave Chinner */ 331230f712c9SDave Chinner if (align_off != orig_off && align_off < prevo) 331330f712c9SDave Chinner align_off = prevo; 331430f712c9SDave Chinner if (align_off + align_alen != orig_end && 331530f712c9SDave Chinner align_off + align_alen > nexto && 331630f712c9SDave Chinner nexto != NULLFILEOFF) { 331730f712c9SDave Chinner ASSERT(nexto > prevo); 331830f712c9SDave Chinner align_alen = nexto - align_off; 331930f712c9SDave Chinner } 332030f712c9SDave Chinner 332130f712c9SDave Chinner /* 332230f712c9SDave Chinner * If realtime, and the result isn't a multiple of the realtime 332330f712c9SDave Chinner * extent size we need to remove blocks until it is. 332430f712c9SDave Chinner */ 332530f712c9SDave Chinner if (rt && (temp = (align_alen % mp->m_sb.sb_rextsize))) { 332630f712c9SDave Chinner /* 332730f712c9SDave Chinner * We're not covering the original request, or 332830f712c9SDave Chinner * we won't be able to once we fix the length. 332930f712c9SDave Chinner */ 333030f712c9SDave Chinner if (orig_off < align_off || 333130f712c9SDave Chinner orig_end > align_off + align_alen || 333230f712c9SDave Chinner align_alen - temp < orig_alen) 33332451337dSDave Chinner return -EINVAL; 333430f712c9SDave Chinner /* 333530f712c9SDave Chinner * Try to fix it by moving the start up. 333630f712c9SDave Chinner */ 333730f712c9SDave Chinner if (align_off + temp <= orig_off) { 333830f712c9SDave Chinner align_alen -= temp; 333930f712c9SDave Chinner align_off += temp; 334030f712c9SDave Chinner } 334130f712c9SDave Chinner /* 334230f712c9SDave Chinner * Try to fix it by moving the end in. 334330f712c9SDave Chinner */ 334430f712c9SDave Chinner else if (align_off + align_alen - temp >= orig_end) 334530f712c9SDave Chinner align_alen -= temp; 334630f712c9SDave Chinner /* 334730f712c9SDave Chinner * Set the start to the minimum then trim the length. 334830f712c9SDave Chinner */ 334930f712c9SDave Chinner else { 335030f712c9SDave Chinner align_alen -= orig_off - align_off; 335130f712c9SDave Chinner align_off = orig_off; 335230f712c9SDave Chinner align_alen -= align_alen % mp->m_sb.sb_rextsize; 335330f712c9SDave Chinner } 335430f712c9SDave Chinner /* 335530f712c9SDave Chinner * Result doesn't cover the request, fail it. 335630f712c9SDave Chinner */ 335730f712c9SDave Chinner if (orig_off < align_off || orig_end > align_off + align_alen) 33582451337dSDave Chinner return -EINVAL; 335930f712c9SDave Chinner } else { 336030f712c9SDave Chinner ASSERT(orig_off >= align_off); 33616dea405eSDave Chinner /* see MAXEXTLEN handling above */ 33626dea405eSDave Chinner ASSERT(orig_end <= align_off + align_alen || 33636dea405eSDave Chinner align_alen + extsz > MAXEXTLEN); 336430f712c9SDave Chinner } 336530f712c9SDave Chinner 336630f712c9SDave Chinner #ifdef DEBUG 336730f712c9SDave Chinner if (!eof && gotp->br_startoff != NULLFILEOFF) 336830f712c9SDave Chinner ASSERT(align_off + align_alen <= gotp->br_startoff); 336930f712c9SDave Chinner if (prevp->br_startoff != NULLFILEOFF) 337030f712c9SDave Chinner ASSERT(align_off >= prevp->br_startoff + prevp->br_blockcount); 337130f712c9SDave Chinner #endif 337230f712c9SDave Chinner 337330f712c9SDave Chinner *lenp = align_alen; 337430f712c9SDave Chinner *offp = align_off; 337530f712c9SDave Chinner return 0; 337630f712c9SDave Chinner } 337730f712c9SDave Chinner 337830f712c9SDave Chinner #define XFS_ALLOC_GAP_UNITS 4 337930f712c9SDave Chinner 338030f712c9SDave Chinner void 338130f712c9SDave Chinner xfs_bmap_adjacent( 338230f712c9SDave Chinner struct xfs_bmalloca *ap) /* bmap alloc argument struct */ 338330f712c9SDave Chinner { 338430f712c9SDave Chinner xfs_fsblock_t adjust; /* adjustment to block numbers */ 338530f712c9SDave Chinner xfs_agnumber_t fb_agno; /* ag number of ap->firstblock */ 338630f712c9SDave Chinner xfs_mount_t *mp; /* mount point structure */ 338730f712c9SDave Chinner int nullfb; /* true if ap->firstblock isn't set */ 338830f712c9SDave Chinner int rt; /* true if inode is realtime */ 338930f712c9SDave Chinner 339030f712c9SDave Chinner #define ISVALID(x,y) \ 339130f712c9SDave Chinner (rt ? \ 339230f712c9SDave Chinner (x) < mp->m_sb.sb_rblocks : \ 339330f712c9SDave Chinner XFS_FSB_TO_AGNO(mp, x) == XFS_FSB_TO_AGNO(mp, y) && \ 339430f712c9SDave Chinner XFS_FSB_TO_AGNO(mp, x) < mp->m_sb.sb_agcount && \ 339530f712c9SDave Chinner XFS_FSB_TO_AGBNO(mp, x) < mp->m_sb.sb_agblocks) 339630f712c9SDave Chinner 339730f712c9SDave Chinner mp = ap->ip->i_mount; 339830f712c9SDave Chinner nullfb = *ap->firstblock == NULLFSBLOCK; 3399292378edSDave Chinner rt = XFS_IS_REALTIME_INODE(ap->ip) && 3400292378edSDave Chinner xfs_alloc_is_userdata(ap->datatype); 340130f712c9SDave Chinner fb_agno = nullfb ? NULLAGNUMBER : XFS_FSB_TO_AGNO(mp, *ap->firstblock); 340230f712c9SDave Chinner /* 340330f712c9SDave Chinner * If allocating at eof, and there's a previous real block, 340430f712c9SDave Chinner * try to use its last block as our starting point. 340530f712c9SDave Chinner */ 340630f712c9SDave Chinner if (ap->eof && ap->prev.br_startoff != NULLFILEOFF && 340730f712c9SDave Chinner !isnullstartblock(ap->prev.br_startblock) && 340830f712c9SDave Chinner ISVALID(ap->prev.br_startblock + ap->prev.br_blockcount, 340930f712c9SDave Chinner ap->prev.br_startblock)) { 341030f712c9SDave Chinner ap->blkno = ap->prev.br_startblock + ap->prev.br_blockcount; 341130f712c9SDave Chinner /* 341230f712c9SDave Chinner * Adjust for the gap between prevp and us. 341330f712c9SDave Chinner */ 341430f712c9SDave Chinner adjust = ap->offset - 341530f712c9SDave Chinner (ap->prev.br_startoff + ap->prev.br_blockcount); 341630f712c9SDave Chinner if (adjust && 341730f712c9SDave Chinner ISVALID(ap->blkno + adjust, ap->prev.br_startblock)) 341830f712c9SDave Chinner ap->blkno += adjust; 341930f712c9SDave Chinner } 342030f712c9SDave Chinner /* 342130f712c9SDave Chinner * If not at eof, then compare the two neighbor blocks. 342230f712c9SDave Chinner * Figure out whether either one gives us a good starting point, 342330f712c9SDave Chinner * and pick the better one. 342430f712c9SDave Chinner */ 342530f712c9SDave Chinner else if (!ap->eof) { 342630f712c9SDave Chinner xfs_fsblock_t gotbno; /* right side block number */ 342730f712c9SDave Chinner xfs_fsblock_t gotdiff=0; /* right side difference */ 342830f712c9SDave Chinner xfs_fsblock_t prevbno; /* left side block number */ 342930f712c9SDave Chinner xfs_fsblock_t prevdiff=0; /* left side difference */ 343030f712c9SDave Chinner 343130f712c9SDave Chinner /* 343230f712c9SDave Chinner * If there's a previous (left) block, select a requested 343330f712c9SDave Chinner * start block based on it. 343430f712c9SDave Chinner */ 343530f712c9SDave Chinner if (ap->prev.br_startoff != NULLFILEOFF && 343630f712c9SDave Chinner !isnullstartblock(ap->prev.br_startblock) && 343730f712c9SDave Chinner (prevbno = ap->prev.br_startblock + 343830f712c9SDave Chinner ap->prev.br_blockcount) && 343930f712c9SDave Chinner ISVALID(prevbno, ap->prev.br_startblock)) { 344030f712c9SDave Chinner /* 344130f712c9SDave Chinner * Calculate gap to end of previous block. 344230f712c9SDave Chinner */ 344330f712c9SDave Chinner adjust = prevdiff = ap->offset - 344430f712c9SDave Chinner (ap->prev.br_startoff + 344530f712c9SDave Chinner ap->prev.br_blockcount); 344630f712c9SDave Chinner /* 344730f712c9SDave Chinner * Figure the startblock based on the previous block's 344830f712c9SDave Chinner * end and the gap size. 344930f712c9SDave Chinner * Heuristic! 345030f712c9SDave Chinner * If the gap is large relative to the piece we're 345130f712c9SDave Chinner * allocating, or using it gives us an invalid block 345230f712c9SDave Chinner * number, then just use the end of the previous block. 345330f712c9SDave Chinner */ 345430f712c9SDave Chinner if (prevdiff <= XFS_ALLOC_GAP_UNITS * ap->length && 345530f712c9SDave Chinner ISVALID(prevbno + prevdiff, 345630f712c9SDave Chinner ap->prev.br_startblock)) 345730f712c9SDave Chinner prevbno += adjust; 345830f712c9SDave Chinner else 345930f712c9SDave Chinner prevdiff += adjust; 346030f712c9SDave Chinner /* 346130f712c9SDave Chinner * If the firstblock forbids it, can't use it, 346230f712c9SDave Chinner * must use default. 346330f712c9SDave Chinner */ 346430f712c9SDave Chinner if (!rt && !nullfb && 346530f712c9SDave Chinner XFS_FSB_TO_AGNO(mp, prevbno) != fb_agno) 346630f712c9SDave Chinner prevbno = NULLFSBLOCK; 346730f712c9SDave Chinner } 346830f712c9SDave Chinner /* 346930f712c9SDave Chinner * No previous block or can't follow it, just default. 347030f712c9SDave Chinner */ 347130f712c9SDave Chinner else 347230f712c9SDave Chinner prevbno = NULLFSBLOCK; 347330f712c9SDave Chinner /* 347430f712c9SDave Chinner * If there's a following (right) block, select a requested 347530f712c9SDave Chinner * start block based on it. 347630f712c9SDave Chinner */ 347730f712c9SDave Chinner if (!isnullstartblock(ap->got.br_startblock)) { 347830f712c9SDave Chinner /* 347930f712c9SDave Chinner * Calculate gap to start of next block. 348030f712c9SDave Chinner */ 348130f712c9SDave Chinner adjust = gotdiff = ap->got.br_startoff - ap->offset; 348230f712c9SDave Chinner /* 348330f712c9SDave Chinner * Figure the startblock based on the next block's 348430f712c9SDave Chinner * start and the gap size. 348530f712c9SDave Chinner */ 348630f712c9SDave Chinner gotbno = ap->got.br_startblock; 348730f712c9SDave Chinner /* 348830f712c9SDave Chinner * Heuristic! 348930f712c9SDave Chinner * If the gap is large relative to the piece we're 349030f712c9SDave Chinner * allocating, or using it gives us an invalid block 349130f712c9SDave Chinner * number, then just use the start of the next block 349230f712c9SDave Chinner * offset by our length. 349330f712c9SDave Chinner */ 349430f712c9SDave Chinner if (gotdiff <= XFS_ALLOC_GAP_UNITS * ap->length && 349530f712c9SDave Chinner ISVALID(gotbno - gotdiff, gotbno)) 349630f712c9SDave Chinner gotbno -= adjust; 349730f712c9SDave Chinner else if (ISVALID(gotbno - ap->length, gotbno)) { 349830f712c9SDave Chinner gotbno -= ap->length; 349930f712c9SDave Chinner gotdiff += adjust - ap->length; 350030f712c9SDave Chinner } else 350130f712c9SDave Chinner gotdiff += adjust; 350230f712c9SDave Chinner /* 350330f712c9SDave Chinner * If the firstblock forbids it, can't use it, 350430f712c9SDave Chinner * must use default. 350530f712c9SDave Chinner */ 350630f712c9SDave Chinner if (!rt && !nullfb && 350730f712c9SDave Chinner XFS_FSB_TO_AGNO(mp, gotbno) != fb_agno) 350830f712c9SDave Chinner gotbno = NULLFSBLOCK; 350930f712c9SDave Chinner } 351030f712c9SDave Chinner /* 351130f712c9SDave Chinner * No next block, just default. 351230f712c9SDave Chinner */ 351330f712c9SDave Chinner else 351430f712c9SDave Chinner gotbno = NULLFSBLOCK; 351530f712c9SDave Chinner /* 351630f712c9SDave Chinner * If both valid, pick the better one, else the only good 351730f712c9SDave Chinner * one, else ap->blkno is already set (to 0 or the inode block). 351830f712c9SDave Chinner */ 351930f712c9SDave Chinner if (prevbno != NULLFSBLOCK && gotbno != NULLFSBLOCK) 352030f712c9SDave Chinner ap->blkno = prevdiff <= gotdiff ? prevbno : gotbno; 352130f712c9SDave Chinner else if (prevbno != NULLFSBLOCK) 352230f712c9SDave Chinner ap->blkno = prevbno; 352330f712c9SDave Chinner else if (gotbno != NULLFSBLOCK) 352430f712c9SDave Chinner ap->blkno = gotbno; 352530f712c9SDave Chinner } 352630f712c9SDave Chinner #undef ISVALID 352730f712c9SDave Chinner } 352830f712c9SDave Chinner 352930f712c9SDave Chinner static int 353030f712c9SDave Chinner xfs_bmap_longest_free_extent( 353130f712c9SDave Chinner struct xfs_trans *tp, 353230f712c9SDave Chinner xfs_agnumber_t ag, 353330f712c9SDave Chinner xfs_extlen_t *blen, 353430f712c9SDave Chinner int *notinit) 353530f712c9SDave Chinner { 353630f712c9SDave Chinner struct xfs_mount *mp = tp->t_mountp; 353730f712c9SDave Chinner struct xfs_perag *pag; 353830f712c9SDave Chinner xfs_extlen_t longest; 353930f712c9SDave Chinner int error = 0; 354030f712c9SDave Chinner 354130f712c9SDave Chinner pag = xfs_perag_get(mp, ag); 354230f712c9SDave Chinner if (!pag->pagf_init) { 354330f712c9SDave Chinner error = xfs_alloc_pagf_init(mp, tp, ag, XFS_ALLOC_FLAG_TRYLOCK); 354430f712c9SDave Chinner if (error) 354530f712c9SDave Chinner goto out; 354630f712c9SDave Chinner 354730f712c9SDave Chinner if (!pag->pagf_init) { 354830f712c9SDave Chinner *notinit = 1; 354930f712c9SDave Chinner goto out; 355030f712c9SDave Chinner } 355130f712c9SDave Chinner } 355230f712c9SDave Chinner 355350adbcb4SDave Chinner longest = xfs_alloc_longest_free_extent(mp, pag, 35543fd129b6SDarrick J. Wong xfs_alloc_min_freelist(mp, pag), 35553fd129b6SDarrick J. Wong xfs_ag_resv_needed(pag, XFS_AG_RESV_NONE)); 355630f712c9SDave Chinner if (*blen < longest) 355730f712c9SDave Chinner *blen = longest; 355830f712c9SDave Chinner 355930f712c9SDave Chinner out: 356030f712c9SDave Chinner xfs_perag_put(pag); 356130f712c9SDave Chinner return error; 356230f712c9SDave Chinner } 356330f712c9SDave Chinner 356430f712c9SDave Chinner static void 356530f712c9SDave Chinner xfs_bmap_select_minlen( 356630f712c9SDave Chinner struct xfs_bmalloca *ap, 356730f712c9SDave Chinner struct xfs_alloc_arg *args, 356830f712c9SDave Chinner xfs_extlen_t *blen, 356930f712c9SDave Chinner int notinit) 357030f712c9SDave Chinner { 357130f712c9SDave Chinner if (notinit || *blen < ap->minlen) { 357230f712c9SDave Chinner /* 357330f712c9SDave Chinner * Since we did a BUF_TRYLOCK above, it is possible that 357430f712c9SDave Chinner * there is space for this request. 357530f712c9SDave Chinner */ 357630f712c9SDave Chinner args->minlen = ap->minlen; 357730f712c9SDave Chinner } else if (*blen < args->maxlen) { 357830f712c9SDave Chinner /* 357930f712c9SDave Chinner * If the best seen length is less than the request length, 358030f712c9SDave Chinner * use the best as the minimum. 358130f712c9SDave Chinner */ 358230f712c9SDave Chinner args->minlen = *blen; 358330f712c9SDave Chinner } else { 358430f712c9SDave Chinner /* 358530f712c9SDave Chinner * Otherwise we've seen an extent as big as maxlen, use that 358630f712c9SDave Chinner * as the minimum. 358730f712c9SDave Chinner */ 358830f712c9SDave Chinner args->minlen = args->maxlen; 358930f712c9SDave Chinner } 359030f712c9SDave Chinner } 359130f712c9SDave Chinner 359230f712c9SDave Chinner STATIC int 359330f712c9SDave Chinner xfs_bmap_btalloc_nullfb( 359430f712c9SDave Chinner struct xfs_bmalloca *ap, 359530f712c9SDave Chinner struct xfs_alloc_arg *args, 359630f712c9SDave Chinner xfs_extlen_t *blen) 359730f712c9SDave Chinner { 359830f712c9SDave Chinner struct xfs_mount *mp = ap->ip->i_mount; 359930f712c9SDave Chinner xfs_agnumber_t ag, startag; 360030f712c9SDave Chinner int notinit = 0; 360130f712c9SDave Chinner int error; 360230f712c9SDave Chinner 360330f712c9SDave Chinner args->type = XFS_ALLOCTYPE_START_BNO; 360430f712c9SDave Chinner args->total = ap->total; 360530f712c9SDave Chinner 360630f712c9SDave Chinner startag = ag = XFS_FSB_TO_AGNO(mp, args->fsbno); 360730f712c9SDave Chinner if (startag == NULLAGNUMBER) 360830f712c9SDave Chinner startag = ag = 0; 360930f712c9SDave Chinner 361030f712c9SDave Chinner while (*blen < args->maxlen) { 361130f712c9SDave Chinner error = xfs_bmap_longest_free_extent(args->tp, ag, blen, 361230f712c9SDave Chinner ¬init); 361330f712c9SDave Chinner if (error) 361430f712c9SDave Chinner return error; 361530f712c9SDave Chinner 361630f712c9SDave Chinner if (++ag == mp->m_sb.sb_agcount) 361730f712c9SDave Chinner ag = 0; 361830f712c9SDave Chinner if (ag == startag) 361930f712c9SDave Chinner break; 362030f712c9SDave Chinner } 362130f712c9SDave Chinner 362230f712c9SDave Chinner xfs_bmap_select_minlen(ap, args, blen, notinit); 362330f712c9SDave Chinner return 0; 362430f712c9SDave Chinner } 362530f712c9SDave Chinner 362630f712c9SDave Chinner STATIC int 362730f712c9SDave Chinner xfs_bmap_btalloc_filestreams( 362830f712c9SDave Chinner struct xfs_bmalloca *ap, 362930f712c9SDave Chinner struct xfs_alloc_arg *args, 363030f712c9SDave Chinner xfs_extlen_t *blen) 363130f712c9SDave Chinner { 363230f712c9SDave Chinner struct xfs_mount *mp = ap->ip->i_mount; 363330f712c9SDave Chinner xfs_agnumber_t ag; 363430f712c9SDave Chinner int notinit = 0; 363530f712c9SDave Chinner int error; 363630f712c9SDave Chinner 363730f712c9SDave Chinner args->type = XFS_ALLOCTYPE_NEAR_BNO; 363830f712c9SDave Chinner args->total = ap->total; 363930f712c9SDave Chinner 364030f712c9SDave Chinner ag = XFS_FSB_TO_AGNO(mp, args->fsbno); 364130f712c9SDave Chinner if (ag == NULLAGNUMBER) 364230f712c9SDave Chinner ag = 0; 364330f712c9SDave Chinner 364430f712c9SDave Chinner error = xfs_bmap_longest_free_extent(args->tp, ag, blen, ¬init); 364530f712c9SDave Chinner if (error) 364630f712c9SDave Chinner return error; 364730f712c9SDave Chinner 364830f712c9SDave Chinner if (*blen < args->maxlen) { 364930f712c9SDave Chinner error = xfs_filestream_new_ag(ap, &ag); 365030f712c9SDave Chinner if (error) 365130f712c9SDave Chinner return error; 365230f712c9SDave Chinner 365330f712c9SDave Chinner error = xfs_bmap_longest_free_extent(args->tp, ag, blen, 365430f712c9SDave Chinner ¬init); 365530f712c9SDave Chinner if (error) 365630f712c9SDave Chinner return error; 365730f712c9SDave Chinner 365830f712c9SDave Chinner } 365930f712c9SDave Chinner 366030f712c9SDave Chinner xfs_bmap_select_minlen(ap, args, blen, notinit); 366130f712c9SDave Chinner 366230f712c9SDave Chinner /* 366330f712c9SDave Chinner * Set the failure fallback case to look in the selected AG as stream 366430f712c9SDave Chinner * may have moved. 366530f712c9SDave Chinner */ 366630f712c9SDave Chinner ap->blkno = args->fsbno = XFS_AGB_TO_FSB(mp, ag, 0); 366730f712c9SDave Chinner return 0; 366830f712c9SDave Chinner } 366930f712c9SDave Chinner 367030f712c9SDave Chinner STATIC int 367130f712c9SDave Chinner xfs_bmap_btalloc( 367230f712c9SDave Chinner struct xfs_bmalloca *ap) /* bmap alloc argument struct */ 367330f712c9SDave Chinner { 367430f712c9SDave Chinner xfs_mount_t *mp; /* mount point structure */ 367530f712c9SDave Chinner xfs_alloctype_t atype = 0; /* type for allocation routines */ 3676292378edSDave Chinner xfs_extlen_t align = 0; /* minimum allocation alignment */ 367730f712c9SDave Chinner xfs_agnumber_t fb_agno; /* ag number of ap->firstblock */ 367830f712c9SDave Chinner xfs_agnumber_t ag; 367930f712c9SDave Chinner xfs_alloc_arg_t args; 368030f712c9SDave Chinner xfs_extlen_t blen; 368130f712c9SDave Chinner xfs_extlen_t nextminlen = 0; 368230f712c9SDave Chinner int nullfb; /* true if ap->firstblock isn't set */ 368330f712c9SDave Chinner int isaligned; 368430f712c9SDave Chinner int tryagain; 368530f712c9SDave Chinner int error; 368630f712c9SDave Chinner int stripe_align; 368730f712c9SDave Chinner 368830f712c9SDave Chinner ASSERT(ap->length); 368930f712c9SDave Chinner 369030f712c9SDave Chinner mp = ap->ip->i_mount; 369130f712c9SDave Chinner 369230f712c9SDave Chinner /* stripe alignment for allocation is determined by mount parameters */ 369330f712c9SDave Chinner stripe_align = 0; 369430f712c9SDave Chinner if (mp->m_swidth && (mp->m_flags & XFS_MOUNT_SWALLOC)) 369530f712c9SDave Chinner stripe_align = mp->m_swidth; 369630f712c9SDave Chinner else if (mp->m_dalign) 369730f712c9SDave Chinner stripe_align = mp->m_dalign; 369830f712c9SDave Chinner 3699f7ca3522SDarrick J. Wong if (ap->flags & XFS_BMAPI_COWFORK) 3700f7ca3522SDarrick J. Wong align = xfs_get_cowextsz_hint(ap->ip); 3701f7ca3522SDarrick J. Wong else if (xfs_alloc_is_userdata(ap->datatype)) 3702292378edSDave Chinner align = xfs_get_extsz_hint(ap->ip); 370330f712c9SDave Chinner if (unlikely(align)) { 370430f712c9SDave Chinner error = xfs_bmap_extsize_align(mp, &ap->got, &ap->prev, 370530f712c9SDave Chinner align, 0, ap->eof, 0, ap->conv, 370630f712c9SDave Chinner &ap->offset, &ap->length); 370730f712c9SDave Chinner ASSERT(!error); 370830f712c9SDave Chinner ASSERT(ap->length); 370930f712c9SDave Chinner } 371030f712c9SDave Chinner 371130f712c9SDave Chinner 371230f712c9SDave Chinner nullfb = *ap->firstblock == NULLFSBLOCK; 371330f712c9SDave Chinner fb_agno = nullfb ? NULLAGNUMBER : XFS_FSB_TO_AGNO(mp, *ap->firstblock); 371430f712c9SDave Chinner if (nullfb) { 3715292378edSDave Chinner if (xfs_alloc_is_userdata(ap->datatype) && 3716292378edSDave Chinner xfs_inode_is_filestream(ap->ip)) { 371730f712c9SDave Chinner ag = xfs_filestream_lookup_ag(ap->ip); 371830f712c9SDave Chinner ag = (ag != NULLAGNUMBER) ? ag : 0; 371930f712c9SDave Chinner ap->blkno = XFS_AGB_TO_FSB(mp, ag, 0); 372030f712c9SDave Chinner } else { 372130f712c9SDave Chinner ap->blkno = XFS_INO_TO_FSB(mp, ap->ip->i_ino); 372230f712c9SDave Chinner } 372330f712c9SDave Chinner } else 372430f712c9SDave Chinner ap->blkno = *ap->firstblock; 372530f712c9SDave Chinner 372630f712c9SDave Chinner xfs_bmap_adjacent(ap); 372730f712c9SDave Chinner 372830f712c9SDave Chinner /* 372930f712c9SDave Chinner * If allowed, use ap->blkno; otherwise must use firstblock since 373030f712c9SDave Chinner * it's in the right allocation group. 373130f712c9SDave Chinner */ 373230f712c9SDave Chinner if (nullfb || XFS_FSB_TO_AGNO(mp, ap->blkno) == fb_agno) 373330f712c9SDave Chinner ; 373430f712c9SDave Chinner else 373530f712c9SDave Chinner ap->blkno = *ap->firstblock; 373630f712c9SDave Chinner /* 373730f712c9SDave Chinner * Normal allocation, done through xfs_alloc_vextent. 373830f712c9SDave Chinner */ 373930f712c9SDave Chinner tryagain = isaligned = 0; 374030f712c9SDave Chinner memset(&args, 0, sizeof(args)); 374130f712c9SDave Chinner args.tp = ap->tp; 374230f712c9SDave Chinner args.mp = mp; 374330f712c9SDave Chinner args.fsbno = ap->blkno; 3744340785ccSDarrick J. Wong xfs_rmap_skip_owner_update(&args.oinfo); 374530f712c9SDave Chinner 374630f712c9SDave Chinner /* Trim the allocation back to the maximum an AG can fit. */ 374752548852SDarrick J. Wong args.maxlen = MIN(ap->length, mp->m_ag_max_usable); 374830f712c9SDave Chinner args.firstblock = *ap->firstblock; 374930f712c9SDave Chinner blen = 0; 375030f712c9SDave Chinner if (nullfb) { 375130f712c9SDave Chinner /* 375230f712c9SDave Chinner * Search for an allocation group with a single extent large 375330f712c9SDave Chinner * enough for the request. If one isn't found, then adjust 375430f712c9SDave Chinner * the minimum allocation size to the largest space found. 375530f712c9SDave Chinner */ 3756292378edSDave Chinner if (xfs_alloc_is_userdata(ap->datatype) && 3757292378edSDave Chinner xfs_inode_is_filestream(ap->ip)) 375830f712c9SDave Chinner error = xfs_bmap_btalloc_filestreams(ap, &args, &blen); 375930f712c9SDave Chinner else 376030f712c9SDave Chinner error = xfs_bmap_btalloc_nullfb(ap, &args, &blen); 376130f712c9SDave Chinner if (error) 376230f712c9SDave Chinner return error; 37632c3234d1SDarrick J. Wong } else if (ap->dfops->dop_low) { 376430f712c9SDave Chinner if (xfs_inode_is_filestream(ap->ip)) 376530f712c9SDave Chinner args.type = XFS_ALLOCTYPE_FIRST_AG; 376630f712c9SDave Chinner else 376730f712c9SDave Chinner args.type = XFS_ALLOCTYPE_START_BNO; 376830f712c9SDave Chinner args.total = args.minlen = ap->minlen; 376930f712c9SDave Chinner } else { 377030f712c9SDave Chinner args.type = XFS_ALLOCTYPE_NEAR_BNO; 377130f712c9SDave Chinner args.total = ap->total; 377230f712c9SDave Chinner args.minlen = ap->minlen; 377330f712c9SDave Chinner } 377430f712c9SDave Chinner /* apply extent size hints if obtained earlier */ 377530f712c9SDave Chinner if (unlikely(align)) { 377630f712c9SDave Chinner args.prod = align; 377730f712c9SDave Chinner if ((args.mod = (xfs_extlen_t)do_mod(ap->offset, args.prod))) 377830f712c9SDave Chinner args.mod = (xfs_extlen_t)(args.prod - args.mod); 377909cbfeafSKirill A. Shutemov } else if (mp->m_sb.sb_blocksize >= PAGE_SIZE) { 378030f712c9SDave Chinner args.prod = 1; 378130f712c9SDave Chinner args.mod = 0; 378230f712c9SDave Chinner } else { 378309cbfeafSKirill A. Shutemov args.prod = PAGE_SIZE >> mp->m_sb.sb_blocklog; 378430f712c9SDave Chinner if ((args.mod = (xfs_extlen_t)(do_mod(ap->offset, args.prod)))) 378530f712c9SDave Chinner args.mod = (xfs_extlen_t)(args.prod - args.mod); 378630f712c9SDave Chinner } 378730f712c9SDave Chinner /* 378830f712c9SDave Chinner * If we are not low on available data blocks, and the 378930f712c9SDave Chinner * underlying logical volume manager is a stripe, and 379030f712c9SDave Chinner * the file offset is zero then try to allocate data 379130f712c9SDave Chinner * blocks on stripe unit boundary. 379230f712c9SDave Chinner * NOTE: ap->aeof is only set if the allocation length 379330f712c9SDave Chinner * is >= the stripe unit and the allocation offset is 379430f712c9SDave Chinner * at the end of file. 379530f712c9SDave Chinner */ 37962c3234d1SDarrick J. Wong if (!ap->dfops->dop_low && ap->aeof) { 379730f712c9SDave Chinner if (!ap->offset) { 379830f712c9SDave Chinner args.alignment = stripe_align; 379930f712c9SDave Chinner atype = args.type; 380030f712c9SDave Chinner isaligned = 1; 380130f712c9SDave Chinner /* 380230f712c9SDave Chinner * Adjust for alignment 380330f712c9SDave Chinner */ 380430f712c9SDave Chinner if (blen > args.alignment && blen <= args.maxlen) 380530f712c9SDave Chinner args.minlen = blen - args.alignment; 380630f712c9SDave Chinner args.minalignslop = 0; 380730f712c9SDave Chinner } else { 380830f712c9SDave Chinner /* 380930f712c9SDave Chinner * First try an exact bno allocation. 381030f712c9SDave Chinner * If it fails then do a near or start bno 381130f712c9SDave Chinner * allocation with alignment turned on. 381230f712c9SDave Chinner */ 381330f712c9SDave Chinner atype = args.type; 381430f712c9SDave Chinner tryagain = 1; 381530f712c9SDave Chinner args.type = XFS_ALLOCTYPE_THIS_BNO; 381630f712c9SDave Chinner args.alignment = 1; 381730f712c9SDave Chinner /* 381830f712c9SDave Chinner * Compute the minlen+alignment for the 381930f712c9SDave Chinner * next case. Set slop so that the value 382030f712c9SDave Chinner * of minlen+alignment+slop doesn't go up 382130f712c9SDave Chinner * between the calls. 382230f712c9SDave Chinner */ 382330f712c9SDave Chinner if (blen > stripe_align && blen <= args.maxlen) 382430f712c9SDave Chinner nextminlen = blen - stripe_align; 382530f712c9SDave Chinner else 382630f712c9SDave Chinner nextminlen = args.minlen; 382730f712c9SDave Chinner if (nextminlen + stripe_align > args.minlen + 1) 382830f712c9SDave Chinner args.minalignslop = 382930f712c9SDave Chinner nextminlen + stripe_align - 383030f712c9SDave Chinner args.minlen - 1; 383130f712c9SDave Chinner else 383230f712c9SDave Chinner args.minalignslop = 0; 383330f712c9SDave Chinner } 383430f712c9SDave Chinner } else { 383530f712c9SDave Chinner args.alignment = 1; 383630f712c9SDave Chinner args.minalignslop = 0; 383730f712c9SDave Chinner } 383830f712c9SDave Chinner args.minleft = ap->minleft; 383930f712c9SDave Chinner args.wasdel = ap->wasdel; 38403fd129b6SDarrick J. Wong args.resv = XFS_AG_RESV_NONE; 3841292378edSDave Chinner args.datatype = ap->datatype; 3842292378edSDave Chinner if (ap->datatype & XFS_ALLOC_USERDATA_ZERO) 38433fbbbea3SDave Chinner args.ip = ap->ip; 38443fbbbea3SDave Chinner 38453fbbbea3SDave Chinner error = xfs_alloc_vextent(&args); 38463fbbbea3SDave Chinner if (error) 384730f712c9SDave Chinner return error; 38483fbbbea3SDave Chinner 384930f712c9SDave Chinner if (tryagain && args.fsbno == NULLFSBLOCK) { 385030f712c9SDave Chinner /* 385130f712c9SDave Chinner * Exact allocation failed. Now try with alignment 385230f712c9SDave Chinner * turned on. 385330f712c9SDave Chinner */ 385430f712c9SDave Chinner args.type = atype; 385530f712c9SDave Chinner args.fsbno = ap->blkno; 385630f712c9SDave Chinner args.alignment = stripe_align; 385730f712c9SDave Chinner args.minlen = nextminlen; 385830f712c9SDave Chinner args.minalignslop = 0; 385930f712c9SDave Chinner isaligned = 1; 386030f712c9SDave Chinner if ((error = xfs_alloc_vextent(&args))) 386130f712c9SDave Chinner return error; 386230f712c9SDave Chinner } 386330f712c9SDave Chinner if (isaligned && args.fsbno == NULLFSBLOCK) { 386430f712c9SDave Chinner /* 386530f712c9SDave Chinner * allocation failed, so turn off alignment and 386630f712c9SDave Chinner * try again. 386730f712c9SDave Chinner */ 386830f712c9SDave Chinner args.type = atype; 386930f712c9SDave Chinner args.fsbno = ap->blkno; 387030f712c9SDave Chinner args.alignment = 0; 387130f712c9SDave Chinner if ((error = xfs_alloc_vextent(&args))) 387230f712c9SDave Chinner return error; 387330f712c9SDave Chinner } 387430f712c9SDave Chinner if (args.fsbno == NULLFSBLOCK && nullfb && 387530f712c9SDave Chinner args.minlen > ap->minlen) { 387630f712c9SDave Chinner args.minlen = ap->minlen; 387730f712c9SDave Chinner args.type = XFS_ALLOCTYPE_START_BNO; 387830f712c9SDave Chinner args.fsbno = ap->blkno; 387930f712c9SDave Chinner if ((error = xfs_alloc_vextent(&args))) 388030f712c9SDave Chinner return error; 388130f712c9SDave Chinner } 388230f712c9SDave Chinner if (args.fsbno == NULLFSBLOCK && nullfb) { 388330f712c9SDave Chinner args.fsbno = 0; 388430f712c9SDave Chinner args.type = XFS_ALLOCTYPE_FIRST_AG; 388530f712c9SDave Chinner args.total = ap->minlen; 388630f712c9SDave Chinner args.minleft = 0; 388730f712c9SDave Chinner if ((error = xfs_alloc_vextent(&args))) 388830f712c9SDave Chinner return error; 38892c3234d1SDarrick J. Wong ap->dfops->dop_low = true; 389030f712c9SDave Chinner } 389130f712c9SDave Chinner if (args.fsbno != NULLFSBLOCK) { 389230f712c9SDave Chinner /* 389330f712c9SDave Chinner * check the allocation happened at the same or higher AG than 389430f712c9SDave Chinner * the first block that was allocated. 389530f712c9SDave Chinner */ 389630f712c9SDave Chinner ASSERT(*ap->firstblock == NULLFSBLOCK || 389730f712c9SDave Chinner XFS_FSB_TO_AGNO(mp, *ap->firstblock) == 389830f712c9SDave Chinner XFS_FSB_TO_AGNO(mp, args.fsbno) || 38992c3234d1SDarrick J. Wong (ap->dfops->dop_low && 390030f712c9SDave Chinner XFS_FSB_TO_AGNO(mp, *ap->firstblock) < 390130f712c9SDave Chinner XFS_FSB_TO_AGNO(mp, args.fsbno))); 390230f712c9SDave Chinner 390330f712c9SDave Chinner ap->blkno = args.fsbno; 390430f712c9SDave Chinner if (*ap->firstblock == NULLFSBLOCK) 390530f712c9SDave Chinner *ap->firstblock = args.fsbno; 390630f712c9SDave Chinner ASSERT(nullfb || fb_agno == args.agno || 39072c3234d1SDarrick J. Wong (ap->dfops->dop_low && fb_agno < args.agno)); 390830f712c9SDave Chinner ap->length = args.len; 390960b4984fSDarrick J. Wong if (!(ap->flags & XFS_BMAPI_COWFORK)) 391030f712c9SDave Chinner ap->ip->i_d.di_nblocks += args.len; 391130f712c9SDave Chinner xfs_trans_log_inode(ap->tp, ap->ip, XFS_ILOG_CORE); 391230f712c9SDave Chinner if (ap->wasdel) 391330f712c9SDave Chinner ap->ip->i_delayed_blks -= args.len; 391430f712c9SDave Chinner /* 391530f712c9SDave Chinner * Adjust the disk quota also. This was reserved 391630f712c9SDave Chinner * earlier. 391730f712c9SDave Chinner */ 391830f712c9SDave Chinner xfs_trans_mod_dquot_byino(ap->tp, ap->ip, 391930f712c9SDave Chinner ap->wasdel ? XFS_TRANS_DQ_DELBCOUNT : 392030f712c9SDave Chinner XFS_TRANS_DQ_BCOUNT, 392130f712c9SDave Chinner (long) args.len); 392230f712c9SDave Chinner } else { 392330f712c9SDave Chinner ap->blkno = NULLFSBLOCK; 392430f712c9SDave Chinner ap->length = 0; 392530f712c9SDave Chinner } 392630f712c9SDave Chinner return 0; 392730f712c9SDave Chinner } 392830f712c9SDave Chinner 392930f712c9SDave Chinner /* 3930f65306eaSDarrick J. Wong * For a remap operation, just "allocate" an extent at the address that the 3931f65306eaSDarrick J. Wong * caller passed in, and ensure that the AGFL is the right size. The caller 3932f65306eaSDarrick J. Wong * will then map the "allocated" extent into the file somewhere. 3933f65306eaSDarrick J. Wong */ 3934f65306eaSDarrick J. Wong STATIC int 3935f65306eaSDarrick J. Wong xfs_bmap_remap_alloc( 3936f65306eaSDarrick J. Wong struct xfs_bmalloca *ap) 3937f65306eaSDarrick J. Wong { 3938f65306eaSDarrick J. Wong struct xfs_trans *tp = ap->tp; 3939f65306eaSDarrick J. Wong struct xfs_mount *mp = tp->t_mountp; 3940f65306eaSDarrick J. Wong xfs_agblock_t bno; 3941f65306eaSDarrick J. Wong struct xfs_alloc_arg args; 3942f65306eaSDarrick J. Wong int error; 3943f65306eaSDarrick J. Wong 3944f65306eaSDarrick J. Wong /* 3945f65306eaSDarrick J. Wong * validate that the block number is legal - the enables us to detect 3946f65306eaSDarrick J. Wong * and handle a silent filesystem corruption rather than crashing. 3947f65306eaSDarrick J. Wong */ 3948f65306eaSDarrick J. Wong memset(&args, 0, sizeof(struct xfs_alloc_arg)); 3949f65306eaSDarrick J. Wong args.tp = ap->tp; 3950f65306eaSDarrick J. Wong args.mp = ap->tp->t_mountp; 3951f65306eaSDarrick J. Wong bno = *ap->firstblock; 3952f65306eaSDarrick J. Wong args.agno = XFS_FSB_TO_AGNO(mp, bno); 3953f65306eaSDarrick J. Wong args.agbno = XFS_FSB_TO_AGBNO(mp, bno); 3954f65306eaSDarrick J. Wong if (args.agno >= mp->m_sb.sb_agcount || 3955f65306eaSDarrick J. Wong args.agbno >= mp->m_sb.sb_agblocks) 3956f65306eaSDarrick J. Wong return -EFSCORRUPTED; 3957f65306eaSDarrick J. Wong 3958f65306eaSDarrick J. Wong /* "Allocate" the extent from the range we passed in. */ 3959f65306eaSDarrick J. Wong trace_xfs_bmap_remap_alloc(ap->ip, *ap->firstblock, ap->length); 3960f65306eaSDarrick J. Wong ap->blkno = bno; 3961f65306eaSDarrick J. Wong ap->ip->i_d.di_nblocks += ap->length; 3962f65306eaSDarrick J. Wong xfs_trans_log_inode(ap->tp, ap->ip, XFS_ILOG_CORE); 3963f65306eaSDarrick J. Wong 3964f65306eaSDarrick J. Wong /* Fix the freelist, like a real allocator does. */ 3965f65306eaSDarrick J. Wong args.datatype = ap->datatype; 3966f65306eaSDarrick J. Wong args.pag = xfs_perag_get(args.mp, args.agno); 3967f65306eaSDarrick J. Wong ASSERT(args.pag); 3968f65306eaSDarrick J. Wong 3969f65306eaSDarrick J. Wong /* 3970f65306eaSDarrick J. Wong * The freelist fixing code will decline the allocation if 3971f65306eaSDarrick J. Wong * the size and shape of the free space doesn't allow for 3972f65306eaSDarrick J. Wong * allocating the extent and updating all the metadata that 3973f65306eaSDarrick J. Wong * happens during an allocation. We're remapping, not 3974f65306eaSDarrick J. Wong * allocating, so skip that check by pretending to be freeing. 3975f65306eaSDarrick J. Wong */ 3976f65306eaSDarrick J. Wong error = xfs_alloc_fix_freelist(&args, XFS_ALLOC_FLAG_FREEING); 3977f65306eaSDarrick J. Wong if (error) 3978f65306eaSDarrick J. Wong goto error0; 3979f65306eaSDarrick J. Wong error0: 3980f65306eaSDarrick J. Wong xfs_perag_put(args.pag); 3981f65306eaSDarrick J. Wong if (error) 3982f65306eaSDarrick J. Wong trace_xfs_bmap_remap_alloc_error(ap->ip, error, _RET_IP_); 3983f65306eaSDarrick J. Wong return error; 3984f65306eaSDarrick J. Wong } 3985f65306eaSDarrick J. Wong 3986f65306eaSDarrick J. Wong /* 398730f712c9SDave Chinner * xfs_bmap_alloc is called by xfs_bmapi to allocate an extent for a file. 398830f712c9SDave Chinner * It figures out where to ask the underlying allocator to put the new extent. 398930f712c9SDave Chinner */ 399030f712c9SDave Chinner STATIC int 399130f712c9SDave Chinner xfs_bmap_alloc( 399230f712c9SDave Chinner struct xfs_bmalloca *ap) /* bmap alloc argument struct */ 399330f712c9SDave Chinner { 3994f65306eaSDarrick J. Wong if (ap->flags & XFS_BMAPI_REMAP) 3995f65306eaSDarrick J. Wong return xfs_bmap_remap_alloc(ap); 3996292378edSDave Chinner if (XFS_IS_REALTIME_INODE(ap->ip) && 3997292378edSDave Chinner xfs_alloc_is_userdata(ap->datatype)) 399830f712c9SDave Chinner return xfs_bmap_rtalloc(ap); 399930f712c9SDave Chinner return xfs_bmap_btalloc(ap); 400030f712c9SDave Chinner } 400130f712c9SDave Chinner 400230f712c9SDave Chinner /* 400330f712c9SDave Chinner * Trim the returned map to the required bounds 400430f712c9SDave Chinner */ 400530f712c9SDave Chinner STATIC void 400630f712c9SDave Chinner xfs_bmapi_trim_map( 400730f712c9SDave Chinner struct xfs_bmbt_irec *mval, 400830f712c9SDave Chinner struct xfs_bmbt_irec *got, 400930f712c9SDave Chinner xfs_fileoff_t *bno, 401030f712c9SDave Chinner xfs_filblks_t len, 401130f712c9SDave Chinner xfs_fileoff_t obno, 401230f712c9SDave Chinner xfs_fileoff_t end, 401330f712c9SDave Chinner int n, 401430f712c9SDave Chinner int flags) 401530f712c9SDave Chinner { 401630f712c9SDave Chinner if ((flags & XFS_BMAPI_ENTIRE) || 401730f712c9SDave Chinner got->br_startoff + got->br_blockcount <= obno) { 401830f712c9SDave Chinner *mval = *got; 401930f712c9SDave Chinner if (isnullstartblock(got->br_startblock)) 402030f712c9SDave Chinner mval->br_startblock = DELAYSTARTBLOCK; 402130f712c9SDave Chinner return; 402230f712c9SDave Chinner } 402330f712c9SDave Chinner 402430f712c9SDave Chinner if (obno > *bno) 402530f712c9SDave Chinner *bno = obno; 402630f712c9SDave Chinner ASSERT((*bno >= obno) || (n == 0)); 402730f712c9SDave Chinner ASSERT(*bno < end); 402830f712c9SDave Chinner mval->br_startoff = *bno; 402930f712c9SDave Chinner if (isnullstartblock(got->br_startblock)) 403030f712c9SDave Chinner mval->br_startblock = DELAYSTARTBLOCK; 403130f712c9SDave Chinner else 403230f712c9SDave Chinner mval->br_startblock = got->br_startblock + 403330f712c9SDave Chinner (*bno - got->br_startoff); 403430f712c9SDave Chinner /* 403530f712c9SDave Chinner * Return the minimum of what we got and what we asked for for 403630f712c9SDave Chinner * the length. We can use the len variable here because it is 403730f712c9SDave Chinner * modified below and we could have been there before coming 403830f712c9SDave Chinner * here if the first part of the allocation didn't overlap what 403930f712c9SDave Chinner * was asked for. 404030f712c9SDave Chinner */ 404130f712c9SDave Chinner mval->br_blockcount = XFS_FILBLKS_MIN(end - *bno, 404230f712c9SDave Chinner got->br_blockcount - (*bno - got->br_startoff)); 404330f712c9SDave Chinner mval->br_state = got->br_state; 404430f712c9SDave Chinner ASSERT(mval->br_blockcount <= len); 404530f712c9SDave Chinner return; 404630f712c9SDave Chinner } 404730f712c9SDave Chinner 404830f712c9SDave Chinner /* 404930f712c9SDave Chinner * Update and validate the extent map to return 405030f712c9SDave Chinner */ 405130f712c9SDave Chinner STATIC void 405230f712c9SDave Chinner xfs_bmapi_update_map( 405330f712c9SDave Chinner struct xfs_bmbt_irec **map, 405430f712c9SDave Chinner xfs_fileoff_t *bno, 405530f712c9SDave Chinner xfs_filblks_t *len, 405630f712c9SDave Chinner xfs_fileoff_t obno, 405730f712c9SDave Chinner xfs_fileoff_t end, 405830f712c9SDave Chinner int *n, 405930f712c9SDave Chinner int flags) 406030f712c9SDave Chinner { 406130f712c9SDave Chinner xfs_bmbt_irec_t *mval = *map; 406230f712c9SDave Chinner 406330f712c9SDave Chinner ASSERT((flags & XFS_BMAPI_ENTIRE) || 406430f712c9SDave Chinner ((mval->br_startoff + mval->br_blockcount) <= end)); 406530f712c9SDave Chinner ASSERT((flags & XFS_BMAPI_ENTIRE) || (mval->br_blockcount <= *len) || 406630f712c9SDave Chinner (mval->br_startoff < obno)); 406730f712c9SDave Chinner 406830f712c9SDave Chinner *bno = mval->br_startoff + mval->br_blockcount; 406930f712c9SDave Chinner *len = end - *bno; 407030f712c9SDave Chinner if (*n > 0 && mval->br_startoff == mval[-1].br_startoff) { 407130f712c9SDave Chinner /* update previous map with new information */ 407230f712c9SDave Chinner ASSERT(mval->br_startblock == mval[-1].br_startblock); 407330f712c9SDave Chinner ASSERT(mval->br_blockcount > mval[-1].br_blockcount); 407430f712c9SDave Chinner ASSERT(mval->br_state == mval[-1].br_state); 407530f712c9SDave Chinner mval[-1].br_blockcount = mval->br_blockcount; 407630f712c9SDave Chinner mval[-1].br_state = mval->br_state; 407730f712c9SDave Chinner } else if (*n > 0 && mval->br_startblock != DELAYSTARTBLOCK && 407830f712c9SDave Chinner mval[-1].br_startblock != DELAYSTARTBLOCK && 407930f712c9SDave Chinner mval[-1].br_startblock != HOLESTARTBLOCK && 408030f712c9SDave Chinner mval->br_startblock == mval[-1].br_startblock + 408130f712c9SDave Chinner mval[-1].br_blockcount && 408230f712c9SDave Chinner ((flags & XFS_BMAPI_IGSTATE) || 408330f712c9SDave Chinner mval[-1].br_state == mval->br_state)) { 408430f712c9SDave Chinner ASSERT(mval->br_startoff == 408530f712c9SDave Chinner mval[-1].br_startoff + mval[-1].br_blockcount); 408630f712c9SDave Chinner mval[-1].br_blockcount += mval->br_blockcount; 408730f712c9SDave Chinner } else if (*n > 0 && 408830f712c9SDave Chinner mval->br_startblock == DELAYSTARTBLOCK && 408930f712c9SDave Chinner mval[-1].br_startblock == DELAYSTARTBLOCK && 409030f712c9SDave Chinner mval->br_startoff == 409130f712c9SDave Chinner mval[-1].br_startoff + mval[-1].br_blockcount) { 409230f712c9SDave Chinner mval[-1].br_blockcount += mval->br_blockcount; 409330f712c9SDave Chinner mval[-1].br_state = mval->br_state; 409430f712c9SDave Chinner } else if (!((*n == 0) && 409530f712c9SDave Chinner ((mval->br_startoff + mval->br_blockcount) <= 409630f712c9SDave Chinner obno))) { 409730f712c9SDave Chinner mval++; 409830f712c9SDave Chinner (*n)++; 409930f712c9SDave Chinner } 410030f712c9SDave Chinner *map = mval; 410130f712c9SDave Chinner } 410230f712c9SDave Chinner 410330f712c9SDave Chinner /* 410430f712c9SDave Chinner * Map file blocks to filesystem blocks without allocation. 410530f712c9SDave Chinner */ 410630f712c9SDave Chinner int 410730f712c9SDave Chinner xfs_bmapi_read( 410830f712c9SDave Chinner struct xfs_inode *ip, 410930f712c9SDave Chinner xfs_fileoff_t bno, 411030f712c9SDave Chinner xfs_filblks_t len, 411130f712c9SDave Chinner struct xfs_bmbt_irec *mval, 411230f712c9SDave Chinner int *nmap, 411330f712c9SDave Chinner int flags) 411430f712c9SDave Chinner { 411530f712c9SDave Chinner struct xfs_mount *mp = ip->i_mount; 411630f712c9SDave Chinner struct xfs_ifork *ifp; 411730f712c9SDave Chinner struct xfs_bmbt_irec got; 411830f712c9SDave Chinner struct xfs_bmbt_irec prev; 411930f712c9SDave Chinner xfs_fileoff_t obno; 412030f712c9SDave Chinner xfs_fileoff_t end; 412130f712c9SDave Chinner xfs_extnum_t lastx; 412230f712c9SDave Chinner int error; 412330f712c9SDave Chinner int eof; 412430f712c9SDave Chinner int n = 0; 41253993baebSDarrick J. Wong int whichfork = xfs_bmapi_whichfork(flags); 412630f712c9SDave Chinner 412730f712c9SDave Chinner ASSERT(*nmap >= 1); 412830f712c9SDave Chinner ASSERT(!(flags & ~(XFS_BMAPI_ATTRFORK|XFS_BMAPI_ENTIRE| 41293993baebSDarrick J. Wong XFS_BMAPI_IGSTATE|XFS_BMAPI_COWFORK))); 413030f712c9SDave Chinner ASSERT(xfs_isilocked(ip, XFS_ILOCK_SHARED|XFS_ILOCK_EXCL)); 413130f712c9SDave Chinner 413230f712c9SDave Chinner if (unlikely(XFS_TEST_ERROR( 413330f712c9SDave Chinner (XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS && 413430f712c9SDave Chinner XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE), 413530f712c9SDave Chinner mp, XFS_ERRTAG_BMAPIFORMAT, XFS_RANDOM_BMAPIFORMAT))) { 413630f712c9SDave Chinner XFS_ERROR_REPORT("xfs_bmapi_read", XFS_ERRLEVEL_LOW, mp); 41372451337dSDave Chinner return -EFSCORRUPTED; 413830f712c9SDave Chinner } 413930f712c9SDave Chinner 414030f712c9SDave Chinner if (XFS_FORCED_SHUTDOWN(mp)) 41412451337dSDave Chinner return -EIO; 414230f712c9SDave Chinner 4143ff6d6af2SBill O'Donnell XFS_STATS_INC(mp, xs_blk_mapr); 414430f712c9SDave Chinner 414530f712c9SDave Chinner ifp = XFS_IFORK_PTR(ip, whichfork); 414630f712c9SDave Chinner 41473993baebSDarrick J. Wong /* No CoW fork? Return a hole. */ 41483993baebSDarrick J. Wong if (whichfork == XFS_COW_FORK && !ifp) { 41493993baebSDarrick J. Wong mval->br_startoff = bno; 41503993baebSDarrick J. Wong mval->br_startblock = HOLESTARTBLOCK; 41513993baebSDarrick J. Wong mval->br_blockcount = len; 41523993baebSDarrick J. Wong mval->br_state = XFS_EXT_NORM; 41533993baebSDarrick J. Wong *nmap = 1; 41543993baebSDarrick J. Wong return 0; 41553993baebSDarrick J. Wong } 41563993baebSDarrick J. Wong 415730f712c9SDave Chinner if (!(ifp->if_flags & XFS_IFEXTENTS)) { 415830f712c9SDave Chinner error = xfs_iread_extents(NULL, ip, whichfork); 415930f712c9SDave Chinner if (error) 416030f712c9SDave Chinner return error; 416130f712c9SDave Chinner } 416230f712c9SDave Chinner 416330f712c9SDave Chinner xfs_bmap_search_extents(ip, bno, whichfork, &eof, &lastx, &got, &prev); 416430f712c9SDave Chinner end = bno + len; 416530f712c9SDave Chinner obno = bno; 416630f712c9SDave Chinner 416730f712c9SDave Chinner while (bno < end && n < *nmap) { 416830f712c9SDave Chinner /* Reading past eof, act as though there's a hole up to end. */ 416930f712c9SDave Chinner if (eof) 417030f712c9SDave Chinner got.br_startoff = end; 417130f712c9SDave Chinner if (got.br_startoff > bno) { 417230f712c9SDave Chinner /* Reading in a hole. */ 417330f712c9SDave Chinner mval->br_startoff = bno; 417430f712c9SDave Chinner mval->br_startblock = HOLESTARTBLOCK; 417530f712c9SDave Chinner mval->br_blockcount = 417630f712c9SDave Chinner XFS_FILBLKS_MIN(len, got.br_startoff - bno); 417730f712c9SDave Chinner mval->br_state = XFS_EXT_NORM; 417830f712c9SDave Chinner bno += mval->br_blockcount; 417930f712c9SDave Chinner len -= mval->br_blockcount; 418030f712c9SDave Chinner mval++; 418130f712c9SDave Chinner n++; 418230f712c9SDave Chinner continue; 418330f712c9SDave Chinner } 418430f712c9SDave Chinner 418530f712c9SDave Chinner /* set up the extent map to return. */ 418630f712c9SDave Chinner xfs_bmapi_trim_map(mval, &got, &bno, len, obno, end, n, flags); 418730f712c9SDave Chinner xfs_bmapi_update_map(&mval, &bno, &len, obno, end, &n, flags); 418830f712c9SDave Chinner 418930f712c9SDave Chinner /* If we're done, stop now. */ 419030f712c9SDave Chinner if (bno >= end || n >= *nmap) 419130f712c9SDave Chinner break; 419230f712c9SDave Chinner 419330f712c9SDave Chinner /* Else go on to the next record. */ 419430f712c9SDave Chinner if (++lastx < ifp->if_bytes / sizeof(xfs_bmbt_rec_t)) 419530f712c9SDave Chinner xfs_bmbt_get_all(xfs_iext_get_ext(ifp, lastx), &got); 419630f712c9SDave Chinner else 419730f712c9SDave Chinner eof = 1; 419830f712c9SDave Chinner } 419930f712c9SDave Chinner *nmap = n; 420030f712c9SDave Chinner return 0; 420130f712c9SDave Chinner } 420230f712c9SDave Chinner 420351446f5bSChristoph Hellwig int 420430f712c9SDave Chinner xfs_bmapi_reserve_delalloc( 420530f712c9SDave Chinner struct xfs_inode *ip, 4206be51f811SDarrick J. Wong int whichfork, 420730f712c9SDave Chinner xfs_fileoff_t aoff, 420830f712c9SDave Chinner xfs_filblks_t len, 420930f712c9SDave Chinner struct xfs_bmbt_irec *got, 421030f712c9SDave Chinner struct xfs_bmbt_irec *prev, 421130f712c9SDave Chinner xfs_extnum_t *lastx, 421230f712c9SDave Chinner int eof) 421330f712c9SDave Chinner { 421430f712c9SDave Chinner struct xfs_mount *mp = ip->i_mount; 4215be51f811SDarrick J. Wong struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, whichfork); 421630f712c9SDave Chinner xfs_extlen_t alen; 421730f712c9SDave Chinner xfs_extlen_t indlen; 421830f712c9SDave Chinner char rt = XFS_IS_REALTIME_INODE(ip); 421930f712c9SDave Chinner xfs_extlen_t extsz; 422030f712c9SDave Chinner int error; 422130f712c9SDave Chinner 422230f712c9SDave Chinner alen = XFS_FILBLKS_MIN(len, MAXEXTLEN); 422330f712c9SDave Chinner if (!eof) 422430f712c9SDave Chinner alen = XFS_FILBLKS_MIN(alen, got->br_startoff - aoff); 422530f712c9SDave Chinner 422630f712c9SDave Chinner /* Figure out the extent size, adjust alen */ 4227f7ca3522SDarrick J. Wong if (whichfork == XFS_COW_FORK) 4228f7ca3522SDarrick J. Wong extsz = xfs_get_cowextsz_hint(ip); 4229f7ca3522SDarrick J. Wong else 423030f712c9SDave Chinner extsz = xfs_get_extsz_hint(ip); 423130f712c9SDave Chinner if (extsz) { 423230f712c9SDave Chinner error = xfs_bmap_extsize_align(mp, got, prev, extsz, rt, eof, 423330f712c9SDave Chinner 1, 0, &aoff, &alen); 423430f712c9SDave Chinner ASSERT(!error); 423530f712c9SDave Chinner } 423630f712c9SDave Chinner 423730f712c9SDave Chinner if (rt) 423830f712c9SDave Chinner extsz = alen / mp->m_sb.sb_rextsize; 423930f712c9SDave Chinner 424030f712c9SDave Chinner /* 424130f712c9SDave Chinner * Make a transaction-less quota reservation for delayed allocation 424230f712c9SDave Chinner * blocks. This number gets adjusted later. We return if we haven't 424330f712c9SDave Chinner * allocated blocks already inside this loop. 424430f712c9SDave Chinner */ 424530f712c9SDave Chinner error = xfs_trans_reserve_quota_nblks(NULL, ip, (long)alen, 0, 424630f712c9SDave Chinner rt ? XFS_QMOPT_RES_RTBLKS : XFS_QMOPT_RES_REGBLKS); 424730f712c9SDave Chinner if (error) 424830f712c9SDave Chinner return error; 424930f712c9SDave Chinner 425030f712c9SDave Chinner /* 425130f712c9SDave Chinner * Split changing sb for alen and indlen since they could be coming 425230f712c9SDave Chinner * from different places. 425330f712c9SDave Chinner */ 425430f712c9SDave Chinner indlen = (xfs_extlen_t)xfs_bmap_worst_indlen(ip, alen); 425530f712c9SDave Chinner ASSERT(indlen > 0); 425630f712c9SDave Chinner 425730f712c9SDave Chinner if (rt) { 4258bab98bbeSDave Chinner error = xfs_mod_frextents(mp, -((int64_t)extsz)); 425930f712c9SDave Chinner } else { 42600d485adaSDave Chinner error = xfs_mod_fdblocks(mp, -((int64_t)alen), false); 426130f712c9SDave Chinner } 426230f712c9SDave Chinner 426330f712c9SDave Chinner if (error) 426430f712c9SDave Chinner goto out_unreserve_quota; 426530f712c9SDave Chinner 42660d485adaSDave Chinner error = xfs_mod_fdblocks(mp, -((int64_t)indlen), false); 426730f712c9SDave Chinner if (error) 426830f712c9SDave Chinner goto out_unreserve_blocks; 426930f712c9SDave Chinner 427030f712c9SDave Chinner 427130f712c9SDave Chinner ip->i_delayed_blks += alen; 427230f712c9SDave Chinner 427330f712c9SDave Chinner got->br_startoff = aoff; 427430f712c9SDave Chinner got->br_startblock = nullstartblock(indlen); 427530f712c9SDave Chinner got->br_blockcount = alen; 427630f712c9SDave Chinner got->br_state = XFS_EXT_NORM; 4277be51f811SDarrick J. Wong xfs_bmap_add_extent_hole_delay(ip, whichfork, lastx, got); 427830f712c9SDave Chinner 427930f712c9SDave Chinner /* 428030f712c9SDave Chinner * Update our extent pointer, given that xfs_bmap_add_extent_hole_delay 428130f712c9SDave Chinner * might have merged it into one of the neighbouring ones. 428230f712c9SDave Chinner */ 428330f712c9SDave Chinner xfs_bmbt_get_all(xfs_iext_get_ext(ifp, *lastx), got); 428430f712c9SDave Chinner 428530f712c9SDave Chinner ASSERT(got->br_startoff <= aoff); 428630f712c9SDave Chinner ASSERT(got->br_startoff + got->br_blockcount >= aoff + alen); 428730f712c9SDave Chinner ASSERT(isnullstartblock(got->br_startblock)); 428830f712c9SDave Chinner ASSERT(got->br_state == XFS_EXT_NORM); 428930f712c9SDave Chinner return 0; 429030f712c9SDave Chinner 429130f712c9SDave Chinner out_unreserve_blocks: 429230f712c9SDave Chinner if (rt) 4293bab98bbeSDave Chinner xfs_mod_frextents(mp, extsz); 429430f712c9SDave Chinner else 42950d485adaSDave Chinner xfs_mod_fdblocks(mp, alen, false); 429630f712c9SDave Chinner out_unreserve_quota: 429730f712c9SDave Chinner if (XFS_IS_QUOTA_ON(mp)) 429830f712c9SDave Chinner xfs_trans_unreserve_quota_nblks(NULL, ip, (long)alen, 0, rt ? 429930f712c9SDave Chinner XFS_QMOPT_RES_RTBLKS : XFS_QMOPT_RES_REGBLKS); 430030f712c9SDave Chinner return error; 430130f712c9SDave Chinner } 430230f712c9SDave Chinner 43037f8a058fSDave Chinner static int 43047f8a058fSDave Chinner xfs_bmapi_allocate( 430530f712c9SDave Chinner struct xfs_bmalloca *bma) 430630f712c9SDave Chinner { 430730f712c9SDave Chinner struct xfs_mount *mp = bma->ip->i_mount; 430860b4984fSDarrick J. Wong int whichfork = xfs_bmapi_whichfork(bma->flags); 430930f712c9SDave Chinner struct xfs_ifork *ifp = XFS_IFORK_PTR(bma->ip, whichfork); 431030f712c9SDave Chinner int tmp_logflags = 0; 431130f712c9SDave Chinner int error; 431230f712c9SDave Chinner 431330f712c9SDave Chinner ASSERT(bma->length > 0); 431430f712c9SDave Chinner 431530f712c9SDave Chinner /* 431630f712c9SDave Chinner * For the wasdelay case, we could also just allocate the stuff asked 431730f712c9SDave Chinner * for in this bmap call but that wouldn't be as good. 431830f712c9SDave Chinner */ 431930f712c9SDave Chinner if (bma->wasdel) { 432030f712c9SDave Chinner bma->length = (xfs_extlen_t)bma->got.br_blockcount; 432130f712c9SDave Chinner bma->offset = bma->got.br_startoff; 432230f712c9SDave Chinner if (bma->idx != NULLEXTNUM && bma->idx) { 432330f712c9SDave Chinner xfs_bmbt_get_all(xfs_iext_get_ext(ifp, bma->idx - 1), 432430f712c9SDave Chinner &bma->prev); 432530f712c9SDave Chinner } 432630f712c9SDave Chinner } else { 432730f712c9SDave Chinner bma->length = XFS_FILBLKS_MIN(bma->length, MAXEXTLEN); 432830f712c9SDave Chinner if (!bma->eof) 432930f712c9SDave Chinner bma->length = XFS_FILBLKS_MIN(bma->length, 433030f712c9SDave Chinner bma->got.br_startoff - bma->offset); 433130f712c9SDave Chinner } 433230f712c9SDave Chinner 433330f712c9SDave Chinner /* 4334292378edSDave Chinner * Set the data type being allocated. For the data fork, the first data 4335292378edSDave Chinner * in the file is treated differently to all other allocations. For the 4336292378edSDave Chinner * attribute fork, we only need to ensure the allocated range is not on 4337292378edSDave Chinner * the busy list. 433830f712c9SDave Chinner */ 433930f712c9SDave Chinner if (!(bma->flags & XFS_BMAPI_METADATA)) { 4340292378edSDave Chinner bma->datatype = XFS_ALLOC_NOBUSY; 4341292378edSDave Chinner if (whichfork == XFS_DATA_FORK) { 4342292378edSDave Chinner if (bma->offset == 0) 4343292378edSDave Chinner bma->datatype |= XFS_ALLOC_INITIAL_USER_DATA; 4344292378edSDave Chinner else 4345292378edSDave Chinner bma->datatype |= XFS_ALLOC_USERDATA; 4346292378edSDave Chinner } 43473fbbbea3SDave Chinner if (bma->flags & XFS_BMAPI_ZERO) 4348292378edSDave Chinner bma->datatype |= XFS_ALLOC_USERDATA_ZERO; 434930f712c9SDave Chinner } 435030f712c9SDave Chinner 435130f712c9SDave Chinner bma->minlen = (bma->flags & XFS_BMAPI_CONTIG) ? bma->length : 1; 435230f712c9SDave Chinner 435330f712c9SDave Chinner /* 435430f712c9SDave Chinner * Only want to do the alignment at the eof if it is userdata and 435530f712c9SDave Chinner * allocation length is larger than a stripe unit. 435630f712c9SDave Chinner */ 435730f712c9SDave Chinner if (mp->m_dalign && bma->length >= mp->m_dalign && 435830f712c9SDave Chinner !(bma->flags & XFS_BMAPI_METADATA) && whichfork == XFS_DATA_FORK) { 435930f712c9SDave Chinner error = xfs_bmap_isaeof(bma, whichfork); 436030f712c9SDave Chinner if (error) 436130f712c9SDave Chinner return error; 436230f712c9SDave Chinner } 436330f712c9SDave Chinner 436430f712c9SDave Chinner error = xfs_bmap_alloc(bma); 436530f712c9SDave Chinner if (error) 436630f712c9SDave Chinner return error; 436730f712c9SDave Chinner 43682c3234d1SDarrick J. Wong if (bma->dfops->dop_low) 436930f712c9SDave Chinner bma->minleft = 0; 437030f712c9SDave Chinner if (bma->cur) 437130f712c9SDave Chinner bma->cur->bc_private.b.firstblock = *bma->firstblock; 437230f712c9SDave Chinner if (bma->blkno == NULLFSBLOCK) 437330f712c9SDave Chinner return 0; 437430f712c9SDave Chinner if ((ifp->if_flags & XFS_IFBROOT) && !bma->cur) { 437530f712c9SDave Chinner bma->cur = xfs_bmbt_init_cursor(mp, bma->tp, bma->ip, whichfork); 437630f712c9SDave Chinner bma->cur->bc_private.b.firstblock = *bma->firstblock; 43772c3234d1SDarrick J. Wong bma->cur->bc_private.b.dfops = bma->dfops; 437830f712c9SDave Chinner } 437930f712c9SDave Chinner /* 438030f712c9SDave Chinner * Bump the number of extents we've allocated 438130f712c9SDave Chinner * in this call. 438230f712c9SDave Chinner */ 438330f712c9SDave Chinner bma->nallocs++; 438430f712c9SDave Chinner 438530f712c9SDave Chinner if (bma->cur) 438630f712c9SDave Chinner bma->cur->bc_private.b.flags = 438730f712c9SDave Chinner bma->wasdel ? XFS_BTCUR_BPRV_WASDEL : 0; 438830f712c9SDave Chinner 438930f712c9SDave Chinner bma->got.br_startoff = bma->offset; 439030f712c9SDave Chinner bma->got.br_startblock = bma->blkno; 439130f712c9SDave Chinner bma->got.br_blockcount = bma->length; 439230f712c9SDave Chinner bma->got.br_state = XFS_EXT_NORM; 439330f712c9SDave Chinner 439430f712c9SDave Chinner /* 439530f712c9SDave Chinner * A wasdelay extent has been initialized, so shouldn't be flagged 439630f712c9SDave Chinner * as unwritten. 439730f712c9SDave Chinner */ 439830f712c9SDave Chinner if (!bma->wasdel && (bma->flags & XFS_BMAPI_PREALLOC) && 439930f712c9SDave Chinner xfs_sb_version_hasextflgbit(&mp->m_sb)) 440030f712c9SDave Chinner bma->got.br_state = XFS_EXT_UNWRITTEN; 440130f712c9SDave Chinner 440230f712c9SDave Chinner if (bma->wasdel) 440360b4984fSDarrick J. Wong error = xfs_bmap_add_extent_delay_real(bma, whichfork); 440430f712c9SDave Chinner else 440530f712c9SDave Chinner error = xfs_bmap_add_extent_hole_real(bma, whichfork); 440630f712c9SDave Chinner 440730f712c9SDave Chinner bma->logflags |= tmp_logflags; 440830f712c9SDave Chinner if (error) 440930f712c9SDave Chinner return error; 441030f712c9SDave Chinner 441130f712c9SDave Chinner /* 441230f712c9SDave Chinner * Update our extent pointer, given that xfs_bmap_add_extent_delay_real 441330f712c9SDave Chinner * or xfs_bmap_add_extent_hole_real might have merged it into one of 441430f712c9SDave Chinner * the neighbouring ones. 441530f712c9SDave Chinner */ 441630f712c9SDave Chinner xfs_bmbt_get_all(xfs_iext_get_ext(ifp, bma->idx), &bma->got); 441730f712c9SDave Chinner 441830f712c9SDave Chinner ASSERT(bma->got.br_startoff <= bma->offset); 441930f712c9SDave Chinner ASSERT(bma->got.br_startoff + bma->got.br_blockcount >= 442030f712c9SDave Chinner bma->offset + bma->length); 442130f712c9SDave Chinner ASSERT(bma->got.br_state == XFS_EXT_NORM || 442230f712c9SDave Chinner bma->got.br_state == XFS_EXT_UNWRITTEN); 442330f712c9SDave Chinner return 0; 442430f712c9SDave Chinner } 442530f712c9SDave Chinner 442630f712c9SDave Chinner STATIC int 442730f712c9SDave Chinner xfs_bmapi_convert_unwritten( 442830f712c9SDave Chinner struct xfs_bmalloca *bma, 442930f712c9SDave Chinner struct xfs_bmbt_irec *mval, 443030f712c9SDave Chinner xfs_filblks_t len, 443130f712c9SDave Chinner int flags) 443230f712c9SDave Chinner { 44333993baebSDarrick J. Wong int whichfork = xfs_bmapi_whichfork(flags); 443430f712c9SDave Chinner struct xfs_ifork *ifp = XFS_IFORK_PTR(bma->ip, whichfork); 443530f712c9SDave Chinner int tmp_logflags = 0; 443630f712c9SDave Chinner int error; 443730f712c9SDave Chinner 443830f712c9SDave Chinner /* check if we need to do unwritten->real conversion */ 443930f712c9SDave Chinner if (mval->br_state == XFS_EXT_UNWRITTEN && 444030f712c9SDave Chinner (flags & XFS_BMAPI_PREALLOC)) 444130f712c9SDave Chinner return 0; 444230f712c9SDave Chinner 444330f712c9SDave Chinner /* check if we need to do real->unwritten conversion */ 444430f712c9SDave Chinner if (mval->br_state == XFS_EXT_NORM && 444530f712c9SDave Chinner (flags & (XFS_BMAPI_PREALLOC | XFS_BMAPI_CONVERT)) != 444630f712c9SDave Chinner (XFS_BMAPI_PREALLOC | XFS_BMAPI_CONVERT)) 444730f712c9SDave Chinner return 0; 444830f712c9SDave Chinner 44493993baebSDarrick J. Wong ASSERT(whichfork != XFS_COW_FORK); 44503993baebSDarrick J. Wong 445130f712c9SDave Chinner /* 445230f712c9SDave Chinner * Modify (by adding) the state flag, if writing. 445330f712c9SDave Chinner */ 445430f712c9SDave Chinner ASSERT(mval->br_blockcount <= len); 445530f712c9SDave Chinner if ((ifp->if_flags & XFS_IFBROOT) && !bma->cur) { 445630f712c9SDave Chinner bma->cur = xfs_bmbt_init_cursor(bma->ip->i_mount, bma->tp, 445730f712c9SDave Chinner bma->ip, whichfork); 445830f712c9SDave Chinner bma->cur->bc_private.b.firstblock = *bma->firstblock; 44592c3234d1SDarrick J. Wong bma->cur->bc_private.b.dfops = bma->dfops; 446030f712c9SDave Chinner } 446130f712c9SDave Chinner mval->br_state = (mval->br_state == XFS_EXT_UNWRITTEN) 446230f712c9SDave Chinner ? XFS_EXT_NORM : XFS_EXT_UNWRITTEN; 446330f712c9SDave Chinner 44643fbbbea3SDave Chinner /* 44653fbbbea3SDave Chinner * Before insertion into the bmbt, zero the range being converted 44663fbbbea3SDave Chinner * if required. 44673fbbbea3SDave Chinner */ 44683fbbbea3SDave Chinner if (flags & XFS_BMAPI_ZERO) { 44693fbbbea3SDave Chinner error = xfs_zero_extent(bma->ip, mval->br_startblock, 44703fbbbea3SDave Chinner mval->br_blockcount); 44713fbbbea3SDave Chinner if (error) 44723fbbbea3SDave Chinner return error; 44733fbbbea3SDave Chinner } 44743fbbbea3SDave Chinner 447530f712c9SDave Chinner error = xfs_bmap_add_extent_unwritten_real(bma->tp, bma->ip, &bma->idx, 44762c3234d1SDarrick J. Wong &bma->cur, mval, bma->firstblock, bma->dfops, 447730f712c9SDave Chinner &tmp_logflags); 44782e588a46SBrian Foster /* 44792e588a46SBrian Foster * Log the inode core unconditionally in the unwritten extent conversion 44802e588a46SBrian Foster * path because the conversion might not have done so (e.g., if the 44812e588a46SBrian Foster * extent count hasn't changed). We need to make sure the inode is dirty 44822e588a46SBrian Foster * in the transaction for the sake of fsync(), even if nothing has 44832e588a46SBrian Foster * changed, because fsync() will not force the log for this transaction 44842e588a46SBrian Foster * unless it sees the inode pinned. 44852e588a46SBrian Foster */ 44862e588a46SBrian Foster bma->logflags |= tmp_logflags | XFS_ILOG_CORE; 448730f712c9SDave Chinner if (error) 448830f712c9SDave Chinner return error; 448930f712c9SDave Chinner 449030f712c9SDave Chinner /* 449130f712c9SDave Chinner * Update our extent pointer, given that 449230f712c9SDave Chinner * xfs_bmap_add_extent_unwritten_real might have merged it into one 449330f712c9SDave Chinner * of the neighbouring ones. 449430f712c9SDave Chinner */ 449530f712c9SDave Chinner xfs_bmbt_get_all(xfs_iext_get_ext(ifp, bma->idx), &bma->got); 449630f712c9SDave Chinner 449730f712c9SDave Chinner /* 449830f712c9SDave Chinner * We may have combined previously unwritten space with written space, 449930f712c9SDave Chinner * so generate another request. 450030f712c9SDave Chinner */ 450130f712c9SDave Chinner if (mval->br_blockcount < len) 45022451337dSDave Chinner return -EAGAIN; 450330f712c9SDave Chinner return 0; 450430f712c9SDave Chinner } 450530f712c9SDave Chinner 450630f712c9SDave Chinner /* 450730f712c9SDave Chinner * Map file blocks to filesystem blocks, and allocate blocks or convert the 450830f712c9SDave Chinner * extent state if necessary. Details behaviour is controlled by the flags 450930f712c9SDave Chinner * parameter. Only allocates blocks from a single allocation group, to avoid 451030f712c9SDave Chinner * locking problems. 451130f712c9SDave Chinner * 451230f712c9SDave Chinner * The returned value in "firstblock" from the first call in a transaction 451330f712c9SDave Chinner * must be remembered and presented to subsequent calls in "firstblock". 451430f712c9SDave Chinner * An upper bound for the number of blocks to be allocated is supplied to 451530f712c9SDave Chinner * the first call in "total"; if no allocation group has that many free 451630f712c9SDave Chinner * blocks then the call will fail (return NULLFSBLOCK in "firstblock"). 451730f712c9SDave Chinner */ 451830f712c9SDave Chinner int 451930f712c9SDave Chinner xfs_bmapi_write( 452030f712c9SDave Chinner struct xfs_trans *tp, /* transaction pointer */ 452130f712c9SDave Chinner struct xfs_inode *ip, /* incore inode */ 452230f712c9SDave Chinner xfs_fileoff_t bno, /* starting file offs. mapped */ 452330f712c9SDave Chinner xfs_filblks_t len, /* length to map in file */ 452430f712c9SDave Chinner int flags, /* XFS_BMAPI_... */ 452530f712c9SDave Chinner xfs_fsblock_t *firstblock, /* first allocated block 452630f712c9SDave Chinner controls a.g. for allocs */ 452730f712c9SDave Chinner xfs_extlen_t total, /* total blocks needed */ 452830f712c9SDave Chinner struct xfs_bmbt_irec *mval, /* output: map values */ 452930f712c9SDave Chinner int *nmap, /* i/o: mval size/count */ 45302c3234d1SDarrick J. Wong struct xfs_defer_ops *dfops) /* i/o: list extents to free */ 453130f712c9SDave Chinner { 453230f712c9SDave Chinner struct xfs_mount *mp = ip->i_mount; 453330f712c9SDave Chinner struct xfs_ifork *ifp; 453430f712c9SDave Chinner struct xfs_bmalloca bma = { NULL }; /* args for xfs_bmap_alloc */ 453530f712c9SDave Chinner xfs_fileoff_t end; /* end of mapped file region */ 453630f712c9SDave Chinner int eof; /* after the end of extents */ 453730f712c9SDave Chinner int error; /* error return */ 453830f712c9SDave Chinner int n; /* current extent index */ 453930f712c9SDave Chinner xfs_fileoff_t obno; /* old block number (offset) */ 454030f712c9SDave Chinner int whichfork; /* data or attr fork */ 454130f712c9SDave Chinner char inhole; /* current location is hole in file */ 454230f712c9SDave Chinner char wasdelay; /* old extent was delayed */ 454330f712c9SDave Chinner 454430f712c9SDave Chinner #ifdef DEBUG 454530f712c9SDave Chinner xfs_fileoff_t orig_bno; /* original block number value */ 454630f712c9SDave Chinner int orig_flags; /* original flags arg value */ 454730f712c9SDave Chinner xfs_filblks_t orig_len; /* original value of len arg */ 454830f712c9SDave Chinner struct xfs_bmbt_irec *orig_mval; /* original value of mval */ 454930f712c9SDave Chinner int orig_nmap; /* original value of *nmap */ 455030f712c9SDave Chinner 455130f712c9SDave Chinner orig_bno = bno; 455230f712c9SDave Chinner orig_len = len; 455330f712c9SDave Chinner orig_flags = flags; 455430f712c9SDave Chinner orig_mval = mval; 455530f712c9SDave Chinner orig_nmap = *nmap; 455630f712c9SDave Chinner #endif 455760b4984fSDarrick J. Wong whichfork = xfs_bmapi_whichfork(flags); 455830f712c9SDave Chinner 455930f712c9SDave Chinner ASSERT(*nmap >= 1); 456030f712c9SDave Chinner ASSERT(*nmap <= XFS_BMAP_MAX_NMAP); 456130f712c9SDave Chinner ASSERT(!(flags & XFS_BMAPI_IGSTATE)); 456230f712c9SDave Chinner ASSERT(tp != NULL); 456330f712c9SDave Chinner ASSERT(len > 0); 456430f712c9SDave Chinner ASSERT(XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_LOCAL); 456530f712c9SDave Chinner ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL)); 4566f65306eaSDarrick J. Wong ASSERT(!(flags & XFS_BMAPI_REMAP) || whichfork == XFS_DATA_FORK); 4567f65306eaSDarrick J. Wong ASSERT(!(flags & XFS_BMAPI_PREALLOC) || !(flags & XFS_BMAPI_REMAP)); 4568f65306eaSDarrick J. Wong ASSERT(!(flags & XFS_BMAPI_CONVERT) || !(flags & XFS_BMAPI_REMAP)); 456960b4984fSDarrick J. Wong ASSERT(!(flags & XFS_BMAPI_PREALLOC) || whichfork != XFS_COW_FORK); 457060b4984fSDarrick J. Wong ASSERT(!(flags & XFS_BMAPI_CONVERT) || whichfork != XFS_COW_FORK); 457130f712c9SDave Chinner 45723fbbbea3SDave Chinner /* zeroing is for currently only for data extents, not metadata */ 45733fbbbea3SDave Chinner ASSERT((flags & (XFS_BMAPI_METADATA | XFS_BMAPI_ZERO)) != 45743fbbbea3SDave Chinner (XFS_BMAPI_METADATA | XFS_BMAPI_ZERO)); 45753fbbbea3SDave Chinner /* 45763fbbbea3SDave Chinner * we can allocate unwritten extents or pre-zero allocated blocks, 45773fbbbea3SDave Chinner * but it makes no sense to do both at once. This would result in 45783fbbbea3SDave Chinner * zeroing the unwritten extent twice, but it still being an 45793fbbbea3SDave Chinner * unwritten extent.... 45803fbbbea3SDave Chinner */ 45813fbbbea3SDave Chinner ASSERT((flags & (XFS_BMAPI_PREALLOC | XFS_BMAPI_ZERO)) != 45823fbbbea3SDave Chinner (XFS_BMAPI_PREALLOC | XFS_BMAPI_ZERO)); 45833fbbbea3SDave Chinner 458430f712c9SDave Chinner if (unlikely(XFS_TEST_ERROR( 458530f712c9SDave Chinner (XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS && 458630f712c9SDave Chinner XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE), 458730f712c9SDave Chinner mp, XFS_ERRTAG_BMAPIFORMAT, XFS_RANDOM_BMAPIFORMAT))) { 458830f712c9SDave Chinner XFS_ERROR_REPORT("xfs_bmapi_write", XFS_ERRLEVEL_LOW, mp); 45892451337dSDave Chinner return -EFSCORRUPTED; 459030f712c9SDave Chinner } 459130f712c9SDave Chinner 459230f712c9SDave Chinner if (XFS_FORCED_SHUTDOWN(mp)) 45932451337dSDave Chinner return -EIO; 459430f712c9SDave Chinner 459530f712c9SDave Chinner ifp = XFS_IFORK_PTR(ip, whichfork); 459630f712c9SDave Chinner 4597ff6d6af2SBill O'Donnell XFS_STATS_INC(mp, xs_blk_mapw); 459830f712c9SDave Chinner 459930f712c9SDave Chinner if (*firstblock == NULLFSBLOCK) { 460030f712c9SDave Chinner if (XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_BTREE) 460130f712c9SDave Chinner bma.minleft = be16_to_cpu(ifp->if_broot->bb_level) + 1; 460230f712c9SDave Chinner else 460330f712c9SDave Chinner bma.minleft = 1; 460430f712c9SDave Chinner } else { 460530f712c9SDave Chinner bma.minleft = 0; 460630f712c9SDave Chinner } 460730f712c9SDave Chinner 460830f712c9SDave Chinner if (!(ifp->if_flags & XFS_IFEXTENTS)) { 460930f712c9SDave Chinner error = xfs_iread_extents(tp, ip, whichfork); 461030f712c9SDave Chinner if (error) 461130f712c9SDave Chinner goto error0; 461230f712c9SDave Chinner } 461330f712c9SDave Chinner 461430f712c9SDave Chinner xfs_bmap_search_extents(ip, bno, whichfork, &eof, &bma.idx, &bma.got, 461530f712c9SDave Chinner &bma.prev); 461630f712c9SDave Chinner n = 0; 461730f712c9SDave Chinner end = bno + len; 461830f712c9SDave Chinner obno = bno; 461930f712c9SDave Chinner 462030f712c9SDave Chinner bma.tp = tp; 462130f712c9SDave Chinner bma.ip = ip; 462230f712c9SDave Chinner bma.total = total; 4623292378edSDave Chinner bma.datatype = 0; 46242c3234d1SDarrick J. Wong bma.dfops = dfops; 462530f712c9SDave Chinner bma.firstblock = firstblock; 462630f712c9SDave Chinner 462730f712c9SDave Chinner while (bno < end && n < *nmap) { 462830f712c9SDave Chinner inhole = eof || bma.got.br_startoff > bno; 462930f712c9SDave Chinner wasdelay = !inhole && isnullstartblock(bma.got.br_startblock); 463030f712c9SDave Chinner 463130f712c9SDave Chinner /* 4632f65306eaSDarrick J. Wong * Make sure we only reflink into a hole. 4633f65306eaSDarrick J. Wong */ 4634f65306eaSDarrick J. Wong if (flags & XFS_BMAPI_REMAP) 4635f65306eaSDarrick J. Wong ASSERT(inhole); 463660b4984fSDarrick J. Wong if (flags & XFS_BMAPI_COWFORK) 463760b4984fSDarrick J. Wong ASSERT(!inhole); 4638f65306eaSDarrick J. Wong 4639f65306eaSDarrick J. Wong /* 464030f712c9SDave Chinner * First, deal with the hole before the allocated space 464130f712c9SDave Chinner * that we found, if any. 464230f712c9SDave Chinner */ 464330f712c9SDave Chinner if (inhole || wasdelay) { 464430f712c9SDave Chinner bma.eof = eof; 464530f712c9SDave Chinner bma.conv = !!(flags & XFS_BMAPI_CONVERT); 464630f712c9SDave Chinner bma.wasdel = wasdelay; 464730f712c9SDave Chinner bma.offset = bno; 464830f712c9SDave Chinner bma.flags = flags; 464930f712c9SDave Chinner 465030f712c9SDave Chinner /* 465130f712c9SDave Chinner * There's a 32/64 bit type mismatch between the 465230f712c9SDave Chinner * allocation length request (which can be 64 bits in 465330f712c9SDave Chinner * length) and the bma length request, which is 465430f712c9SDave Chinner * xfs_extlen_t and therefore 32 bits. Hence we have to 465530f712c9SDave Chinner * check for 32-bit overflows and handle them here. 465630f712c9SDave Chinner */ 465730f712c9SDave Chinner if (len > (xfs_filblks_t)MAXEXTLEN) 465830f712c9SDave Chinner bma.length = MAXEXTLEN; 465930f712c9SDave Chinner else 466030f712c9SDave Chinner bma.length = len; 466130f712c9SDave Chinner 466230f712c9SDave Chinner ASSERT(len > 0); 466330f712c9SDave Chinner ASSERT(bma.length > 0); 466430f712c9SDave Chinner error = xfs_bmapi_allocate(&bma); 466530f712c9SDave Chinner if (error) 466630f712c9SDave Chinner goto error0; 466730f712c9SDave Chinner if (bma.blkno == NULLFSBLOCK) 466830f712c9SDave Chinner break; 4669174edb0eSDarrick J. Wong 4670174edb0eSDarrick J. Wong /* 4671174edb0eSDarrick J. Wong * If this is a CoW allocation, record the data in 4672174edb0eSDarrick J. Wong * the refcount btree for orphan recovery. 4673174edb0eSDarrick J. Wong */ 4674174edb0eSDarrick J. Wong if (whichfork == XFS_COW_FORK) { 4675174edb0eSDarrick J. Wong error = xfs_refcount_alloc_cow_extent(mp, dfops, 4676174edb0eSDarrick J. Wong bma.blkno, bma.length); 4677174edb0eSDarrick J. Wong if (error) 4678174edb0eSDarrick J. Wong goto error0; 4679174edb0eSDarrick J. Wong } 468030f712c9SDave Chinner } 468130f712c9SDave Chinner 468230f712c9SDave Chinner /* Deal with the allocated space we found. */ 468330f712c9SDave Chinner xfs_bmapi_trim_map(mval, &bma.got, &bno, len, obno, 468430f712c9SDave Chinner end, n, flags); 468530f712c9SDave Chinner 468630f712c9SDave Chinner /* Execute unwritten extent conversion if necessary */ 468730f712c9SDave Chinner error = xfs_bmapi_convert_unwritten(&bma, mval, len, flags); 46882451337dSDave Chinner if (error == -EAGAIN) 468930f712c9SDave Chinner continue; 469030f712c9SDave Chinner if (error) 469130f712c9SDave Chinner goto error0; 469230f712c9SDave Chinner 469330f712c9SDave Chinner /* update the extent map to return */ 469430f712c9SDave Chinner xfs_bmapi_update_map(&mval, &bno, &len, obno, end, &n, flags); 469530f712c9SDave Chinner 469630f712c9SDave Chinner /* 469730f712c9SDave Chinner * If we're done, stop now. Stop when we've allocated 469830f712c9SDave Chinner * XFS_BMAP_MAX_NMAP extents no matter what. Otherwise 469930f712c9SDave Chinner * the transaction may get too big. 470030f712c9SDave Chinner */ 470130f712c9SDave Chinner if (bno >= end || n >= *nmap || bma.nallocs >= *nmap) 470230f712c9SDave Chinner break; 470330f712c9SDave Chinner 470430f712c9SDave Chinner /* Else go on to the next record. */ 470530f712c9SDave Chinner bma.prev = bma.got; 470630f712c9SDave Chinner if (++bma.idx < ifp->if_bytes / sizeof(xfs_bmbt_rec_t)) { 470730f712c9SDave Chinner xfs_bmbt_get_all(xfs_iext_get_ext(ifp, bma.idx), 470830f712c9SDave Chinner &bma.got); 470930f712c9SDave Chinner } else 471030f712c9SDave Chinner eof = 1; 471130f712c9SDave Chinner } 471230f712c9SDave Chinner *nmap = n; 471330f712c9SDave Chinner 471430f712c9SDave Chinner /* 471530f712c9SDave Chinner * Transform from btree to extents, give it cur. 471630f712c9SDave Chinner */ 471730f712c9SDave Chinner if (xfs_bmap_wants_extents(ip, whichfork)) { 471830f712c9SDave Chinner int tmp_logflags = 0; 471930f712c9SDave Chinner 472030f712c9SDave Chinner ASSERT(bma.cur); 472130f712c9SDave Chinner error = xfs_bmap_btree_to_extents(tp, ip, bma.cur, 472230f712c9SDave Chinner &tmp_logflags, whichfork); 472330f712c9SDave Chinner bma.logflags |= tmp_logflags; 472430f712c9SDave Chinner if (error) 472530f712c9SDave Chinner goto error0; 472630f712c9SDave Chinner } 472730f712c9SDave Chinner 472830f712c9SDave Chinner ASSERT(XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE || 472930f712c9SDave Chinner XFS_IFORK_NEXTENTS(ip, whichfork) > 473030f712c9SDave Chinner XFS_IFORK_MAXEXT(ip, whichfork)); 473130f712c9SDave Chinner error = 0; 473230f712c9SDave Chinner error0: 473330f712c9SDave Chinner /* 473430f712c9SDave Chinner * Log everything. Do this after conversion, there's no point in 473530f712c9SDave Chinner * logging the extent records if we've converted to btree format. 473630f712c9SDave Chinner */ 473730f712c9SDave Chinner if ((bma.logflags & xfs_ilog_fext(whichfork)) && 473830f712c9SDave Chinner XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS) 473930f712c9SDave Chinner bma.logflags &= ~xfs_ilog_fext(whichfork); 474030f712c9SDave Chinner else if ((bma.logflags & xfs_ilog_fbroot(whichfork)) && 474130f712c9SDave Chinner XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE) 474230f712c9SDave Chinner bma.logflags &= ~xfs_ilog_fbroot(whichfork); 474330f712c9SDave Chinner /* 474430f712c9SDave Chinner * Log whatever the flags say, even if error. Otherwise we might miss 474530f712c9SDave Chinner * detecting a case where the data is changed, there's an error, 474630f712c9SDave Chinner * and it's not logged so we don't shutdown when we should. 474730f712c9SDave Chinner */ 474830f712c9SDave Chinner if (bma.logflags) 474930f712c9SDave Chinner xfs_trans_log_inode(tp, ip, bma.logflags); 475030f712c9SDave Chinner 475130f712c9SDave Chinner if (bma.cur) { 475230f712c9SDave Chinner if (!error) { 475330f712c9SDave Chinner ASSERT(*firstblock == NULLFSBLOCK || 475430f712c9SDave Chinner XFS_FSB_TO_AGNO(mp, *firstblock) == 475530f712c9SDave Chinner XFS_FSB_TO_AGNO(mp, 475630f712c9SDave Chinner bma.cur->bc_private.b.firstblock) || 47572c3234d1SDarrick J. Wong (dfops->dop_low && 475830f712c9SDave Chinner XFS_FSB_TO_AGNO(mp, *firstblock) < 475930f712c9SDave Chinner XFS_FSB_TO_AGNO(mp, 476030f712c9SDave Chinner bma.cur->bc_private.b.firstblock))); 476130f712c9SDave Chinner *firstblock = bma.cur->bc_private.b.firstblock; 476230f712c9SDave Chinner } 476330f712c9SDave Chinner xfs_btree_del_cursor(bma.cur, 476430f712c9SDave Chinner error ? XFS_BTREE_ERROR : XFS_BTREE_NOERROR); 476530f712c9SDave Chinner } 476630f712c9SDave Chinner if (!error) 476730f712c9SDave Chinner xfs_bmap_validate_ret(orig_bno, orig_len, orig_flags, orig_mval, 476830f712c9SDave Chinner orig_nmap, *nmap); 476930f712c9SDave Chinner return error; 477030f712c9SDave Chinner } 477130f712c9SDave Chinner 477230f712c9SDave Chinner /* 4773a9bd24acSBrian Foster * When a delalloc extent is split (e.g., due to a hole punch), the original 4774a9bd24acSBrian Foster * indlen reservation must be shared across the two new extents that are left 4775a9bd24acSBrian Foster * behind. 4776a9bd24acSBrian Foster * 4777a9bd24acSBrian Foster * Given the original reservation and the worst case indlen for the two new 4778a9bd24acSBrian Foster * extents (as calculated by xfs_bmap_worst_indlen()), split the original 4779d34999c9SBrian Foster * reservation fairly across the two new extents. If necessary, steal available 4780d34999c9SBrian Foster * blocks from a deleted extent to make up a reservation deficiency (e.g., if 4781d34999c9SBrian Foster * ores == 1). The number of stolen blocks is returned. The availability and 4782d34999c9SBrian Foster * subsequent accounting of stolen blocks is the responsibility of the caller. 4783a9bd24acSBrian Foster */ 4784d34999c9SBrian Foster static xfs_filblks_t 4785a9bd24acSBrian Foster xfs_bmap_split_indlen( 4786a9bd24acSBrian Foster xfs_filblks_t ores, /* original res. */ 4787a9bd24acSBrian Foster xfs_filblks_t *indlen1, /* ext1 worst indlen */ 4788d34999c9SBrian Foster xfs_filblks_t *indlen2, /* ext2 worst indlen */ 4789d34999c9SBrian Foster xfs_filblks_t avail) /* stealable blocks */ 4790a9bd24acSBrian Foster { 4791a9bd24acSBrian Foster xfs_filblks_t len1 = *indlen1; 4792a9bd24acSBrian Foster xfs_filblks_t len2 = *indlen2; 4793a9bd24acSBrian Foster xfs_filblks_t nres = len1 + len2; /* new total res. */ 4794d34999c9SBrian Foster xfs_filblks_t stolen = 0; 4795a9bd24acSBrian Foster 4796a9bd24acSBrian Foster /* 4797d34999c9SBrian Foster * Steal as many blocks as we can to try and satisfy the worst case 4798d34999c9SBrian Foster * indlen for both new extents. 4799d34999c9SBrian Foster */ 4800d34999c9SBrian Foster while (nres > ores && avail) { 4801d34999c9SBrian Foster nres--; 4802d34999c9SBrian Foster avail--; 4803d34999c9SBrian Foster stolen++; 4804d34999c9SBrian Foster } 4805d34999c9SBrian Foster 4806d34999c9SBrian Foster /* 4807d34999c9SBrian Foster * The only blocks available are those reserved for the original 4808d34999c9SBrian Foster * extent and what we can steal from the extent being removed. 4809d34999c9SBrian Foster * If this still isn't enough to satisfy the combined 4810d34999c9SBrian Foster * requirements for the two new extents, skim blocks off of each 4811d34999c9SBrian Foster * of the new reservations until they match what is available. 4812a9bd24acSBrian Foster */ 4813a9bd24acSBrian Foster while (nres > ores) { 4814a9bd24acSBrian Foster if (len1) { 4815a9bd24acSBrian Foster len1--; 4816a9bd24acSBrian Foster nres--; 4817a9bd24acSBrian Foster } 4818a9bd24acSBrian Foster if (nres == ores) 4819a9bd24acSBrian Foster break; 4820a9bd24acSBrian Foster if (len2) { 4821a9bd24acSBrian Foster len2--; 4822a9bd24acSBrian Foster nres--; 4823a9bd24acSBrian Foster } 4824a9bd24acSBrian Foster } 4825a9bd24acSBrian Foster 4826a9bd24acSBrian Foster *indlen1 = len1; 4827a9bd24acSBrian Foster *indlen2 = len2; 4828d34999c9SBrian Foster 4829d34999c9SBrian Foster return stolen; 4830a9bd24acSBrian Foster } 4831a9bd24acSBrian Foster 4832a9bd24acSBrian Foster /* 483330f712c9SDave Chinner * Called by xfs_bmapi to update file extent records and the btree 483430f712c9SDave Chinner * after removing space (or undoing a delayed allocation). 483530f712c9SDave Chinner */ 483630f712c9SDave Chinner STATIC int /* error */ 483730f712c9SDave Chinner xfs_bmap_del_extent( 483830f712c9SDave Chinner xfs_inode_t *ip, /* incore inode pointer */ 483930f712c9SDave Chinner xfs_trans_t *tp, /* current transaction pointer */ 484030f712c9SDave Chinner xfs_extnum_t *idx, /* extent number to update/delete */ 48412c3234d1SDarrick J. Wong struct xfs_defer_ops *dfops, /* list of extents to be freed */ 484230f712c9SDave Chinner xfs_btree_cur_t *cur, /* if null, not a btree */ 484330f712c9SDave Chinner xfs_bmbt_irec_t *del, /* data to remove from extents */ 484430f712c9SDave Chinner int *logflagsp, /* inode logging flags */ 48454847acf8SDarrick J. Wong int whichfork, /* data or attr fork */ 48464847acf8SDarrick J. Wong int bflags) /* bmapi flags */ 484730f712c9SDave Chinner { 484830f712c9SDave Chinner xfs_filblks_t da_new; /* new delay-alloc indirect blocks */ 484930f712c9SDave Chinner xfs_filblks_t da_old; /* old delay-alloc indirect blocks */ 485030f712c9SDave Chinner xfs_fsblock_t del_endblock=0; /* first block past del */ 485130f712c9SDave Chinner xfs_fileoff_t del_endoff; /* first offset past del */ 485230f712c9SDave Chinner int delay; /* current block is delayed allocated */ 485330f712c9SDave Chinner int do_fx; /* free extent at end of routine */ 485430f712c9SDave Chinner xfs_bmbt_rec_host_t *ep; /* current extent entry pointer */ 485530f712c9SDave Chinner int error; /* error return value */ 485630f712c9SDave Chinner int flags; /* inode logging flags */ 485730f712c9SDave Chinner xfs_bmbt_irec_t got; /* current extent entry */ 485830f712c9SDave Chinner xfs_fileoff_t got_endoff; /* first offset past got */ 485930f712c9SDave Chinner int i; /* temp state */ 486030f712c9SDave Chinner xfs_ifork_t *ifp; /* inode fork pointer */ 486130f712c9SDave Chinner xfs_mount_t *mp; /* mount structure */ 486230f712c9SDave Chinner xfs_filblks_t nblks; /* quota/sb block count */ 486330f712c9SDave Chinner xfs_bmbt_irec_t new; /* new record to be inserted */ 486430f712c9SDave Chinner /* REFERENCED */ 486530f712c9SDave Chinner uint qfield; /* quota field to update */ 486630f712c9SDave Chinner xfs_filblks_t temp; /* for indirect length calculations */ 486730f712c9SDave Chinner xfs_filblks_t temp2; /* for indirect length calculations */ 486830f712c9SDave Chinner int state = 0; 486930f712c9SDave Chinner 4870ff6d6af2SBill O'Donnell mp = ip->i_mount; 4871ff6d6af2SBill O'Donnell XFS_STATS_INC(mp, xs_del_exlist); 487230f712c9SDave Chinner 487330f712c9SDave Chinner if (whichfork == XFS_ATTR_FORK) 487430f712c9SDave Chinner state |= BMAP_ATTRFORK; 48753993baebSDarrick J. Wong else if (whichfork == XFS_COW_FORK) 48763993baebSDarrick J. Wong state |= BMAP_COWFORK; 487730f712c9SDave Chinner 487830f712c9SDave Chinner ifp = XFS_IFORK_PTR(ip, whichfork); 487930f712c9SDave Chinner ASSERT((*idx >= 0) && (*idx < ifp->if_bytes / 488030f712c9SDave Chinner (uint)sizeof(xfs_bmbt_rec_t))); 488130f712c9SDave Chinner ASSERT(del->br_blockcount > 0); 488230f712c9SDave Chinner ep = xfs_iext_get_ext(ifp, *idx); 488330f712c9SDave Chinner xfs_bmbt_get_all(ep, &got); 488430f712c9SDave Chinner ASSERT(got.br_startoff <= del->br_startoff); 488530f712c9SDave Chinner del_endoff = del->br_startoff + del->br_blockcount; 488630f712c9SDave Chinner got_endoff = got.br_startoff + got.br_blockcount; 488730f712c9SDave Chinner ASSERT(got_endoff >= del_endoff); 488830f712c9SDave Chinner delay = isnullstartblock(got.br_startblock); 488930f712c9SDave Chinner ASSERT(isnullstartblock(del->br_startblock) == delay); 489030f712c9SDave Chinner flags = 0; 489130f712c9SDave Chinner qfield = 0; 489230f712c9SDave Chinner error = 0; 489330f712c9SDave Chinner /* 489430f712c9SDave Chinner * If deleting a real allocation, must free up the disk space. 489530f712c9SDave Chinner */ 489630f712c9SDave Chinner if (!delay) { 489730f712c9SDave Chinner flags = XFS_ILOG_CORE; 489830f712c9SDave Chinner /* 489930f712c9SDave Chinner * Realtime allocation. Free it and record di_nblocks update. 490030f712c9SDave Chinner */ 490130f712c9SDave Chinner if (whichfork == XFS_DATA_FORK && XFS_IS_REALTIME_INODE(ip)) { 490230f712c9SDave Chinner xfs_fsblock_t bno; 490330f712c9SDave Chinner xfs_filblks_t len; 490430f712c9SDave Chinner 490530f712c9SDave Chinner ASSERT(do_mod(del->br_blockcount, 490630f712c9SDave Chinner mp->m_sb.sb_rextsize) == 0); 490730f712c9SDave Chinner ASSERT(do_mod(del->br_startblock, 490830f712c9SDave Chinner mp->m_sb.sb_rextsize) == 0); 490930f712c9SDave Chinner bno = del->br_startblock; 491030f712c9SDave Chinner len = del->br_blockcount; 491130f712c9SDave Chinner do_div(bno, mp->m_sb.sb_rextsize); 491230f712c9SDave Chinner do_div(len, mp->m_sb.sb_rextsize); 491330f712c9SDave Chinner error = xfs_rtfree_extent(tp, bno, (xfs_extlen_t)len); 491430f712c9SDave Chinner if (error) 491530f712c9SDave Chinner goto done; 491630f712c9SDave Chinner do_fx = 0; 491730f712c9SDave Chinner nblks = len * mp->m_sb.sb_rextsize; 491830f712c9SDave Chinner qfield = XFS_TRANS_DQ_RTBCOUNT; 491930f712c9SDave Chinner } 492030f712c9SDave Chinner /* 492130f712c9SDave Chinner * Ordinary allocation. 492230f712c9SDave Chinner */ 492330f712c9SDave Chinner else { 492430f712c9SDave Chinner do_fx = 1; 492530f712c9SDave Chinner nblks = del->br_blockcount; 492630f712c9SDave Chinner qfield = XFS_TRANS_DQ_BCOUNT; 492730f712c9SDave Chinner } 492830f712c9SDave Chinner /* 492930f712c9SDave Chinner * Set up del_endblock and cur for later. 493030f712c9SDave Chinner */ 493130f712c9SDave Chinner del_endblock = del->br_startblock + del->br_blockcount; 493230f712c9SDave Chinner if (cur) { 493330f712c9SDave Chinner if ((error = xfs_bmbt_lookup_eq(cur, got.br_startoff, 493430f712c9SDave Chinner got.br_startblock, got.br_blockcount, 493530f712c9SDave Chinner &i))) 493630f712c9SDave Chinner goto done; 4937c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 493830f712c9SDave Chinner } 493930f712c9SDave Chinner da_old = da_new = 0; 494030f712c9SDave Chinner } else { 494130f712c9SDave Chinner da_old = startblockval(got.br_startblock); 494230f712c9SDave Chinner da_new = 0; 494330f712c9SDave Chinner nblks = 0; 494430f712c9SDave Chinner do_fx = 0; 494530f712c9SDave Chinner } 4946340785ccSDarrick J. Wong 494730f712c9SDave Chinner /* 494830f712c9SDave Chinner * Set flag value to use in switch statement. 494930f712c9SDave Chinner * Left-contig is 2, right-contig is 1. 495030f712c9SDave Chinner */ 495130f712c9SDave Chinner switch (((got.br_startoff == del->br_startoff) << 1) | 495230f712c9SDave Chinner (got_endoff == del_endoff)) { 495330f712c9SDave Chinner case 3: 495430f712c9SDave Chinner /* 495530f712c9SDave Chinner * Matches the whole extent. Delete the entry. 495630f712c9SDave Chinner */ 49574862cfe8SDarrick J. Wong trace_xfs_bmap_pre_update(ip, *idx, state, _THIS_IP_); 495830f712c9SDave Chinner xfs_iext_remove(ip, *idx, 1, 495930f712c9SDave Chinner whichfork == XFS_ATTR_FORK ? BMAP_ATTRFORK : 0); 496030f712c9SDave Chinner --*idx; 496130f712c9SDave Chinner if (delay) 496230f712c9SDave Chinner break; 496330f712c9SDave Chinner 496430f712c9SDave Chinner XFS_IFORK_NEXT_SET(ip, whichfork, 496530f712c9SDave Chinner XFS_IFORK_NEXTENTS(ip, whichfork) - 1); 496630f712c9SDave Chinner flags |= XFS_ILOG_CORE; 496730f712c9SDave Chinner if (!cur) { 496830f712c9SDave Chinner flags |= xfs_ilog_fext(whichfork); 496930f712c9SDave Chinner break; 497030f712c9SDave Chinner } 497130f712c9SDave Chinner if ((error = xfs_btree_delete(cur, &i))) 497230f712c9SDave Chinner goto done; 4973c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 497430f712c9SDave Chinner break; 497530f712c9SDave Chinner 497630f712c9SDave Chinner case 2: 497730f712c9SDave Chinner /* 497830f712c9SDave Chinner * Deleting the first part of the extent. 497930f712c9SDave Chinner */ 498030f712c9SDave Chinner trace_xfs_bmap_pre_update(ip, *idx, state, _THIS_IP_); 498130f712c9SDave Chinner xfs_bmbt_set_startoff(ep, del_endoff); 498230f712c9SDave Chinner temp = got.br_blockcount - del->br_blockcount; 498330f712c9SDave Chinner xfs_bmbt_set_blockcount(ep, temp); 498430f712c9SDave Chinner if (delay) { 498530f712c9SDave Chinner temp = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(ip, temp), 498630f712c9SDave Chinner da_old); 498730f712c9SDave Chinner xfs_bmbt_set_startblock(ep, nullstartblock((int)temp)); 498830f712c9SDave Chinner trace_xfs_bmap_post_update(ip, *idx, state, _THIS_IP_); 498930f712c9SDave Chinner da_new = temp; 499030f712c9SDave Chinner break; 499130f712c9SDave Chinner } 499230f712c9SDave Chinner xfs_bmbt_set_startblock(ep, del_endblock); 499330f712c9SDave Chinner trace_xfs_bmap_post_update(ip, *idx, state, _THIS_IP_); 499430f712c9SDave Chinner if (!cur) { 499530f712c9SDave Chinner flags |= xfs_ilog_fext(whichfork); 499630f712c9SDave Chinner break; 499730f712c9SDave Chinner } 499830f712c9SDave Chinner if ((error = xfs_bmbt_update(cur, del_endoff, del_endblock, 499930f712c9SDave Chinner got.br_blockcount - del->br_blockcount, 500030f712c9SDave Chinner got.br_state))) 500130f712c9SDave Chinner goto done; 500230f712c9SDave Chinner break; 500330f712c9SDave Chinner 500430f712c9SDave Chinner case 1: 500530f712c9SDave Chinner /* 500630f712c9SDave Chinner * Deleting the last part of the extent. 500730f712c9SDave Chinner */ 500830f712c9SDave Chinner temp = got.br_blockcount - del->br_blockcount; 500930f712c9SDave Chinner trace_xfs_bmap_pre_update(ip, *idx, state, _THIS_IP_); 501030f712c9SDave Chinner xfs_bmbt_set_blockcount(ep, temp); 501130f712c9SDave Chinner if (delay) { 501230f712c9SDave Chinner temp = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(ip, temp), 501330f712c9SDave Chinner da_old); 501430f712c9SDave Chinner xfs_bmbt_set_startblock(ep, nullstartblock((int)temp)); 501530f712c9SDave Chinner trace_xfs_bmap_post_update(ip, *idx, state, _THIS_IP_); 501630f712c9SDave Chinner da_new = temp; 501730f712c9SDave Chinner break; 501830f712c9SDave Chinner } 501930f712c9SDave Chinner trace_xfs_bmap_post_update(ip, *idx, state, _THIS_IP_); 502030f712c9SDave Chinner if (!cur) { 502130f712c9SDave Chinner flags |= xfs_ilog_fext(whichfork); 502230f712c9SDave Chinner break; 502330f712c9SDave Chinner } 502430f712c9SDave Chinner if ((error = xfs_bmbt_update(cur, got.br_startoff, 502530f712c9SDave Chinner got.br_startblock, 502630f712c9SDave Chinner got.br_blockcount - del->br_blockcount, 502730f712c9SDave Chinner got.br_state))) 502830f712c9SDave Chinner goto done; 502930f712c9SDave Chinner break; 503030f712c9SDave Chinner 503130f712c9SDave Chinner case 0: 503230f712c9SDave Chinner /* 503330f712c9SDave Chinner * Deleting the middle of the extent. 503430f712c9SDave Chinner */ 503530f712c9SDave Chinner temp = del->br_startoff - got.br_startoff; 503630f712c9SDave Chinner trace_xfs_bmap_pre_update(ip, *idx, state, _THIS_IP_); 503730f712c9SDave Chinner xfs_bmbt_set_blockcount(ep, temp); 503830f712c9SDave Chinner new.br_startoff = del_endoff; 503930f712c9SDave Chinner temp2 = got_endoff - del_endoff; 504030f712c9SDave Chinner new.br_blockcount = temp2; 504130f712c9SDave Chinner new.br_state = got.br_state; 504230f712c9SDave Chinner if (!delay) { 504330f712c9SDave Chinner new.br_startblock = del_endblock; 504430f712c9SDave Chinner flags |= XFS_ILOG_CORE; 504530f712c9SDave Chinner if (cur) { 504630f712c9SDave Chinner if ((error = xfs_bmbt_update(cur, 504730f712c9SDave Chinner got.br_startoff, 504830f712c9SDave Chinner got.br_startblock, temp, 504930f712c9SDave Chinner got.br_state))) 505030f712c9SDave Chinner goto done; 505130f712c9SDave Chinner if ((error = xfs_btree_increment(cur, 0, &i))) 505230f712c9SDave Chinner goto done; 505330f712c9SDave Chinner cur->bc_rec.b = new; 505430f712c9SDave Chinner error = xfs_btree_insert(cur, &i); 50552451337dSDave Chinner if (error && error != -ENOSPC) 505630f712c9SDave Chinner goto done; 505730f712c9SDave Chinner /* 505830f712c9SDave Chinner * If get no-space back from btree insert, 505930f712c9SDave Chinner * it tried a split, and we have a zero 506030f712c9SDave Chinner * block reservation. 506130f712c9SDave Chinner * Fix up our state and return the error. 506230f712c9SDave Chinner */ 50632451337dSDave Chinner if (error == -ENOSPC) { 506430f712c9SDave Chinner /* 506530f712c9SDave Chinner * Reset the cursor, don't trust 506630f712c9SDave Chinner * it after any insert operation. 506730f712c9SDave Chinner */ 506830f712c9SDave Chinner if ((error = xfs_bmbt_lookup_eq(cur, 506930f712c9SDave Chinner got.br_startoff, 507030f712c9SDave Chinner got.br_startblock, 507130f712c9SDave Chinner temp, &i))) 507230f712c9SDave Chinner goto done; 5073c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, 5074c29aad41SEric Sandeen i == 1, done); 507530f712c9SDave Chinner /* 507630f712c9SDave Chinner * Update the btree record back 507730f712c9SDave Chinner * to the original value. 507830f712c9SDave Chinner */ 507930f712c9SDave Chinner if ((error = xfs_bmbt_update(cur, 508030f712c9SDave Chinner got.br_startoff, 508130f712c9SDave Chinner got.br_startblock, 508230f712c9SDave Chinner got.br_blockcount, 508330f712c9SDave Chinner got.br_state))) 508430f712c9SDave Chinner goto done; 508530f712c9SDave Chinner /* 508630f712c9SDave Chinner * Reset the extent record back 508730f712c9SDave Chinner * to the original value. 508830f712c9SDave Chinner */ 508930f712c9SDave Chinner xfs_bmbt_set_blockcount(ep, 509030f712c9SDave Chinner got.br_blockcount); 509130f712c9SDave Chinner flags = 0; 50922451337dSDave Chinner error = -ENOSPC; 509330f712c9SDave Chinner goto done; 509430f712c9SDave Chinner } 5095c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 509630f712c9SDave Chinner } else 509730f712c9SDave Chinner flags |= xfs_ilog_fext(whichfork); 509830f712c9SDave Chinner XFS_IFORK_NEXT_SET(ip, whichfork, 509930f712c9SDave Chinner XFS_IFORK_NEXTENTS(ip, whichfork) + 1); 510030f712c9SDave Chinner } else { 5101d34999c9SBrian Foster xfs_filblks_t stolen; 510230f712c9SDave Chinner ASSERT(whichfork == XFS_DATA_FORK); 5103a9bd24acSBrian Foster 5104a9bd24acSBrian Foster /* 5105a9bd24acSBrian Foster * Distribute the original indlen reservation across the 5106d34999c9SBrian Foster * two new extents. Steal blocks from the deleted extent 5107d34999c9SBrian Foster * if necessary. Stealing blocks simply fudges the 5108d34999c9SBrian Foster * fdblocks accounting in xfs_bunmapi(). 5109a9bd24acSBrian Foster */ 5110a9bd24acSBrian Foster temp = xfs_bmap_worst_indlen(ip, got.br_blockcount); 5111a9bd24acSBrian Foster temp2 = xfs_bmap_worst_indlen(ip, new.br_blockcount); 5112d34999c9SBrian Foster stolen = xfs_bmap_split_indlen(da_old, &temp, &temp2, 5113d34999c9SBrian Foster del->br_blockcount); 5114d34999c9SBrian Foster da_new = temp + temp2 - stolen; 5115d34999c9SBrian Foster del->br_blockcount -= stolen; 5116a9bd24acSBrian Foster 5117a9bd24acSBrian Foster /* 5118d34999c9SBrian Foster * Set the reservation for each extent. Warn if either 5119d34999c9SBrian Foster * is zero as this can lead to delalloc problems. 5120a9bd24acSBrian Foster */ 5121d34999c9SBrian Foster WARN_ON_ONCE(!temp || !temp2); 512230f712c9SDave Chinner xfs_bmbt_set_startblock(ep, nullstartblock((int)temp)); 512330f712c9SDave Chinner new.br_startblock = nullstartblock((int)temp2); 512430f712c9SDave Chinner } 512530f712c9SDave Chinner trace_xfs_bmap_post_update(ip, *idx, state, _THIS_IP_); 512630f712c9SDave Chinner xfs_iext_insert(ip, *idx + 1, 1, &new, state); 512730f712c9SDave Chinner ++*idx; 512830f712c9SDave Chinner break; 512930f712c9SDave Chinner } 51309c194644SDarrick J. Wong 51319c194644SDarrick J. Wong /* remove reverse mapping */ 51329c194644SDarrick J. Wong if (!delay) { 51339c194644SDarrick J. Wong error = xfs_rmap_unmap_extent(mp, dfops, ip, whichfork, del); 51349c194644SDarrick J. Wong if (error) 51359c194644SDarrick J. Wong goto done; 51369c194644SDarrick J. Wong } 51379c194644SDarrick J. Wong 513830f712c9SDave Chinner /* 513930f712c9SDave Chinner * If we need to, add to list of extents to delete. 514030f712c9SDave Chinner */ 51414847acf8SDarrick J. Wong if (do_fx && !(bflags & XFS_BMAPI_REMAP)) { 514262aab20fSDarrick J. Wong if (xfs_is_reflink_inode(ip) && whichfork == XFS_DATA_FORK) { 514362aab20fSDarrick J. Wong error = xfs_refcount_decrease_extent(mp, dfops, del); 514462aab20fSDarrick J. Wong if (error) 514562aab20fSDarrick J. Wong goto done; 514662aab20fSDarrick J. Wong } else 51472c3234d1SDarrick J. Wong xfs_bmap_add_free(mp, dfops, del->br_startblock, 5148340785ccSDarrick J. Wong del->br_blockcount, NULL); 514962aab20fSDarrick J. Wong } 515062aab20fSDarrick J. Wong 515130f712c9SDave Chinner /* 515230f712c9SDave Chinner * Adjust inode # blocks in the file. 515330f712c9SDave Chinner */ 515430f712c9SDave Chinner if (nblks) 515530f712c9SDave Chinner ip->i_d.di_nblocks -= nblks; 515630f712c9SDave Chinner /* 515730f712c9SDave Chinner * Adjust quota data. 515830f712c9SDave Chinner */ 51594847acf8SDarrick J. Wong if (qfield && !(bflags & XFS_BMAPI_REMAP)) 516030f712c9SDave Chinner xfs_trans_mod_dquot_byino(tp, ip, qfield, (long)-nblks); 516130f712c9SDave Chinner 516230f712c9SDave Chinner /* 516330f712c9SDave Chinner * Account for change in delayed indirect blocks. 516430f712c9SDave Chinner * Nothing to do for disk quota accounting here. 516530f712c9SDave Chinner */ 516630f712c9SDave Chinner ASSERT(da_old >= da_new); 51670d485adaSDave Chinner if (da_old > da_new) 51680d485adaSDave Chinner xfs_mod_fdblocks(mp, (int64_t)(da_old - da_new), false); 516930f712c9SDave Chinner done: 517030f712c9SDave Chinner *logflagsp = flags; 517130f712c9SDave Chinner return error; 517230f712c9SDave Chinner } 517330f712c9SDave Chinner 51744862cfe8SDarrick J. Wong /* Remove an extent from the CoW fork. Similar to xfs_bmap_del_extent. */ 51754862cfe8SDarrick J. Wong int 51764862cfe8SDarrick J. Wong xfs_bunmapi_cow( 51774862cfe8SDarrick J. Wong struct xfs_inode *ip, 51784862cfe8SDarrick J. Wong struct xfs_bmbt_irec *del) 51794862cfe8SDarrick J. Wong { 51804862cfe8SDarrick J. Wong xfs_filblks_t da_new; 51814862cfe8SDarrick J. Wong xfs_filblks_t da_old; 51824862cfe8SDarrick J. Wong xfs_fsblock_t del_endblock = 0; 51834862cfe8SDarrick J. Wong xfs_fileoff_t del_endoff; 51844862cfe8SDarrick J. Wong int delay; 51854862cfe8SDarrick J. Wong struct xfs_bmbt_rec_host *ep; 51864862cfe8SDarrick J. Wong int error; 51874862cfe8SDarrick J. Wong struct xfs_bmbt_irec got; 51884862cfe8SDarrick J. Wong xfs_fileoff_t got_endoff; 51894862cfe8SDarrick J. Wong struct xfs_ifork *ifp; 51904862cfe8SDarrick J. Wong struct xfs_mount *mp; 51914862cfe8SDarrick J. Wong xfs_filblks_t nblks; 51924862cfe8SDarrick J. Wong struct xfs_bmbt_irec new; 51934862cfe8SDarrick J. Wong /* REFERENCED */ 51944862cfe8SDarrick J. Wong uint qfield; 51954862cfe8SDarrick J. Wong xfs_filblks_t temp; 51964862cfe8SDarrick J. Wong xfs_filblks_t temp2; 51974862cfe8SDarrick J. Wong int state = BMAP_COWFORK; 51984862cfe8SDarrick J. Wong int eof; 51994862cfe8SDarrick J. Wong xfs_extnum_t eidx; 52004862cfe8SDarrick J. Wong 52014862cfe8SDarrick J. Wong mp = ip->i_mount; 52024862cfe8SDarrick J. Wong XFS_STATS_INC(mp, xs_del_exlist); 52034862cfe8SDarrick J. Wong 52044862cfe8SDarrick J. Wong ep = xfs_bmap_search_extents(ip, del->br_startoff, XFS_COW_FORK, &eof, 52054862cfe8SDarrick J. Wong &eidx, &got, &new); 52064862cfe8SDarrick J. Wong 52074862cfe8SDarrick J. Wong ifp = XFS_IFORK_PTR(ip, XFS_COW_FORK); ifp = ifp; 52084862cfe8SDarrick J. Wong ASSERT((eidx >= 0) && (eidx < ifp->if_bytes / 52094862cfe8SDarrick J. Wong (uint)sizeof(xfs_bmbt_rec_t))); 52104862cfe8SDarrick J. Wong ASSERT(del->br_blockcount > 0); 52114862cfe8SDarrick J. Wong ASSERT(got.br_startoff <= del->br_startoff); 52124862cfe8SDarrick J. Wong del_endoff = del->br_startoff + del->br_blockcount; 52134862cfe8SDarrick J. Wong got_endoff = got.br_startoff + got.br_blockcount; 52144862cfe8SDarrick J. Wong ASSERT(got_endoff >= del_endoff); 52154862cfe8SDarrick J. Wong delay = isnullstartblock(got.br_startblock); 52164862cfe8SDarrick J. Wong ASSERT(isnullstartblock(del->br_startblock) == delay); 52174862cfe8SDarrick J. Wong qfield = 0; 52184862cfe8SDarrick J. Wong error = 0; 52194862cfe8SDarrick J. Wong /* 52204862cfe8SDarrick J. Wong * If deleting a real allocation, must free up the disk space. 52214862cfe8SDarrick J. Wong */ 52224862cfe8SDarrick J. Wong if (!delay) { 52234862cfe8SDarrick J. Wong nblks = del->br_blockcount; 52244862cfe8SDarrick J. Wong qfield = XFS_TRANS_DQ_BCOUNT; 52254862cfe8SDarrick J. Wong /* 52264862cfe8SDarrick J. Wong * Set up del_endblock and cur for later. 52274862cfe8SDarrick J. Wong */ 52284862cfe8SDarrick J. Wong del_endblock = del->br_startblock + del->br_blockcount; 52294862cfe8SDarrick J. Wong da_old = da_new = 0; 52304862cfe8SDarrick J. Wong } else { 52314862cfe8SDarrick J. Wong da_old = startblockval(got.br_startblock); 52324862cfe8SDarrick J. Wong da_new = 0; 52334862cfe8SDarrick J. Wong nblks = 0; 52344862cfe8SDarrick J. Wong } 52354862cfe8SDarrick J. Wong qfield = qfield; 52364862cfe8SDarrick J. Wong nblks = nblks; 52374862cfe8SDarrick J. Wong 52384862cfe8SDarrick J. Wong /* 52394862cfe8SDarrick J. Wong * Set flag value to use in switch statement. 52404862cfe8SDarrick J. Wong * Left-contig is 2, right-contig is 1. 52414862cfe8SDarrick J. Wong */ 52424862cfe8SDarrick J. Wong switch (((got.br_startoff == del->br_startoff) << 1) | 52434862cfe8SDarrick J. Wong (got_endoff == del_endoff)) { 52444862cfe8SDarrick J. Wong case 3: 52454862cfe8SDarrick J. Wong /* 52464862cfe8SDarrick J. Wong * Matches the whole extent. Delete the entry. 52474862cfe8SDarrick J. Wong */ 52484862cfe8SDarrick J. Wong xfs_iext_remove(ip, eidx, 1, BMAP_COWFORK); 52494862cfe8SDarrick J. Wong --eidx; 52504862cfe8SDarrick J. Wong break; 52514862cfe8SDarrick J. Wong 52524862cfe8SDarrick J. Wong case 2: 52534862cfe8SDarrick J. Wong /* 52544862cfe8SDarrick J. Wong * Deleting the first part of the extent. 52554862cfe8SDarrick J. Wong */ 52564862cfe8SDarrick J. Wong trace_xfs_bmap_pre_update(ip, eidx, state, _THIS_IP_); 52574862cfe8SDarrick J. Wong xfs_bmbt_set_startoff(ep, del_endoff); 52584862cfe8SDarrick J. Wong temp = got.br_blockcount - del->br_blockcount; 52594862cfe8SDarrick J. Wong xfs_bmbt_set_blockcount(ep, temp); 52604862cfe8SDarrick J. Wong if (delay) { 52614862cfe8SDarrick J. Wong temp = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(ip, temp), 52624862cfe8SDarrick J. Wong da_old); 52634862cfe8SDarrick J. Wong xfs_bmbt_set_startblock(ep, nullstartblock((int)temp)); 52644862cfe8SDarrick J. Wong trace_xfs_bmap_post_update(ip, eidx, state, _THIS_IP_); 52654862cfe8SDarrick J. Wong da_new = temp; 52664862cfe8SDarrick J. Wong break; 52674862cfe8SDarrick J. Wong } 52684862cfe8SDarrick J. Wong xfs_bmbt_set_startblock(ep, del_endblock); 52694862cfe8SDarrick J. Wong trace_xfs_bmap_post_update(ip, eidx, state, _THIS_IP_); 52704862cfe8SDarrick J. Wong break; 52714862cfe8SDarrick J. Wong 52724862cfe8SDarrick J. Wong case 1: 52734862cfe8SDarrick J. Wong /* 52744862cfe8SDarrick J. Wong * Deleting the last part of the extent. 52754862cfe8SDarrick J. Wong */ 52764862cfe8SDarrick J. Wong temp = got.br_blockcount - del->br_blockcount; 52774862cfe8SDarrick J. Wong trace_xfs_bmap_pre_update(ip, eidx, state, _THIS_IP_); 52784862cfe8SDarrick J. Wong xfs_bmbt_set_blockcount(ep, temp); 52794862cfe8SDarrick J. Wong if (delay) { 52804862cfe8SDarrick J. Wong temp = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(ip, temp), 52814862cfe8SDarrick J. Wong da_old); 52824862cfe8SDarrick J. Wong xfs_bmbt_set_startblock(ep, nullstartblock((int)temp)); 52834862cfe8SDarrick J. Wong trace_xfs_bmap_post_update(ip, eidx, state, _THIS_IP_); 52844862cfe8SDarrick J. Wong da_new = temp; 52854862cfe8SDarrick J. Wong break; 52864862cfe8SDarrick J. Wong } 52874862cfe8SDarrick J. Wong trace_xfs_bmap_post_update(ip, eidx, state, _THIS_IP_); 52884862cfe8SDarrick J. Wong break; 52894862cfe8SDarrick J. Wong 52904862cfe8SDarrick J. Wong case 0: 52914862cfe8SDarrick J. Wong /* 52924862cfe8SDarrick J. Wong * Deleting the middle of the extent. 52934862cfe8SDarrick J. Wong */ 52944862cfe8SDarrick J. Wong temp = del->br_startoff - got.br_startoff; 52954862cfe8SDarrick J. Wong trace_xfs_bmap_pre_update(ip, eidx, state, _THIS_IP_); 52964862cfe8SDarrick J. Wong xfs_bmbt_set_blockcount(ep, temp); 52974862cfe8SDarrick J. Wong new.br_startoff = del_endoff; 52984862cfe8SDarrick J. Wong temp2 = got_endoff - del_endoff; 52994862cfe8SDarrick J. Wong new.br_blockcount = temp2; 53004862cfe8SDarrick J. Wong new.br_state = got.br_state; 53014862cfe8SDarrick J. Wong if (!delay) { 53024862cfe8SDarrick J. Wong new.br_startblock = del_endblock; 53034862cfe8SDarrick J. Wong } else { 53044862cfe8SDarrick J. Wong temp = xfs_bmap_worst_indlen(ip, temp); 53054862cfe8SDarrick J. Wong xfs_bmbt_set_startblock(ep, nullstartblock((int)temp)); 53064862cfe8SDarrick J. Wong temp2 = xfs_bmap_worst_indlen(ip, temp2); 53074862cfe8SDarrick J. Wong new.br_startblock = nullstartblock((int)temp2); 53084862cfe8SDarrick J. Wong da_new = temp + temp2; 53094862cfe8SDarrick J. Wong while (da_new > da_old) { 53104862cfe8SDarrick J. Wong if (temp) { 53114862cfe8SDarrick J. Wong temp--; 53124862cfe8SDarrick J. Wong da_new--; 53134862cfe8SDarrick J. Wong xfs_bmbt_set_startblock(ep, 53144862cfe8SDarrick J. Wong nullstartblock((int)temp)); 53154862cfe8SDarrick J. Wong } 53164862cfe8SDarrick J. Wong if (da_new == da_old) 53174862cfe8SDarrick J. Wong break; 53184862cfe8SDarrick J. Wong if (temp2) { 53194862cfe8SDarrick J. Wong temp2--; 53204862cfe8SDarrick J. Wong da_new--; 53214862cfe8SDarrick J. Wong new.br_startblock = 53224862cfe8SDarrick J. Wong nullstartblock((int)temp2); 53234862cfe8SDarrick J. Wong } 53244862cfe8SDarrick J. Wong } 53254862cfe8SDarrick J. Wong } 53264862cfe8SDarrick J. Wong trace_xfs_bmap_post_update(ip, eidx, state, _THIS_IP_); 53274862cfe8SDarrick J. Wong xfs_iext_insert(ip, eidx + 1, 1, &new, state); 53284862cfe8SDarrick J. Wong ++eidx; 53294862cfe8SDarrick J. Wong break; 53304862cfe8SDarrick J. Wong } 53314862cfe8SDarrick J. Wong 53324862cfe8SDarrick J. Wong /* 53334862cfe8SDarrick J. Wong * Account for change in delayed indirect blocks. 53344862cfe8SDarrick J. Wong * Nothing to do for disk quota accounting here. 53354862cfe8SDarrick J. Wong */ 53364862cfe8SDarrick J. Wong ASSERT(da_old >= da_new); 53374862cfe8SDarrick J. Wong if (da_old > da_new) 53384862cfe8SDarrick J. Wong xfs_mod_fdblocks(mp, (int64_t)(da_old - da_new), false); 53394862cfe8SDarrick J. Wong 53404862cfe8SDarrick J. Wong return error; 53414862cfe8SDarrick J. Wong } 53424862cfe8SDarrick J. Wong 534330f712c9SDave Chinner /* 534430f712c9SDave Chinner * Unmap (remove) blocks from a file. 534530f712c9SDave Chinner * If nexts is nonzero then the number of extents to remove is limited to 534630f712c9SDave Chinner * that value. If not all extents in the block range can be removed then 534730f712c9SDave Chinner * *done is set. 534830f712c9SDave Chinner */ 534930f712c9SDave Chinner int /* error */ 53504453593bSDarrick J. Wong __xfs_bunmapi( 535130f712c9SDave Chinner xfs_trans_t *tp, /* transaction pointer */ 535230f712c9SDave Chinner struct xfs_inode *ip, /* incore inode */ 535330f712c9SDave Chinner xfs_fileoff_t bno, /* starting offset to unmap */ 53544453593bSDarrick J. Wong xfs_filblks_t *rlen, /* i/o: amount remaining */ 535530f712c9SDave Chinner int flags, /* misc flags */ 535630f712c9SDave Chinner xfs_extnum_t nexts, /* number of extents max */ 535730f712c9SDave Chinner xfs_fsblock_t *firstblock, /* first allocated block 535830f712c9SDave Chinner controls a.g. for allocs */ 53594453593bSDarrick J. Wong struct xfs_defer_ops *dfops) /* i/o: deferred updates */ 536030f712c9SDave Chinner { 536130f712c9SDave Chinner xfs_btree_cur_t *cur; /* bmap btree cursor */ 536230f712c9SDave Chinner xfs_bmbt_irec_t del; /* extent being deleted */ 536330f712c9SDave Chinner int eof; /* is deleting at eof */ 536430f712c9SDave Chinner xfs_bmbt_rec_host_t *ep; /* extent record pointer */ 536530f712c9SDave Chinner int error; /* error return value */ 536630f712c9SDave Chinner xfs_extnum_t extno; /* extent number in list */ 536730f712c9SDave Chinner xfs_bmbt_irec_t got; /* current extent record */ 536830f712c9SDave Chinner xfs_ifork_t *ifp; /* inode fork pointer */ 536930f712c9SDave Chinner int isrt; /* freeing in rt area */ 537030f712c9SDave Chinner xfs_extnum_t lastx; /* last extent index used */ 537130f712c9SDave Chinner int logflags; /* transaction logging flags */ 537230f712c9SDave Chinner xfs_extlen_t mod; /* rt extent offset */ 537330f712c9SDave Chinner xfs_mount_t *mp; /* mount structure */ 537430f712c9SDave Chinner xfs_extnum_t nextents; /* number of file extents */ 537530f712c9SDave Chinner xfs_bmbt_irec_t prev; /* previous extent record */ 537630f712c9SDave Chinner xfs_fileoff_t start; /* first file offset deleted */ 537730f712c9SDave Chinner int tmp_logflags; /* partial logging flags */ 537830f712c9SDave Chinner int wasdel; /* was a delayed alloc extent */ 537930f712c9SDave Chinner int whichfork; /* data or attribute fork */ 538030f712c9SDave Chinner xfs_fsblock_t sum; 53814453593bSDarrick J. Wong xfs_filblks_t len = *rlen; /* length to unmap in file */ 538230f712c9SDave Chinner 538330f712c9SDave Chinner trace_xfs_bunmap(ip, bno, len, flags, _RET_IP_); 538430f712c9SDave Chinner 53853993baebSDarrick J. Wong whichfork = xfs_bmapi_whichfork(flags); 53863993baebSDarrick J. Wong ASSERT(whichfork != XFS_COW_FORK); 538730f712c9SDave Chinner ifp = XFS_IFORK_PTR(ip, whichfork); 538830f712c9SDave Chinner if (unlikely( 538930f712c9SDave Chinner XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS && 539030f712c9SDave Chinner XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE)) { 539130f712c9SDave Chinner XFS_ERROR_REPORT("xfs_bunmapi", XFS_ERRLEVEL_LOW, 539230f712c9SDave Chinner ip->i_mount); 53932451337dSDave Chinner return -EFSCORRUPTED; 539430f712c9SDave Chinner } 539530f712c9SDave Chinner mp = ip->i_mount; 539630f712c9SDave Chinner if (XFS_FORCED_SHUTDOWN(mp)) 53972451337dSDave Chinner return -EIO; 539830f712c9SDave Chinner 539930f712c9SDave Chinner ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL)); 540030f712c9SDave Chinner ASSERT(len > 0); 540130f712c9SDave Chinner ASSERT(nexts >= 0); 540230f712c9SDave Chinner 540330f712c9SDave Chinner if (!(ifp->if_flags & XFS_IFEXTENTS) && 540430f712c9SDave Chinner (error = xfs_iread_extents(tp, ip, whichfork))) 540530f712c9SDave Chinner return error; 540630f712c9SDave Chinner nextents = ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t); 540730f712c9SDave Chinner if (nextents == 0) { 54084453593bSDarrick J. Wong *rlen = 0; 540930f712c9SDave Chinner return 0; 541030f712c9SDave Chinner } 5411ff6d6af2SBill O'Donnell XFS_STATS_INC(mp, xs_blk_unmap); 541230f712c9SDave Chinner isrt = (whichfork == XFS_DATA_FORK) && XFS_IS_REALTIME_INODE(ip); 541330f712c9SDave Chinner start = bno; 541430f712c9SDave Chinner bno = start + len - 1; 541530f712c9SDave Chinner ep = xfs_bmap_search_extents(ip, bno, whichfork, &eof, &lastx, &got, 541630f712c9SDave Chinner &prev); 541730f712c9SDave Chinner 541830f712c9SDave Chinner /* 541930f712c9SDave Chinner * Check to see if the given block number is past the end of the 542030f712c9SDave Chinner * file, back up to the last block if so... 542130f712c9SDave Chinner */ 542230f712c9SDave Chinner if (eof) { 542330f712c9SDave Chinner ep = xfs_iext_get_ext(ifp, --lastx); 542430f712c9SDave Chinner xfs_bmbt_get_all(ep, &got); 542530f712c9SDave Chinner bno = got.br_startoff + got.br_blockcount - 1; 542630f712c9SDave Chinner } 542730f712c9SDave Chinner logflags = 0; 542830f712c9SDave Chinner if (ifp->if_flags & XFS_IFBROOT) { 542930f712c9SDave Chinner ASSERT(XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_BTREE); 543030f712c9SDave Chinner cur = xfs_bmbt_init_cursor(mp, tp, ip, whichfork); 543130f712c9SDave Chinner cur->bc_private.b.firstblock = *firstblock; 54322c3234d1SDarrick J. Wong cur->bc_private.b.dfops = dfops; 543330f712c9SDave Chinner cur->bc_private.b.flags = 0; 543430f712c9SDave Chinner } else 543530f712c9SDave Chinner cur = NULL; 543630f712c9SDave Chinner 543730f712c9SDave Chinner if (isrt) { 543830f712c9SDave Chinner /* 543930f712c9SDave Chinner * Synchronize by locking the bitmap inode. 544030f712c9SDave Chinner */ 5441f4a0660dSDarrick J. Wong xfs_ilock(mp->m_rbmip, XFS_ILOCK_EXCL|XFS_ILOCK_RTBITMAP); 544230f712c9SDave Chinner xfs_trans_ijoin(tp, mp->m_rbmip, XFS_ILOCK_EXCL); 5443f4a0660dSDarrick J. Wong xfs_ilock(mp->m_rsumip, XFS_ILOCK_EXCL|XFS_ILOCK_RTSUM); 5444f4a0660dSDarrick J. Wong xfs_trans_ijoin(tp, mp->m_rsumip, XFS_ILOCK_EXCL); 544530f712c9SDave Chinner } 544630f712c9SDave Chinner 544730f712c9SDave Chinner extno = 0; 544830f712c9SDave Chinner while (bno != (xfs_fileoff_t)-1 && bno >= start && lastx >= 0 && 544930f712c9SDave Chinner (nexts == 0 || extno < nexts)) { 545030f712c9SDave Chinner /* 545130f712c9SDave Chinner * Is the found extent after a hole in which bno lives? 545230f712c9SDave Chinner * Just back up to the previous extent, if so. 545330f712c9SDave Chinner */ 545430f712c9SDave Chinner if (got.br_startoff > bno) { 545530f712c9SDave Chinner if (--lastx < 0) 545630f712c9SDave Chinner break; 545730f712c9SDave Chinner ep = xfs_iext_get_ext(ifp, lastx); 545830f712c9SDave Chinner xfs_bmbt_get_all(ep, &got); 545930f712c9SDave Chinner } 546030f712c9SDave Chinner /* 546130f712c9SDave Chinner * Is the last block of this extent before the range 546230f712c9SDave Chinner * we're supposed to delete? If so, we're done. 546330f712c9SDave Chinner */ 546430f712c9SDave Chinner bno = XFS_FILEOFF_MIN(bno, 546530f712c9SDave Chinner got.br_startoff + got.br_blockcount - 1); 546630f712c9SDave Chinner if (bno < start) 546730f712c9SDave Chinner break; 546830f712c9SDave Chinner /* 546930f712c9SDave Chinner * Then deal with the (possibly delayed) allocated space 547030f712c9SDave Chinner * we found. 547130f712c9SDave Chinner */ 547230f712c9SDave Chinner ASSERT(ep != NULL); 547330f712c9SDave Chinner del = got; 547430f712c9SDave Chinner wasdel = isnullstartblock(del.br_startblock); 547530f712c9SDave Chinner if (got.br_startoff < start) { 547630f712c9SDave Chinner del.br_startoff = start; 547730f712c9SDave Chinner del.br_blockcount -= start - got.br_startoff; 547830f712c9SDave Chinner if (!wasdel) 547930f712c9SDave Chinner del.br_startblock += start - got.br_startoff; 548030f712c9SDave Chinner } 548130f712c9SDave Chinner if (del.br_startoff + del.br_blockcount > bno + 1) 548230f712c9SDave Chinner del.br_blockcount = bno + 1 - del.br_startoff; 548330f712c9SDave Chinner sum = del.br_startblock + del.br_blockcount; 548430f712c9SDave Chinner if (isrt && 548530f712c9SDave Chinner (mod = do_mod(sum, mp->m_sb.sb_rextsize))) { 548630f712c9SDave Chinner /* 548730f712c9SDave Chinner * Realtime extent not lined up at the end. 548830f712c9SDave Chinner * The extent could have been split into written 548930f712c9SDave Chinner * and unwritten pieces, or we could just be 549030f712c9SDave Chinner * unmapping part of it. But we can't really 549130f712c9SDave Chinner * get rid of part of a realtime extent. 549230f712c9SDave Chinner */ 549330f712c9SDave Chinner if (del.br_state == XFS_EXT_UNWRITTEN || 549430f712c9SDave Chinner !xfs_sb_version_hasextflgbit(&mp->m_sb)) { 549530f712c9SDave Chinner /* 549630f712c9SDave Chinner * This piece is unwritten, or we're not 549730f712c9SDave Chinner * using unwritten extents. Skip over it. 549830f712c9SDave Chinner */ 549930f712c9SDave Chinner ASSERT(bno >= mod); 550030f712c9SDave Chinner bno -= mod > del.br_blockcount ? 550130f712c9SDave Chinner del.br_blockcount : mod; 550230f712c9SDave Chinner if (bno < got.br_startoff) { 550330f712c9SDave Chinner if (--lastx >= 0) 550430f712c9SDave Chinner xfs_bmbt_get_all(xfs_iext_get_ext( 550530f712c9SDave Chinner ifp, lastx), &got); 550630f712c9SDave Chinner } 550730f712c9SDave Chinner continue; 550830f712c9SDave Chinner } 550930f712c9SDave Chinner /* 551030f712c9SDave Chinner * It's written, turn it unwritten. 551130f712c9SDave Chinner * This is better than zeroing it. 551230f712c9SDave Chinner */ 551330f712c9SDave Chinner ASSERT(del.br_state == XFS_EXT_NORM); 5514a7e5d03bSChristoph Hellwig ASSERT(tp->t_blk_res > 0); 551530f712c9SDave Chinner /* 551630f712c9SDave Chinner * If this spans a realtime extent boundary, 551730f712c9SDave Chinner * chop it back to the start of the one we end at. 551830f712c9SDave Chinner */ 551930f712c9SDave Chinner if (del.br_blockcount > mod) { 552030f712c9SDave Chinner del.br_startoff += del.br_blockcount - mod; 552130f712c9SDave Chinner del.br_startblock += del.br_blockcount - mod; 552230f712c9SDave Chinner del.br_blockcount = mod; 552330f712c9SDave Chinner } 552430f712c9SDave Chinner del.br_state = XFS_EXT_UNWRITTEN; 552530f712c9SDave Chinner error = xfs_bmap_add_extent_unwritten_real(tp, ip, 55262c3234d1SDarrick J. Wong &lastx, &cur, &del, firstblock, dfops, 552730f712c9SDave Chinner &logflags); 552830f712c9SDave Chinner if (error) 552930f712c9SDave Chinner goto error0; 553030f712c9SDave Chinner goto nodelete; 553130f712c9SDave Chinner } 553230f712c9SDave Chinner if (isrt && (mod = do_mod(del.br_startblock, mp->m_sb.sb_rextsize))) { 553330f712c9SDave Chinner /* 553430f712c9SDave Chinner * Realtime extent is lined up at the end but not 553530f712c9SDave Chinner * at the front. We'll get rid of full extents if 553630f712c9SDave Chinner * we can. 553730f712c9SDave Chinner */ 553830f712c9SDave Chinner mod = mp->m_sb.sb_rextsize - mod; 553930f712c9SDave Chinner if (del.br_blockcount > mod) { 554030f712c9SDave Chinner del.br_blockcount -= mod; 554130f712c9SDave Chinner del.br_startoff += mod; 554230f712c9SDave Chinner del.br_startblock += mod; 554330f712c9SDave Chinner } else if ((del.br_startoff == start && 554430f712c9SDave Chinner (del.br_state == XFS_EXT_UNWRITTEN || 5545a7e5d03bSChristoph Hellwig tp->t_blk_res == 0)) || 554630f712c9SDave Chinner !xfs_sb_version_hasextflgbit(&mp->m_sb)) { 554730f712c9SDave Chinner /* 554830f712c9SDave Chinner * Can't make it unwritten. There isn't 554930f712c9SDave Chinner * a full extent here so just skip it. 555030f712c9SDave Chinner */ 555130f712c9SDave Chinner ASSERT(bno >= del.br_blockcount); 555230f712c9SDave Chinner bno -= del.br_blockcount; 555330f712c9SDave Chinner if (got.br_startoff > bno) { 555430f712c9SDave Chinner if (--lastx >= 0) { 555530f712c9SDave Chinner ep = xfs_iext_get_ext(ifp, 555630f712c9SDave Chinner lastx); 555730f712c9SDave Chinner xfs_bmbt_get_all(ep, &got); 555830f712c9SDave Chinner } 555930f712c9SDave Chinner } 556030f712c9SDave Chinner continue; 556130f712c9SDave Chinner } else if (del.br_state == XFS_EXT_UNWRITTEN) { 556230f712c9SDave Chinner /* 556330f712c9SDave Chinner * This one is already unwritten. 556430f712c9SDave Chinner * It must have a written left neighbor. 556530f712c9SDave Chinner * Unwrite the killed part of that one and 556630f712c9SDave Chinner * try again. 556730f712c9SDave Chinner */ 556830f712c9SDave Chinner ASSERT(lastx > 0); 556930f712c9SDave Chinner xfs_bmbt_get_all(xfs_iext_get_ext(ifp, 557030f712c9SDave Chinner lastx - 1), &prev); 557130f712c9SDave Chinner ASSERT(prev.br_state == XFS_EXT_NORM); 557230f712c9SDave Chinner ASSERT(!isnullstartblock(prev.br_startblock)); 557330f712c9SDave Chinner ASSERT(del.br_startblock == 557430f712c9SDave Chinner prev.br_startblock + prev.br_blockcount); 557530f712c9SDave Chinner if (prev.br_startoff < start) { 557630f712c9SDave Chinner mod = start - prev.br_startoff; 557730f712c9SDave Chinner prev.br_blockcount -= mod; 557830f712c9SDave Chinner prev.br_startblock += mod; 557930f712c9SDave Chinner prev.br_startoff = start; 558030f712c9SDave Chinner } 558130f712c9SDave Chinner prev.br_state = XFS_EXT_UNWRITTEN; 558230f712c9SDave Chinner lastx--; 558330f712c9SDave Chinner error = xfs_bmap_add_extent_unwritten_real(tp, 558430f712c9SDave Chinner ip, &lastx, &cur, &prev, 55852c3234d1SDarrick J. Wong firstblock, dfops, &logflags); 558630f712c9SDave Chinner if (error) 558730f712c9SDave Chinner goto error0; 558830f712c9SDave Chinner goto nodelete; 558930f712c9SDave Chinner } else { 559030f712c9SDave Chinner ASSERT(del.br_state == XFS_EXT_NORM); 559130f712c9SDave Chinner del.br_state = XFS_EXT_UNWRITTEN; 559230f712c9SDave Chinner error = xfs_bmap_add_extent_unwritten_real(tp, 559330f712c9SDave Chinner ip, &lastx, &cur, &del, 55942c3234d1SDarrick J. Wong firstblock, dfops, &logflags); 559530f712c9SDave Chinner if (error) 559630f712c9SDave Chinner goto error0; 559730f712c9SDave Chinner goto nodelete; 559830f712c9SDave Chinner } 559930f712c9SDave Chinner } 560030f712c9SDave Chinner 560130f712c9SDave Chinner /* 560230f712c9SDave Chinner * If it's the case where the directory code is running 560330f712c9SDave Chinner * with no block reservation, and the deleted block is in 560430f712c9SDave Chinner * the middle of its extent, and the resulting insert 560530f712c9SDave Chinner * of an extent would cause transformation to btree format, 560630f712c9SDave Chinner * then reject it. The calling code will then swap 560730f712c9SDave Chinner * blocks around instead. 560830f712c9SDave Chinner * We have to do this now, rather than waiting for the 560930f712c9SDave Chinner * conversion to btree format, since the transaction 561030f712c9SDave Chinner * will be dirty. 561130f712c9SDave Chinner */ 5612a7e5d03bSChristoph Hellwig if (!wasdel && tp->t_blk_res == 0 && 561330f712c9SDave Chinner XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_EXTENTS && 561430f712c9SDave Chinner XFS_IFORK_NEXTENTS(ip, whichfork) >= /* Note the >= */ 561530f712c9SDave Chinner XFS_IFORK_MAXEXT(ip, whichfork) && 561630f712c9SDave Chinner del.br_startoff > got.br_startoff && 561730f712c9SDave Chinner del.br_startoff + del.br_blockcount < 561830f712c9SDave Chinner got.br_startoff + got.br_blockcount) { 56192451337dSDave Chinner error = -ENOSPC; 562030f712c9SDave Chinner goto error0; 562130f712c9SDave Chinner } 5622b2706a05SBrian Foster 5623b2706a05SBrian Foster /* 5624b2706a05SBrian Foster * Unreserve quota and update realtime free space, if 5625b2706a05SBrian Foster * appropriate. If delayed allocation, update the inode delalloc 5626b2706a05SBrian Foster * counter now and wait to update the sb counters as 5627b2706a05SBrian Foster * xfs_bmap_del_extent() might need to borrow some blocks. 5628b2706a05SBrian Foster */ 5629b2706a05SBrian Foster if (wasdel) { 5630b2706a05SBrian Foster ASSERT(startblockval(del.br_startblock) > 0); 5631b2706a05SBrian Foster if (isrt) { 5632b2706a05SBrian Foster xfs_filblks_t rtexts; 5633b2706a05SBrian Foster 5634b2706a05SBrian Foster rtexts = XFS_FSB_TO_B(mp, del.br_blockcount); 5635b2706a05SBrian Foster do_div(rtexts, mp->m_sb.sb_rextsize); 5636b2706a05SBrian Foster xfs_mod_frextents(mp, (int64_t)rtexts); 5637b2706a05SBrian Foster (void)xfs_trans_reserve_quota_nblks(NULL, 5638b2706a05SBrian Foster ip, -((long)del.br_blockcount), 0, 5639b2706a05SBrian Foster XFS_QMOPT_RES_RTBLKS); 5640b2706a05SBrian Foster } else { 5641b2706a05SBrian Foster (void)xfs_trans_reserve_quota_nblks(NULL, 5642b2706a05SBrian Foster ip, -((long)del.br_blockcount), 0, 5643b2706a05SBrian Foster XFS_QMOPT_RES_REGBLKS); 5644b2706a05SBrian Foster } 5645b2706a05SBrian Foster ip->i_delayed_blks -= del.br_blockcount; 5646b2706a05SBrian Foster if (cur) 5647b2706a05SBrian Foster cur->bc_private.b.flags |= 5648b2706a05SBrian Foster XFS_BTCUR_BPRV_WASDEL; 5649b2706a05SBrian Foster } else if (cur) 5650b2706a05SBrian Foster cur->bc_private.b.flags &= ~XFS_BTCUR_BPRV_WASDEL; 5651b2706a05SBrian Foster 56522c3234d1SDarrick J. Wong error = xfs_bmap_del_extent(ip, tp, &lastx, dfops, cur, &del, 56534847acf8SDarrick J. Wong &tmp_logflags, whichfork, flags); 565430f712c9SDave Chinner logflags |= tmp_logflags; 565530f712c9SDave Chinner if (error) 565630f712c9SDave Chinner goto error0; 5657b2706a05SBrian Foster 5658b2706a05SBrian Foster if (!isrt && wasdel) 5659b2706a05SBrian Foster xfs_mod_fdblocks(mp, (int64_t)del.br_blockcount, false); 5660b2706a05SBrian Foster 566130f712c9SDave Chinner bno = del.br_startoff - 1; 566230f712c9SDave Chinner nodelete: 566330f712c9SDave Chinner /* 566430f712c9SDave Chinner * If not done go on to the next (previous) record. 566530f712c9SDave Chinner */ 566630f712c9SDave Chinner if (bno != (xfs_fileoff_t)-1 && bno >= start) { 566730f712c9SDave Chinner if (lastx >= 0) { 566830f712c9SDave Chinner ep = xfs_iext_get_ext(ifp, lastx); 566930f712c9SDave Chinner if (xfs_bmbt_get_startoff(ep) > bno) { 567030f712c9SDave Chinner if (--lastx >= 0) 567130f712c9SDave Chinner ep = xfs_iext_get_ext(ifp, 567230f712c9SDave Chinner lastx); 567330f712c9SDave Chinner } 567430f712c9SDave Chinner xfs_bmbt_get_all(ep, &got); 567530f712c9SDave Chinner } 567630f712c9SDave Chinner extno++; 567730f712c9SDave Chinner } 567830f712c9SDave Chinner } 56794453593bSDarrick J. Wong if (bno == (xfs_fileoff_t)-1 || bno < start || lastx < 0) 56804453593bSDarrick J. Wong *rlen = 0; 56814453593bSDarrick J. Wong else 56824453593bSDarrick J. Wong *rlen = bno - start + 1; 568330f712c9SDave Chinner 568430f712c9SDave Chinner /* 568530f712c9SDave Chinner * Convert to a btree if necessary. 568630f712c9SDave Chinner */ 568730f712c9SDave Chinner if (xfs_bmap_needs_btree(ip, whichfork)) { 568830f712c9SDave Chinner ASSERT(cur == NULL); 56892c3234d1SDarrick J. Wong error = xfs_bmap_extents_to_btree(tp, ip, firstblock, dfops, 569030f712c9SDave Chinner &cur, 0, &tmp_logflags, whichfork); 569130f712c9SDave Chinner logflags |= tmp_logflags; 569230f712c9SDave Chinner if (error) 569330f712c9SDave Chinner goto error0; 569430f712c9SDave Chinner } 569530f712c9SDave Chinner /* 569630f712c9SDave Chinner * transform from btree to extents, give it cur 569730f712c9SDave Chinner */ 569830f712c9SDave Chinner else if (xfs_bmap_wants_extents(ip, whichfork)) { 569930f712c9SDave Chinner ASSERT(cur != NULL); 570030f712c9SDave Chinner error = xfs_bmap_btree_to_extents(tp, ip, cur, &tmp_logflags, 570130f712c9SDave Chinner whichfork); 570230f712c9SDave Chinner logflags |= tmp_logflags; 570330f712c9SDave Chinner if (error) 570430f712c9SDave Chinner goto error0; 570530f712c9SDave Chinner } 570630f712c9SDave Chinner /* 570730f712c9SDave Chinner * transform from extents to local? 570830f712c9SDave Chinner */ 570930f712c9SDave Chinner error = 0; 571030f712c9SDave Chinner error0: 571130f712c9SDave Chinner /* 571230f712c9SDave Chinner * Log everything. Do this after conversion, there's no point in 571330f712c9SDave Chinner * logging the extent records if we've converted to btree format. 571430f712c9SDave Chinner */ 571530f712c9SDave Chinner if ((logflags & xfs_ilog_fext(whichfork)) && 571630f712c9SDave Chinner XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS) 571730f712c9SDave Chinner logflags &= ~xfs_ilog_fext(whichfork); 571830f712c9SDave Chinner else if ((logflags & xfs_ilog_fbroot(whichfork)) && 571930f712c9SDave Chinner XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE) 572030f712c9SDave Chinner logflags &= ~xfs_ilog_fbroot(whichfork); 572130f712c9SDave Chinner /* 572230f712c9SDave Chinner * Log inode even in the error case, if the transaction 572330f712c9SDave Chinner * is dirty we'll need to shut down the filesystem. 572430f712c9SDave Chinner */ 572530f712c9SDave Chinner if (logflags) 572630f712c9SDave Chinner xfs_trans_log_inode(tp, ip, logflags); 572730f712c9SDave Chinner if (cur) { 572830f712c9SDave Chinner if (!error) { 572930f712c9SDave Chinner *firstblock = cur->bc_private.b.firstblock; 573030f712c9SDave Chinner cur->bc_private.b.allocated = 0; 573130f712c9SDave Chinner } 573230f712c9SDave Chinner xfs_btree_del_cursor(cur, 573330f712c9SDave Chinner error ? XFS_BTREE_ERROR : XFS_BTREE_NOERROR); 573430f712c9SDave Chinner } 573530f712c9SDave Chinner return error; 573630f712c9SDave Chinner } 573730f712c9SDave Chinner 57384453593bSDarrick J. Wong /* Unmap a range of a file. */ 57394453593bSDarrick J. Wong int 57404453593bSDarrick J. Wong xfs_bunmapi( 57414453593bSDarrick J. Wong xfs_trans_t *tp, 57424453593bSDarrick J. Wong struct xfs_inode *ip, 57434453593bSDarrick J. Wong xfs_fileoff_t bno, 57444453593bSDarrick J. Wong xfs_filblks_t len, 57454453593bSDarrick J. Wong int flags, 57464453593bSDarrick J. Wong xfs_extnum_t nexts, 57474453593bSDarrick J. Wong xfs_fsblock_t *firstblock, 57484453593bSDarrick J. Wong struct xfs_defer_ops *dfops, 57494453593bSDarrick J. Wong int *done) 57504453593bSDarrick J. Wong { 57514453593bSDarrick J. Wong int error; 57524453593bSDarrick J. Wong 57534453593bSDarrick J. Wong error = __xfs_bunmapi(tp, ip, bno, &len, flags, nexts, firstblock, 57544453593bSDarrick J. Wong dfops); 57554453593bSDarrick J. Wong *done = (len == 0); 57564453593bSDarrick J. Wong return error; 57574453593bSDarrick J. Wong } 57584453593bSDarrick J. Wong 575930f712c9SDave Chinner /* 5760ddb19e31SBrian Foster * Determine whether an extent shift can be accomplished by a merge with the 5761ddb19e31SBrian Foster * extent that precedes the target hole of the shift. 5762ddb19e31SBrian Foster */ 5763ddb19e31SBrian Foster STATIC bool 5764ddb19e31SBrian Foster xfs_bmse_can_merge( 5765ddb19e31SBrian Foster struct xfs_bmbt_irec *left, /* preceding extent */ 5766ddb19e31SBrian Foster struct xfs_bmbt_irec *got, /* current extent to shift */ 5767ddb19e31SBrian Foster xfs_fileoff_t shift) /* shift fsb */ 5768ddb19e31SBrian Foster { 5769ddb19e31SBrian Foster xfs_fileoff_t startoff; 5770ddb19e31SBrian Foster 5771ddb19e31SBrian Foster startoff = got->br_startoff - shift; 5772ddb19e31SBrian Foster 5773ddb19e31SBrian Foster /* 5774ddb19e31SBrian Foster * The extent, once shifted, must be adjacent in-file and on-disk with 5775ddb19e31SBrian Foster * the preceding extent. 5776ddb19e31SBrian Foster */ 5777ddb19e31SBrian Foster if ((left->br_startoff + left->br_blockcount != startoff) || 5778ddb19e31SBrian Foster (left->br_startblock + left->br_blockcount != got->br_startblock) || 5779ddb19e31SBrian Foster (left->br_state != got->br_state) || 5780ddb19e31SBrian Foster (left->br_blockcount + got->br_blockcount > MAXEXTLEN)) 5781ddb19e31SBrian Foster return false; 5782ddb19e31SBrian Foster 5783ddb19e31SBrian Foster return true; 5784ddb19e31SBrian Foster } 5785ddb19e31SBrian Foster 5786ddb19e31SBrian Foster /* 5787ddb19e31SBrian Foster * A bmap extent shift adjusts the file offset of an extent to fill a preceding 5788ddb19e31SBrian Foster * hole in the file. If an extent shift would result in the extent being fully 5789ddb19e31SBrian Foster * adjacent to the extent that currently precedes the hole, we can merge with 5790ddb19e31SBrian Foster * the preceding extent rather than do the shift. 5791ddb19e31SBrian Foster * 5792ddb19e31SBrian Foster * This function assumes the caller has verified a shift-by-merge is possible 5793ddb19e31SBrian Foster * with the provided extents via xfs_bmse_can_merge(). 5794ddb19e31SBrian Foster */ 5795ddb19e31SBrian Foster STATIC int 5796ddb19e31SBrian Foster xfs_bmse_merge( 5797ddb19e31SBrian Foster struct xfs_inode *ip, 5798ddb19e31SBrian Foster int whichfork, 5799ddb19e31SBrian Foster xfs_fileoff_t shift, /* shift fsb */ 5800ddb19e31SBrian Foster int current_ext, /* idx of gotp */ 5801ddb19e31SBrian Foster struct xfs_bmbt_rec_host *gotp, /* extent to shift */ 5802ddb19e31SBrian Foster struct xfs_bmbt_rec_host *leftp, /* preceding extent */ 5803ddb19e31SBrian Foster struct xfs_btree_cur *cur, 5804ddb19e31SBrian Foster int *logflags) /* output */ 5805ddb19e31SBrian Foster { 5806ddb19e31SBrian Foster struct xfs_bmbt_irec got; 5807ddb19e31SBrian Foster struct xfs_bmbt_irec left; 5808ddb19e31SBrian Foster xfs_filblks_t blockcount; 5809ddb19e31SBrian Foster int error, i; 58105fb5aeeeSEric Sandeen struct xfs_mount *mp = ip->i_mount; 5811ddb19e31SBrian Foster 5812ddb19e31SBrian Foster xfs_bmbt_get_all(gotp, &got); 5813ddb19e31SBrian Foster xfs_bmbt_get_all(leftp, &left); 5814ddb19e31SBrian Foster blockcount = left.br_blockcount + got.br_blockcount; 5815ddb19e31SBrian Foster 5816ddb19e31SBrian Foster ASSERT(xfs_isilocked(ip, XFS_IOLOCK_EXCL)); 5817ddb19e31SBrian Foster ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL)); 5818ddb19e31SBrian Foster ASSERT(xfs_bmse_can_merge(&left, &got, shift)); 5819ddb19e31SBrian Foster 5820ddb19e31SBrian Foster /* 5821ddb19e31SBrian Foster * Merge the in-core extents. Note that the host record pointers and 5822ddb19e31SBrian Foster * current_ext index are invalid once the extent has been removed via 5823ddb19e31SBrian Foster * xfs_iext_remove(). 5824ddb19e31SBrian Foster */ 5825ddb19e31SBrian Foster xfs_bmbt_set_blockcount(leftp, blockcount); 5826ddb19e31SBrian Foster xfs_iext_remove(ip, current_ext, 1, 0); 5827ddb19e31SBrian Foster 5828ddb19e31SBrian Foster /* 5829ddb19e31SBrian Foster * Update the on-disk extent count, the btree if necessary and log the 5830ddb19e31SBrian Foster * inode. 5831ddb19e31SBrian Foster */ 5832ddb19e31SBrian Foster XFS_IFORK_NEXT_SET(ip, whichfork, 5833ddb19e31SBrian Foster XFS_IFORK_NEXTENTS(ip, whichfork) - 1); 5834ddb19e31SBrian Foster *logflags |= XFS_ILOG_CORE; 5835ddb19e31SBrian Foster if (!cur) { 5836ddb19e31SBrian Foster *logflags |= XFS_ILOG_DEXT; 5837ddb19e31SBrian Foster return 0; 5838ddb19e31SBrian Foster } 5839ddb19e31SBrian Foster 5840ddb19e31SBrian Foster /* lookup and remove the extent to merge */ 5841ddb19e31SBrian Foster error = xfs_bmbt_lookup_eq(cur, got.br_startoff, got.br_startblock, 5842ddb19e31SBrian Foster got.br_blockcount, &i); 5843ddb19e31SBrian Foster if (error) 58444db431f5SDave Chinner return error; 58455fb5aeeeSEric Sandeen XFS_WANT_CORRUPTED_RETURN(mp, i == 1); 5846ddb19e31SBrian Foster 5847ddb19e31SBrian Foster error = xfs_btree_delete(cur, &i); 5848ddb19e31SBrian Foster if (error) 58494db431f5SDave Chinner return error; 58505fb5aeeeSEric Sandeen XFS_WANT_CORRUPTED_RETURN(mp, i == 1); 5851ddb19e31SBrian Foster 5852ddb19e31SBrian Foster /* lookup and update size of the previous extent */ 5853ddb19e31SBrian Foster error = xfs_bmbt_lookup_eq(cur, left.br_startoff, left.br_startblock, 5854ddb19e31SBrian Foster left.br_blockcount, &i); 5855ddb19e31SBrian Foster if (error) 58564db431f5SDave Chinner return error; 58575fb5aeeeSEric Sandeen XFS_WANT_CORRUPTED_RETURN(mp, i == 1); 5858ddb19e31SBrian Foster 5859ddb19e31SBrian Foster left.br_blockcount = blockcount; 5860ddb19e31SBrian Foster 58614db431f5SDave Chinner return xfs_bmbt_update(cur, left.br_startoff, left.br_startblock, 5862ddb19e31SBrian Foster left.br_blockcount, left.br_state); 5863ddb19e31SBrian Foster } 5864ddb19e31SBrian Foster 5865ddb19e31SBrian Foster /* 5866a979bdfeSBrian Foster * Shift a single extent. 5867a979bdfeSBrian Foster */ 5868a979bdfeSBrian Foster STATIC int 5869a979bdfeSBrian Foster xfs_bmse_shift_one( 5870a979bdfeSBrian Foster struct xfs_inode *ip, 5871a979bdfeSBrian Foster int whichfork, 5872a979bdfeSBrian Foster xfs_fileoff_t offset_shift_fsb, 5873a979bdfeSBrian Foster int *current_ext, 5874a979bdfeSBrian Foster struct xfs_bmbt_rec_host *gotp, 5875a979bdfeSBrian Foster struct xfs_btree_cur *cur, 5876a904b1caSNamjae Jeon int *logflags, 58779c194644SDarrick J. Wong enum shift_direction direction, 58789c194644SDarrick J. Wong struct xfs_defer_ops *dfops) 5879a979bdfeSBrian Foster { 5880a979bdfeSBrian Foster struct xfs_ifork *ifp; 58815fb5aeeeSEric Sandeen struct xfs_mount *mp; 5882a979bdfeSBrian Foster xfs_fileoff_t startoff; 5883a904b1caSNamjae Jeon struct xfs_bmbt_rec_host *adj_irecp; 5884a979bdfeSBrian Foster struct xfs_bmbt_irec got; 5885a904b1caSNamjae Jeon struct xfs_bmbt_irec adj_irec; 5886a979bdfeSBrian Foster int error; 5887a979bdfeSBrian Foster int i; 5888a904b1caSNamjae Jeon int total_extents; 5889a979bdfeSBrian Foster 58905fb5aeeeSEric Sandeen mp = ip->i_mount; 5891a979bdfeSBrian Foster ifp = XFS_IFORK_PTR(ip, whichfork); 5892a904b1caSNamjae Jeon total_extents = ifp->if_bytes / sizeof(xfs_bmbt_rec_t); 5893a979bdfeSBrian Foster 5894a979bdfeSBrian Foster xfs_bmbt_get_all(gotp, &got); 5895a979bdfeSBrian Foster 5896f71721d0SBrian Foster /* delalloc extents should be prevented by caller */ 58975fb5aeeeSEric Sandeen XFS_WANT_CORRUPTED_RETURN(mp, !isnullstartblock(got.br_startblock)); 5898f71721d0SBrian Foster 5899a904b1caSNamjae Jeon if (direction == SHIFT_LEFT) { 5900a904b1caSNamjae Jeon startoff = got.br_startoff - offset_shift_fsb; 5901a979bdfeSBrian Foster 5902a904b1caSNamjae Jeon /* 5903a904b1caSNamjae Jeon * Check for merge if we've got an extent to the left, 5904a904b1caSNamjae Jeon * otherwise make sure there's enough room at the start 5905a904b1caSNamjae Jeon * of the file for the shift. 5906a904b1caSNamjae Jeon */ 5907a904b1caSNamjae Jeon if (!*current_ext) { 5908a904b1caSNamjae Jeon if (got.br_startoff < offset_shift_fsb) 5909a904b1caSNamjae Jeon return -EINVAL; 5910a904b1caSNamjae Jeon goto update_current_ext; 5911a904b1caSNamjae Jeon } 5912a904b1caSNamjae Jeon /* 5913a904b1caSNamjae Jeon * grab the left extent and check for a large 5914a904b1caSNamjae Jeon * enough hole. 5915a904b1caSNamjae Jeon */ 5916a904b1caSNamjae Jeon adj_irecp = xfs_iext_get_ext(ifp, *current_ext - 1); 5917a904b1caSNamjae Jeon xfs_bmbt_get_all(adj_irecp, &adj_irec); 5918a904b1caSNamjae Jeon 5919a904b1caSNamjae Jeon if (startoff < 5920a904b1caSNamjae Jeon adj_irec.br_startoff + adj_irec.br_blockcount) 5921a979bdfeSBrian Foster return -EINVAL; 5922a979bdfeSBrian Foster 5923a979bdfeSBrian Foster /* check whether to merge the extent or shift it down */ 5924a904b1caSNamjae Jeon if (xfs_bmse_can_merge(&adj_irec, &got, 5925a904b1caSNamjae Jeon offset_shift_fsb)) { 59269c194644SDarrick J. Wong error = xfs_bmse_merge(ip, whichfork, offset_shift_fsb, 5927a904b1caSNamjae Jeon *current_ext, gotp, adj_irecp, 5928a904b1caSNamjae Jeon cur, logflags); 59299c194644SDarrick J. Wong if (error) 59309c194644SDarrick J. Wong return error; 59319c194644SDarrick J. Wong adj_irec = got; 59329c194644SDarrick J. Wong goto update_rmap; 5933b11bd671SDave Chinner } 5934a904b1caSNamjae Jeon } else { 5935a904b1caSNamjae Jeon startoff = got.br_startoff + offset_shift_fsb; 5936a904b1caSNamjae Jeon /* nothing to move if this is the last extent */ 5937a904b1caSNamjae Jeon if (*current_ext >= (total_extents - 1)) 5938a904b1caSNamjae Jeon goto update_current_ext; 5939a904b1caSNamjae Jeon /* 5940a904b1caSNamjae Jeon * If this is not the last extent in the file, make sure there 5941a904b1caSNamjae Jeon * is enough room between current extent and next extent for 5942a904b1caSNamjae Jeon * accommodating the shift. 5943a904b1caSNamjae Jeon */ 5944a904b1caSNamjae Jeon adj_irecp = xfs_iext_get_ext(ifp, *current_ext + 1); 5945a904b1caSNamjae Jeon xfs_bmbt_get_all(adj_irecp, &adj_irec); 5946a904b1caSNamjae Jeon if (startoff + got.br_blockcount > adj_irec.br_startoff) 5947b11bd671SDave Chinner return -EINVAL; 5948a904b1caSNamjae Jeon /* 5949a904b1caSNamjae Jeon * Unlike a left shift (which involves a hole punch), 5950a904b1caSNamjae Jeon * a right shift does not modify extent neighbors 5951a904b1caSNamjae Jeon * in any way. We should never find mergeable extents 5952a904b1caSNamjae Jeon * in this scenario. Check anyways and warn if we 5953a904b1caSNamjae Jeon * encounter two extents that could be one. 5954a904b1caSNamjae Jeon */ 5955a904b1caSNamjae Jeon if (xfs_bmse_can_merge(&got, &adj_irec, offset_shift_fsb)) 5956a904b1caSNamjae Jeon WARN_ON_ONCE(1); 5957a904b1caSNamjae Jeon } 5958a979bdfeSBrian Foster /* 5959a979bdfeSBrian Foster * Increment the extent index for the next iteration, update the start 5960a979bdfeSBrian Foster * offset of the in-core extent and update the btree if applicable. 5961a979bdfeSBrian Foster */ 5962a904b1caSNamjae Jeon update_current_ext: 5963a904b1caSNamjae Jeon if (direction == SHIFT_LEFT) 5964a979bdfeSBrian Foster (*current_ext)++; 5965a904b1caSNamjae Jeon else 5966a904b1caSNamjae Jeon (*current_ext)--; 5967a979bdfeSBrian Foster xfs_bmbt_set_startoff(gotp, startoff); 5968a979bdfeSBrian Foster *logflags |= XFS_ILOG_CORE; 59699c194644SDarrick J. Wong adj_irec = got; 5970a979bdfeSBrian Foster if (!cur) { 5971a979bdfeSBrian Foster *logflags |= XFS_ILOG_DEXT; 59729c194644SDarrick J. Wong goto update_rmap; 5973a979bdfeSBrian Foster } 5974a979bdfeSBrian Foster 5975a979bdfeSBrian Foster error = xfs_bmbt_lookup_eq(cur, got.br_startoff, got.br_startblock, 5976a979bdfeSBrian Foster got.br_blockcount, &i); 5977a979bdfeSBrian Foster if (error) 5978a979bdfeSBrian Foster return error; 59795fb5aeeeSEric Sandeen XFS_WANT_CORRUPTED_RETURN(mp, i == 1); 5980a979bdfeSBrian Foster 5981a979bdfeSBrian Foster got.br_startoff = startoff; 59829c194644SDarrick J. Wong error = xfs_bmbt_update(cur, got.br_startoff, got.br_startblock, 5983a979bdfeSBrian Foster got.br_blockcount, got.br_state); 59849c194644SDarrick J. Wong if (error) 59859c194644SDarrick J. Wong return error; 59869c194644SDarrick J. Wong 59879c194644SDarrick J. Wong update_rmap: 59889c194644SDarrick J. Wong /* update reverse mapping */ 59899c194644SDarrick J. Wong error = xfs_rmap_unmap_extent(mp, dfops, ip, whichfork, &adj_irec); 59909c194644SDarrick J. Wong if (error) 59919c194644SDarrick J. Wong return error; 59929c194644SDarrick J. Wong adj_irec.br_startoff = startoff; 59939c194644SDarrick J. Wong return xfs_rmap_map_extent(mp, dfops, ip, whichfork, &adj_irec); 5994a979bdfeSBrian Foster } 5995a979bdfeSBrian Foster 5996a979bdfeSBrian Foster /* 5997a904b1caSNamjae Jeon * Shift extent records to the left/right to cover/create a hole. 599830f712c9SDave Chinner * 59992c845f5aSBrian Foster * The maximum number of extents to be shifted in a single operation is 6000a904b1caSNamjae Jeon * @num_exts. @stop_fsb specifies the file offset at which to stop shift and the 60012c845f5aSBrian Foster * file offset where we've left off is returned in @next_fsb. @offset_shift_fsb 60022c845f5aSBrian Foster * is the length by which each extent is shifted. If there is no hole to shift 60032c845f5aSBrian Foster * the extents into, this will be considered invalid operation and we abort 60042c845f5aSBrian Foster * immediately. 600530f712c9SDave Chinner */ 600630f712c9SDave Chinner int 600730f712c9SDave Chinner xfs_bmap_shift_extents( 600830f712c9SDave Chinner struct xfs_trans *tp, 600930f712c9SDave Chinner struct xfs_inode *ip, 6010a904b1caSNamjae Jeon xfs_fileoff_t *next_fsb, 601130f712c9SDave Chinner xfs_fileoff_t offset_shift_fsb, 60122c845f5aSBrian Foster int *done, 6013a904b1caSNamjae Jeon xfs_fileoff_t stop_fsb, 601430f712c9SDave Chinner xfs_fsblock_t *firstblock, 60152c3234d1SDarrick J. Wong struct xfs_defer_ops *dfops, 6016a904b1caSNamjae Jeon enum shift_direction direction, 601730f712c9SDave Chinner int num_exts) 601830f712c9SDave Chinner { 6019ca446d88SBrian Foster struct xfs_btree_cur *cur = NULL; 602030f712c9SDave Chinner struct xfs_bmbt_rec_host *gotp; 602130f712c9SDave Chinner struct xfs_bmbt_irec got; 602230f712c9SDave Chinner struct xfs_mount *mp = ip->i_mount; 602330f712c9SDave Chinner struct xfs_ifork *ifp; 602430f712c9SDave Chinner xfs_extnum_t nexts = 0; 60252c845f5aSBrian Foster xfs_extnum_t current_ext; 6026a904b1caSNamjae Jeon xfs_extnum_t total_extents; 6027a904b1caSNamjae Jeon xfs_extnum_t stop_extent; 602830f712c9SDave Chinner int error = 0; 602930f712c9SDave Chinner int whichfork = XFS_DATA_FORK; 6030ca446d88SBrian Foster int logflags = 0; 603130f712c9SDave Chinner 603230f712c9SDave Chinner if (unlikely(XFS_TEST_ERROR( 603330f712c9SDave Chinner (XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS && 603430f712c9SDave Chinner XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE), 603530f712c9SDave Chinner mp, XFS_ERRTAG_BMAPIFORMAT, XFS_RANDOM_BMAPIFORMAT))) { 603630f712c9SDave Chinner XFS_ERROR_REPORT("xfs_bmap_shift_extents", 603730f712c9SDave Chinner XFS_ERRLEVEL_LOW, mp); 60382451337dSDave Chinner return -EFSCORRUPTED; 603930f712c9SDave Chinner } 604030f712c9SDave Chinner 604130f712c9SDave Chinner if (XFS_FORCED_SHUTDOWN(mp)) 60422451337dSDave Chinner return -EIO; 604330f712c9SDave Chinner 60442c845f5aSBrian Foster ASSERT(xfs_isilocked(ip, XFS_IOLOCK_EXCL)); 60452c845f5aSBrian Foster ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL)); 6046a904b1caSNamjae Jeon ASSERT(direction == SHIFT_LEFT || direction == SHIFT_RIGHT); 6047a904b1caSNamjae Jeon ASSERT(*next_fsb != NULLFSBLOCK || direction == SHIFT_RIGHT); 604830f712c9SDave Chinner 604930f712c9SDave Chinner ifp = XFS_IFORK_PTR(ip, whichfork); 605030f712c9SDave Chinner if (!(ifp->if_flags & XFS_IFEXTENTS)) { 605130f712c9SDave Chinner /* Read in all the extents */ 605230f712c9SDave Chinner error = xfs_iread_extents(tp, ip, whichfork); 605330f712c9SDave Chinner if (error) 605430f712c9SDave Chinner return error; 605530f712c9SDave Chinner } 605630f712c9SDave Chinner 6057ddb19e31SBrian Foster if (ifp->if_flags & XFS_IFBROOT) { 6058ddb19e31SBrian Foster cur = xfs_bmbt_init_cursor(mp, tp, ip, whichfork); 6059ddb19e31SBrian Foster cur->bc_private.b.firstblock = *firstblock; 60602c3234d1SDarrick J. Wong cur->bc_private.b.dfops = dfops; 6061ddb19e31SBrian Foster cur->bc_private.b.flags = 0; 6062ddb19e31SBrian Foster } 6063ddb19e31SBrian Foster 606430f712c9SDave Chinner /* 606530f712c9SDave Chinner * There may be delalloc extents in the data fork before the range we 60662c845f5aSBrian Foster * are collapsing out, so we cannot use the count of real extents here. 60672c845f5aSBrian Foster * Instead we have to calculate it from the incore fork. 606830f712c9SDave Chinner */ 606930f712c9SDave Chinner total_extents = ifp->if_bytes / sizeof(xfs_bmbt_rec_t); 6070a904b1caSNamjae Jeon if (total_extents == 0) { 6071a904b1caSNamjae Jeon *done = 1; 6072a904b1caSNamjae Jeon goto del_cursor; 6073a904b1caSNamjae Jeon } 6074a904b1caSNamjae Jeon 6075a904b1caSNamjae Jeon /* 6076a904b1caSNamjae Jeon * In case of first right shift, we need to initialize next_fsb 6077a904b1caSNamjae Jeon */ 6078a904b1caSNamjae Jeon if (*next_fsb == NULLFSBLOCK) { 6079a904b1caSNamjae Jeon gotp = xfs_iext_get_ext(ifp, total_extents - 1); 6080a904b1caSNamjae Jeon xfs_bmbt_get_all(gotp, &got); 6081a904b1caSNamjae Jeon *next_fsb = got.br_startoff; 6082a904b1caSNamjae Jeon if (stop_fsb > *next_fsb) { 6083a904b1caSNamjae Jeon *done = 1; 6084a904b1caSNamjae Jeon goto del_cursor; 6085a904b1caSNamjae Jeon } 6086a904b1caSNamjae Jeon } 6087a904b1caSNamjae Jeon 6088a904b1caSNamjae Jeon /* Lookup the extent index at which we have to stop */ 6089a904b1caSNamjae Jeon if (direction == SHIFT_RIGHT) { 6090a904b1caSNamjae Jeon gotp = xfs_iext_bno_to_ext(ifp, stop_fsb, &stop_extent); 6091a904b1caSNamjae Jeon /* Make stop_extent exclusive of shift range */ 6092a904b1caSNamjae Jeon stop_extent--; 6093a904b1caSNamjae Jeon } else 6094a904b1caSNamjae Jeon stop_extent = total_extents; 6095a904b1caSNamjae Jeon 6096a904b1caSNamjae Jeon /* 6097a904b1caSNamjae Jeon * Look up the extent index for the fsb where we start shifting. We can 6098a904b1caSNamjae Jeon * henceforth iterate with current_ext as extent list changes are locked 6099a904b1caSNamjae Jeon * out via ilock. 6100a904b1caSNamjae Jeon * 6101a904b1caSNamjae Jeon * gotp can be null in 2 cases: 1) if there are no extents or 2) 6102a904b1caSNamjae Jeon * *next_fsb lies in a hole beyond which there are no extents. Either 6103a904b1caSNamjae Jeon * way, we are done. 6104a904b1caSNamjae Jeon */ 6105a904b1caSNamjae Jeon gotp = xfs_iext_bno_to_ext(ifp, *next_fsb, ¤t_ext); 6106a904b1caSNamjae Jeon if (!gotp) { 6107a904b1caSNamjae Jeon *done = 1; 6108a904b1caSNamjae Jeon goto del_cursor; 6109a904b1caSNamjae Jeon } 6110a904b1caSNamjae Jeon 6111a904b1caSNamjae Jeon /* some sanity checking before we finally start shifting extents */ 6112a904b1caSNamjae Jeon if ((direction == SHIFT_LEFT && current_ext >= stop_extent) || 6113a904b1caSNamjae Jeon (direction == SHIFT_RIGHT && current_ext <= stop_extent)) { 6114a904b1caSNamjae Jeon error = -EIO; 6115a904b1caSNamjae Jeon goto del_cursor; 6116a904b1caSNamjae Jeon } 6117a904b1caSNamjae Jeon 6118a904b1caSNamjae Jeon while (nexts++ < num_exts) { 6119a979bdfeSBrian Foster error = xfs_bmse_shift_one(ip, whichfork, offset_shift_fsb, 6120a904b1caSNamjae Jeon ¤t_ext, gotp, cur, &logflags, 61219c194644SDarrick J. Wong direction, dfops); 6122ddb19e31SBrian Foster if (error) 6123ddb19e31SBrian Foster goto del_cursor; 6124a904b1caSNamjae Jeon /* 6125a904b1caSNamjae Jeon * If there was an extent merge during the shift, the extent 6126a904b1caSNamjae Jeon * count can change. Update the total and grade the next record. 6127a904b1caSNamjae Jeon */ 6128a904b1caSNamjae Jeon if (direction == SHIFT_LEFT) { 612930f712c9SDave Chinner total_extents = ifp->if_bytes / sizeof(xfs_bmbt_rec_t); 6130a904b1caSNamjae Jeon stop_extent = total_extents; 6131a904b1caSNamjae Jeon } 6132a904b1caSNamjae Jeon 6133a904b1caSNamjae Jeon if (current_ext == stop_extent) { 6134a904b1caSNamjae Jeon *done = 1; 6135a904b1caSNamjae Jeon *next_fsb = NULLFSBLOCK; 6136ddb19e31SBrian Foster break; 6137a904b1caSNamjae Jeon } 6138ddb19e31SBrian Foster gotp = xfs_iext_get_ext(ifp, current_ext); 613930f712c9SDave Chinner } 614030f712c9SDave Chinner 6141a904b1caSNamjae Jeon if (!*done) { 6142a979bdfeSBrian Foster xfs_bmbt_get_all(gotp, &got); 61432c845f5aSBrian Foster *next_fsb = got.br_startoff; 6144a979bdfeSBrian Foster } 614530f712c9SDave Chinner 614630f712c9SDave Chinner del_cursor: 614730f712c9SDave Chinner if (cur) 614830f712c9SDave Chinner xfs_btree_del_cursor(cur, 614930f712c9SDave Chinner error ? XFS_BTREE_ERROR : XFS_BTREE_NOERROR); 615030f712c9SDave Chinner 6151ca446d88SBrian Foster if (logflags) 615230f712c9SDave Chinner xfs_trans_log_inode(tp, ip, logflags); 61532c845f5aSBrian Foster 615430f712c9SDave Chinner return error; 615530f712c9SDave Chinner } 6156a904b1caSNamjae Jeon 6157a904b1caSNamjae Jeon /* 6158a904b1caSNamjae Jeon * Splits an extent into two extents at split_fsb block such that it is 6159a904b1caSNamjae Jeon * the first block of the current_ext. @current_ext is a target extent 6160a904b1caSNamjae Jeon * to be split. @split_fsb is a block where the extents is split. 6161a904b1caSNamjae Jeon * If split_fsb lies in a hole or the first block of extents, just return 0. 6162a904b1caSNamjae Jeon */ 6163a904b1caSNamjae Jeon STATIC int 6164a904b1caSNamjae Jeon xfs_bmap_split_extent_at( 6165a904b1caSNamjae Jeon struct xfs_trans *tp, 6166a904b1caSNamjae Jeon struct xfs_inode *ip, 6167a904b1caSNamjae Jeon xfs_fileoff_t split_fsb, 6168a904b1caSNamjae Jeon xfs_fsblock_t *firstfsb, 61692c3234d1SDarrick J. Wong struct xfs_defer_ops *dfops) 6170a904b1caSNamjae Jeon { 6171a904b1caSNamjae Jeon int whichfork = XFS_DATA_FORK; 6172a904b1caSNamjae Jeon struct xfs_btree_cur *cur = NULL; 6173a904b1caSNamjae Jeon struct xfs_bmbt_rec_host *gotp; 6174a904b1caSNamjae Jeon struct xfs_bmbt_irec got; 6175a904b1caSNamjae Jeon struct xfs_bmbt_irec new; /* split extent */ 6176a904b1caSNamjae Jeon struct xfs_mount *mp = ip->i_mount; 6177a904b1caSNamjae Jeon struct xfs_ifork *ifp; 6178a904b1caSNamjae Jeon xfs_fsblock_t gotblkcnt; /* new block count for got */ 6179a904b1caSNamjae Jeon xfs_extnum_t current_ext; 6180a904b1caSNamjae Jeon int error = 0; 6181a904b1caSNamjae Jeon int logflags = 0; 6182a904b1caSNamjae Jeon int i = 0; 6183a904b1caSNamjae Jeon 6184a904b1caSNamjae Jeon if (unlikely(XFS_TEST_ERROR( 6185a904b1caSNamjae Jeon (XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS && 6186a904b1caSNamjae Jeon XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE), 6187a904b1caSNamjae Jeon mp, XFS_ERRTAG_BMAPIFORMAT, XFS_RANDOM_BMAPIFORMAT))) { 6188a904b1caSNamjae Jeon XFS_ERROR_REPORT("xfs_bmap_split_extent_at", 6189a904b1caSNamjae Jeon XFS_ERRLEVEL_LOW, mp); 6190a904b1caSNamjae Jeon return -EFSCORRUPTED; 6191a904b1caSNamjae Jeon } 6192a904b1caSNamjae Jeon 6193a904b1caSNamjae Jeon if (XFS_FORCED_SHUTDOWN(mp)) 6194a904b1caSNamjae Jeon return -EIO; 6195a904b1caSNamjae Jeon 6196a904b1caSNamjae Jeon ifp = XFS_IFORK_PTR(ip, whichfork); 6197a904b1caSNamjae Jeon if (!(ifp->if_flags & XFS_IFEXTENTS)) { 6198a904b1caSNamjae Jeon /* Read in all the extents */ 6199a904b1caSNamjae Jeon error = xfs_iread_extents(tp, ip, whichfork); 6200a904b1caSNamjae Jeon if (error) 6201a904b1caSNamjae Jeon return error; 6202a904b1caSNamjae Jeon } 6203a904b1caSNamjae Jeon 6204a904b1caSNamjae Jeon /* 6205a904b1caSNamjae Jeon * gotp can be null in 2 cases: 1) if there are no extents 6206a904b1caSNamjae Jeon * or 2) split_fsb lies in a hole beyond which there are 6207a904b1caSNamjae Jeon * no extents. Either way, we are done. 6208a904b1caSNamjae Jeon */ 6209a904b1caSNamjae Jeon gotp = xfs_iext_bno_to_ext(ifp, split_fsb, ¤t_ext); 6210a904b1caSNamjae Jeon if (!gotp) 6211a904b1caSNamjae Jeon return 0; 6212a904b1caSNamjae Jeon 6213a904b1caSNamjae Jeon xfs_bmbt_get_all(gotp, &got); 6214a904b1caSNamjae Jeon 6215a904b1caSNamjae Jeon /* 6216a904b1caSNamjae Jeon * Check split_fsb lies in a hole or the start boundary offset 6217a904b1caSNamjae Jeon * of the extent. 6218a904b1caSNamjae Jeon */ 6219a904b1caSNamjae Jeon if (got.br_startoff >= split_fsb) 6220a904b1caSNamjae Jeon return 0; 6221a904b1caSNamjae Jeon 6222a904b1caSNamjae Jeon gotblkcnt = split_fsb - got.br_startoff; 6223a904b1caSNamjae Jeon new.br_startoff = split_fsb; 6224a904b1caSNamjae Jeon new.br_startblock = got.br_startblock + gotblkcnt; 6225a904b1caSNamjae Jeon new.br_blockcount = got.br_blockcount - gotblkcnt; 6226a904b1caSNamjae Jeon new.br_state = got.br_state; 6227a904b1caSNamjae Jeon 6228a904b1caSNamjae Jeon if (ifp->if_flags & XFS_IFBROOT) { 6229a904b1caSNamjae Jeon cur = xfs_bmbt_init_cursor(mp, tp, ip, whichfork); 6230a904b1caSNamjae Jeon cur->bc_private.b.firstblock = *firstfsb; 62312c3234d1SDarrick J. Wong cur->bc_private.b.dfops = dfops; 6232a904b1caSNamjae Jeon cur->bc_private.b.flags = 0; 6233a904b1caSNamjae Jeon error = xfs_bmbt_lookup_eq(cur, got.br_startoff, 6234a904b1caSNamjae Jeon got.br_startblock, 6235a904b1caSNamjae Jeon got.br_blockcount, 6236a904b1caSNamjae Jeon &i); 6237a904b1caSNamjae Jeon if (error) 6238a904b1caSNamjae Jeon goto del_cursor; 6239a904b1caSNamjae Jeon XFS_WANT_CORRUPTED_GOTO(mp, i == 1, del_cursor); 6240a904b1caSNamjae Jeon } 6241a904b1caSNamjae Jeon 6242a904b1caSNamjae Jeon xfs_bmbt_set_blockcount(gotp, gotblkcnt); 6243a904b1caSNamjae Jeon got.br_blockcount = gotblkcnt; 6244a904b1caSNamjae Jeon 6245a904b1caSNamjae Jeon logflags = XFS_ILOG_CORE; 6246a904b1caSNamjae Jeon if (cur) { 6247a904b1caSNamjae Jeon error = xfs_bmbt_update(cur, got.br_startoff, 6248a904b1caSNamjae Jeon got.br_startblock, 6249a904b1caSNamjae Jeon got.br_blockcount, 6250a904b1caSNamjae Jeon got.br_state); 6251a904b1caSNamjae Jeon if (error) 6252a904b1caSNamjae Jeon goto del_cursor; 6253a904b1caSNamjae Jeon } else 6254a904b1caSNamjae Jeon logflags |= XFS_ILOG_DEXT; 6255a904b1caSNamjae Jeon 6256a904b1caSNamjae Jeon /* Add new extent */ 6257a904b1caSNamjae Jeon current_ext++; 6258a904b1caSNamjae Jeon xfs_iext_insert(ip, current_ext, 1, &new, 0); 6259a904b1caSNamjae Jeon XFS_IFORK_NEXT_SET(ip, whichfork, 6260a904b1caSNamjae Jeon XFS_IFORK_NEXTENTS(ip, whichfork) + 1); 6261a904b1caSNamjae Jeon 6262a904b1caSNamjae Jeon if (cur) { 6263a904b1caSNamjae Jeon error = xfs_bmbt_lookup_eq(cur, new.br_startoff, 6264a904b1caSNamjae Jeon new.br_startblock, new.br_blockcount, 6265a904b1caSNamjae Jeon &i); 6266a904b1caSNamjae Jeon if (error) 6267a904b1caSNamjae Jeon goto del_cursor; 6268a904b1caSNamjae Jeon XFS_WANT_CORRUPTED_GOTO(mp, i == 0, del_cursor); 6269a904b1caSNamjae Jeon cur->bc_rec.b.br_state = new.br_state; 6270a904b1caSNamjae Jeon 6271a904b1caSNamjae Jeon error = xfs_btree_insert(cur, &i); 6272a904b1caSNamjae Jeon if (error) 6273a904b1caSNamjae Jeon goto del_cursor; 6274a904b1caSNamjae Jeon XFS_WANT_CORRUPTED_GOTO(mp, i == 1, del_cursor); 6275a904b1caSNamjae Jeon } 6276a904b1caSNamjae Jeon 6277a904b1caSNamjae Jeon /* 6278a904b1caSNamjae Jeon * Convert to a btree if necessary. 6279a904b1caSNamjae Jeon */ 6280a904b1caSNamjae Jeon if (xfs_bmap_needs_btree(ip, whichfork)) { 6281a904b1caSNamjae Jeon int tmp_logflags; /* partial log flag return val */ 6282a904b1caSNamjae Jeon 6283a904b1caSNamjae Jeon ASSERT(cur == NULL); 62842c3234d1SDarrick J. Wong error = xfs_bmap_extents_to_btree(tp, ip, firstfsb, dfops, 6285a904b1caSNamjae Jeon &cur, 0, &tmp_logflags, whichfork); 6286a904b1caSNamjae Jeon logflags |= tmp_logflags; 6287a904b1caSNamjae Jeon } 6288a904b1caSNamjae Jeon 6289a904b1caSNamjae Jeon del_cursor: 6290a904b1caSNamjae Jeon if (cur) { 6291a904b1caSNamjae Jeon cur->bc_private.b.allocated = 0; 6292a904b1caSNamjae Jeon xfs_btree_del_cursor(cur, 6293a904b1caSNamjae Jeon error ? XFS_BTREE_ERROR : XFS_BTREE_NOERROR); 6294a904b1caSNamjae Jeon } 6295a904b1caSNamjae Jeon 6296a904b1caSNamjae Jeon if (logflags) 6297a904b1caSNamjae Jeon xfs_trans_log_inode(tp, ip, logflags); 6298a904b1caSNamjae Jeon return error; 6299a904b1caSNamjae Jeon } 6300a904b1caSNamjae Jeon 6301a904b1caSNamjae Jeon int 6302a904b1caSNamjae Jeon xfs_bmap_split_extent( 6303a904b1caSNamjae Jeon struct xfs_inode *ip, 6304a904b1caSNamjae Jeon xfs_fileoff_t split_fsb) 6305a904b1caSNamjae Jeon { 6306a904b1caSNamjae Jeon struct xfs_mount *mp = ip->i_mount; 6307a904b1caSNamjae Jeon struct xfs_trans *tp; 63082c3234d1SDarrick J. Wong struct xfs_defer_ops dfops; 6309a904b1caSNamjae Jeon xfs_fsblock_t firstfsb; 6310a904b1caSNamjae Jeon int error; 6311a904b1caSNamjae Jeon 6312253f4911SChristoph Hellwig error = xfs_trans_alloc(mp, &M_RES(mp)->tr_write, 6313253f4911SChristoph Hellwig XFS_DIOSTRAT_SPACE_RES(mp, 0), 0, 0, &tp); 6314253f4911SChristoph Hellwig if (error) 6315a904b1caSNamjae Jeon return error; 6316a904b1caSNamjae Jeon 6317a904b1caSNamjae Jeon xfs_ilock(ip, XFS_ILOCK_EXCL); 6318a904b1caSNamjae Jeon xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL); 6319a904b1caSNamjae Jeon 63202c3234d1SDarrick J. Wong xfs_defer_init(&dfops, &firstfsb); 6321a904b1caSNamjae Jeon 6322a904b1caSNamjae Jeon error = xfs_bmap_split_extent_at(tp, ip, split_fsb, 63232c3234d1SDarrick J. Wong &firstfsb, &dfops); 6324a904b1caSNamjae Jeon if (error) 6325a904b1caSNamjae Jeon goto out; 6326a904b1caSNamjae Jeon 63272c3234d1SDarrick J. Wong error = xfs_defer_finish(&tp, &dfops, NULL); 6328a904b1caSNamjae Jeon if (error) 6329a904b1caSNamjae Jeon goto out; 6330a904b1caSNamjae Jeon 633170393313SChristoph Hellwig return xfs_trans_commit(tp); 6332a904b1caSNamjae Jeon 6333a904b1caSNamjae Jeon out: 63342c3234d1SDarrick J. Wong xfs_defer_cancel(&dfops); 63354906e215SChristoph Hellwig xfs_trans_cancel(tp); 6336a904b1caSNamjae Jeon return error; 6337a904b1caSNamjae Jeon } 63389f3afb57SDarrick J. Wong 63399f3afb57SDarrick J. Wong /* Deferred mapping is only for real extents in the data fork. */ 63409f3afb57SDarrick J. Wong static bool 63419f3afb57SDarrick J. Wong xfs_bmap_is_update_needed( 63429f3afb57SDarrick J. Wong struct xfs_bmbt_irec *bmap) 63439f3afb57SDarrick J. Wong { 63449f3afb57SDarrick J. Wong return bmap->br_startblock != HOLESTARTBLOCK && 63459f3afb57SDarrick J. Wong bmap->br_startblock != DELAYSTARTBLOCK; 63469f3afb57SDarrick J. Wong } 63479f3afb57SDarrick J. Wong 63489f3afb57SDarrick J. Wong /* Record a bmap intent. */ 63499f3afb57SDarrick J. Wong static int 63509f3afb57SDarrick J. Wong __xfs_bmap_add( 63519f3afb57SDarrick J. Wong struct xfs_mount *mp, 63529f3afb57SDarrick J. Wong struct xfs_defer_ops *dfops, 63539f3afb57SDarrick J. Wong enum xfs_bmap_intent_type type, 63549f3afb57SDarrick J. Wong struct xfs_inode *ip, 63559f3afb57SDarrick J. Wong int whichfork, 63569f3afb57SDarrick J. Wong struct xfs_bmbt_irec *bmap) 63579f3afb57SDarrick J. Wong { 63589f3afb57SDarrick J. Wong int error; 63599f3afb57SDarrick J. Wong struct xfs_bmap_intent *bi; 63609f3afb57SDarrick J. Wong 63619f3afb57SDarrick J. Wong trace_xfs_bmap_defer(mp, 63629f3afb57SDarrick J. Wong XFS_FSB_TO_AGNO(mp, bmap->br_startblock), 63639f3afb57SDarrick J. Wong type, 63649f3afb57SDarrick J. Wong XFS_FSB_TO_AGBNO(mp, bmap->br_startblock), 63659f3afb57SDarrick J. Wong ip->i_ino, whichfork, 63669f3afb57SDarrick J. Wong bmap->br_startoff, 63679f3afb57SDarrick J. Wong bmap->br_blockcount, 63689f3afb57SDarrick J. Wong bmap->br_state); 63699f3afb57SDarrick J. Wong 63709f3afb57SDarrick J. Wong bi = kmem_alloc(sizeof(struct xfs_bmap_intent), KM_SLEEP | KM_NOFS); 63719f3afb57SDarrick J. Wong INIT_LIST_HEAD(&bi->bi_list); 63729f3afb57SDarrick J. Wong bi->bi_type = type; 63739f3afb57SDarrick J. Wong bi->bi_owner = ip; 63749f3afb57SDarrick J. Wong bi->bi_whichfork = whichfork; 63759f3afb57SDarrick J. Wong bi->bi_bmap = *bmap; 63769f3afb57SDarrick J. Wong 63779f3afb57SDarrick J. Wong error = xfs_defer_join(dfops, bi->bi_owner); 63789f3afb57SDarrick J. Wong if (error) { 63799f3afb57SDarrick J. Wong kmem_free(bi); 63809f3afb57SDarrick J. Wong return error; 63819f3afb57SDarrick J. Wong } 63829f3afb57SDarrick J. Wong 63839f3afb57SDarrick J. Wong xfs_defer_add(dfops, XFS_DEFER_OPS_TYPE_BMAP, &bi->bi_list); 63849f3afb57SDarrick J. Wong return 0; 63859f3afb57SDarrick J. Wong } 63869f3afb57SDarrick J. Wong 63879f3afb57SDarrick J. Wong /* Map an extent into a file. */ 63889f3afb57SDarrick J. Wong int 63899f3afb57SDarrick J. Wong xfs_bmap_map_extent( 63909f3afb57SDarrick J. Wong struct xfs_mount *mp, 63919f3afb57SDarrick J. Wong struct xfs_defer_ops *dfops, 63929f3afb57SDarrick J. Wong struct xfs_inode *ip, 63939f3afb57SDarrick J. Wong struct xfs_bmbt_irec *PREV) 63949f3afb57SDarrick J. Wong { 63959f3afb57SDarrick J. Wong if (!xfs_bmap_is_update_needed(PREV)) 63969f3afb57SDarrick J. Wong return 0; 63979f3afb57SDarrick J. Wong 63989f3afb57SDarrick J. Wong return __xfs_bmap_add(mp, dfops, XFS_BMAP_MAP, ip, 63999f3afb57SDarrick J. Wong XFS_DATA_FORK, PREV); 64009f3afb57SDarrick J. Wong } 64019f3afb57SDarrick J. Wong 64029f3afb57SDarrick J. Wong /* Unmap an extent out of a file. */ 64039f3afb57SDarrick J. Wong int 64049f3afb57SDarrick J. Wong xfs_bmap_unmap_extent( 64059f3afb57SDarrick J. Wong struct xfs_mount *mp, 64069f3afb57SDarrick J. Wong struct xfs_defer_ops *dfops, 64079f3afb57SDarrick J. Wong struct xfs_inode *ip, 64089f3afb57SDarrick J. Wong struct xfs_bmbt_irec *PREV) 64099f3afb57SDarrick J. Wong { 64109f3afb57SDarrick J. Wong if (!xfs_bmap_is_update_needed(PREV)) 64119f3afb57SDarrick J. Wong return 0; 64129f3afb57SDarrick J. Wong 64139f3afb57SDarrick J. Wong return __xfs_bmap_add(mp, dfops, XFS_BMAP_UNMAP, ip, 64149f3afb57SDarrick J. Wong XFS_DATA_FORK, PREV); 64159f3afb57SDarrick J. Wong } 64169f3afb57SDarrick J. Wong 64179f3afb57SDarrick J. Wong /* 64189f3afb57SDarrick J. Wong * Process one of the deferred bmap operations. We pass back the 64199f3afb57SDarrick J. Wong * btree cursor to maintain our lock on the bmapbt between calls. 64209f3afb57SDarrick J. Wong */ 64219f3afb57SDarrick J. Wong int 64229f3afb57SDarrick J. Wong xfs_bmap_finish_one( 64239f3afb57SDarrick J. Wong struct xfs_trans *tp, 64249f3afb57SDarrick J. Wong struct xfs_defer_ops *dfops, 64259f3afb57SDarrick J. Wong struct xfs_inode *ip, 64269f3afb57SDarrick J. Wong enum xfs_bmap_intent_type type, 64279f3afb57SDarrick J. Wong int whichfork, 64289f3afb57SDarrick J. Wong xfs_fileoff_t startoff, 64299f3afb57SDarrick J. Wong xfs_fsblock_t startblock, 64309f3afb57SDarrick J. Wong xfs_filblks_t blockcount, 64319f3afb57SDarrick J. Wong xfs_exntst_t state) 64329f3afb57SDarrick J. Wong { 64339f3afb57SDarrick J. Wong struct xfs_bmbt_irec bmap; 64349f3afb57SDarrick J. Wong int nimaps = 1; 64359f3afb57SDarrick J. Wong xfs_fsblock_t firstfsb; 64369f3afb57SDarrick J. Wong int flags = XFS_BMAPI_REMAP; 64379f3afb57SDarrick J. Wong int done; 64389f3afb57SDarrick J. Wong int error = 0; 64399f3afb57SDarrick J. Wong 64409f3afb57SDarrick J. Wong bmap.br_startblock = startblock; 64419f3afb57SDarrick J. Wong bmap.br_startoff = startoff; 64429f3afb57SDarrick J. Wong bmap.br_blockcount = blockcount; 64439f3afb57SDarrick J. Wong bmap.br_state = state; 64449f3afb57SDarrick J. Wong 64459f3afb57SDarrick J. Wong trace_xfs_bmap_deferred(tp->t_mountp, 64469f3afb57SDarrick J. Wong XFS_FSB_TO_AGNO(tp->t_mountp, startblock), type, 64479f3afb57SDarrick J. Wong XFS_FSB_TO_AGBNO(tp->t_mountp, startblock), 64489f3afb57SDarrick J. Wong ip->i_ino, whichfork, startoff, blockcount, state); 64499f3afb57SDarrick J. Wong 64509f3afb57SDarrick J. Wong if (whichfork != XFS_DATA_FORK && whichfork != XFS_ATTR_FORK) 64519f3afb57SDarrick J. Wong return -EFSCORRUPTED; 64529f3afb57SDarrick J. Wong if (whichfork == XFS_ATTR_FORK) 64539f3afb57SDarrick J. Wong flags |= XFS_BMAPI_ATTRFORK; 64549f3afb57SDarrick J. Wong 64559f3afb57SDarrick J. Wong if (XFS_TEST_ERROR(false, tp->t_mountp, 64569f3afb57SDarrick J. Wong XFS_ERRTAG_BMAP_FINISH_ONE, 64579f3afb57SDarrick J. Wong XFS_RANDOM_BMAP_FINISH_ONE)) 64589f3afb57SDarrick J. Wong return -EIO; 64599f3afb57SDarrick J. Wong 64609f3afb57SDarrick J. Wong switch (type) { 64619f3afb57SDarrick J. Wong case XFS_BMAP_MAP: 64629f3afb57SDarrick J. Wong firstfsb = bmap.br_startblock; 64639f3afb57SDarrick J. Wong error = xfs_bmapi_write(tp, ip, bmap.br_startoff, 64649f3afb57SDarrick J. Wong bmap.br_blockcount, flags, &firstfsb, 64659f3afb57SDarrick J. Wong bmap.br_blockcount, &bmap, &nimaps, 64669f3afb57SDarrick J. Wong dfops); 64679f3afb57SDarrick J. Wong break; 64689f3afb57SDarrick J. Wong case XFS_BMAP_UNMAP: 64699f3afb57SDarrick J. Wong error = xfs_bunmapi(tp, ip, bmap.br_startoff, 64709f3afb57SDarrick J. Wong bmap.br_blockcount, flags, 1, &firstfsb, 64719f3afb57SDarrick J. Wong dfops, &done); 64729f3afb57SDarrick J. Wong ASSERT(done); 64739f3afb57SDarrick J. Wong break; 64749f3afb57SDarrick J. Wong default: 64759f3afb57SDarrick J. Wong ASSERT(0); 64769f3afb57SDarrick J. Wong error = -EFSCORRUPTED; 64779f3afb57SDarrick J. Wong } 64789f3afb57SDarrick J. Wong 64799f3afb57SDarrick J. Wong return error; 64809f3afb57SDarrick J. Wong } 6481