130f712c9SDave Chinner /* 230f712c9SDave Chinner * Copyright (c) 2000-2006 Silicon Graphics, Inc. 330f712c9SDave Chinner * All Rights Reserved. 430f712c9SDave Chinner * 530f712c9SDave Chinner * This program is free software; you can redistribute it and/or 630f712c9SDave Chinner * modify it under the terms of the GNU General Public License as 730f712c9SDave Chinner * published by the Free Software Foundation. 830f712c9SDave Chinner * 930f712c9SDave Chinner * This program is distributed in the hope that it would be useful, 1030f712c9SDave Chinner * but WITHOUT ANY WARRANTY; without even the implied warranty of 1130f712c9SDave Chinner * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 1230f712c9SDave Chinner * GNU General Public License for more details. 1330f712c9SDave Chinner * 1430f712c9SDave Chinner * You should have received a copy of the GNU General Public License 1530f712c9SDave Chinner * along with this program; if not, write the Free Software Foundation, 1630f712c9SDave Chinner * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA 1730f712c9SDave Chinner */ 1830f712c9SDave Chinner #include "xfs.h" 1930f712c9SDave Chinner #include "xfs_fs.h" 2030f712c9SDave Chinner #include "xfs_shared.h" 2130f712c9SDave Chinner #include "xfs_format.h" 2230f712c9SDave Chinner #include "xfs_log_format.h" 2330f712c9SDave Chinner #include "xfs_trans_resv.h" 2430f712c9SDave Chinner #include "xfs_bit.h" 2530f712c9SDave Chinner #include "xfs_sb.h" 2630f712c9SDave Chinner #include "xfs_mount.h" 273ab78df2SDarrick J. Wong #include "xfs_defer.h" 2830f712c9SDave Chinner #include "xfs_da_format.h" 2930f712c9SDave Chinner #include "xfs_da_btree.h" 3030f712c9SDave Chinner #include "xfs_dir2.h" 3130f712c9SDave Chinner #include "xfs_inode.h" 3230f712c9SDave Chinner #include "xfs_btree.h" 3330f712c9SDave Chinner #include "xfs_trans.h" 3430f712c9SDave Chinner #include "xfs_inode_item.h" 3530f712c9SDave Chinner #include "xfs_extfree_item.h" 3630f712c9SDave Chinner #include "xfs_alloc.h" 3730f712c9SDave Chinner #include "xfs_bmap.h" 3830f712c9SDave Chinner #include "xfs_bmap_util.h" 3930f712c9SDave Chinner #include "xfs_bmap_btree.h" 4030f712c9SDave Chinner #include "xfs_rtalloc.h" 4130f712c9SDave Chinner #include "xfs_error.h" 4230f712c9SDave Chinner #include "xfs_quota.h" 4330f712c9SDave Chinner #include "xfs_trans_space.h" 4430f712c9SDave Chinner #include "xfs_buf_item.h" 4530f712c9SDave Chinner #include "xfs_trace.h" 4630f712c9SDave Chinner #include "xfs_symlink.h" 4730f712c9SDave Chinner #include "xfs_attr_leaf.h" 4830f712c9SDave Chinner #include "xfs_filestream.h" 49340785ccSDarrick J. Wong #include "xfs_rmap.h" 503fd129b6SDarrick J. Wong #include "xfs_ag_resv.h" 5162aab20fSDarrick J. Wong #include "xfs_refcount.h" 52974ae922SBrian Foster #include "xfs_icache.h" 5330f712c9SDave Chinner 5430f712c9SDave Chinner 5530f712c9SDave Chinner kmem_zone_t *xfs_bmap_free_item_zone; 5630f712c9SDave Chinner 5730f712c9SDave Chinner /* 5830f712c9SDave Chinner * Miscellaneous helper functions 5930f712c9SDave Chinner */ 6030f712c9SDave Chinner 6130f712c9SDave Chinner /* 6230f712c9SDave Chinner * Compute and fill in the value of the maximum depth of a bmap btree 6330f712c9SDave Chinner * in this filesystem. Done once, during mount. 6430f712c9SDave Chinner */ 6530f712c9SDave Chinner void 6630f712c9SDave Chinner xfs_bmap_compute_maxlevels( 6730f712c9SDave Chinner xfs_mount_t *mp, /* file system mount structure */ 6830f712c9SDave Chinner int whichfork) /* data or attr fork */ 6930f712c9SDave Chinner { 7030f712c9SDave Chinner int level; /* btree level */ 7130f712c9SDave Chinner uint maxblocks; /* max blocks at this level */ 7230f712c9SDave Chinner uint maxleafents; /* max leaf entries possible */ 7330f712c9SDave Chinner int maxrootrecs; /* max records in root block */ 7430f712c9SDave Chinner int minleafrecs; /* min records in leaf block */ 7530f712c9SDave Chinner int minnoderecs; /* min records in node block */ 7630f712c9SDave Chinner int sz; /* root block size */ 7730f712c9SDave Chinner 7830f712c9SDave Chinner /* 7930f712c9SDave Chinner * The maximum number of extents in a file, hence the maximum 8030f712c9SDave Chinner * number of leaf entries, is controlled by the type of di_nextents 8130f712c9SDave Chinner * (a signed 32-bit number, xfs_extnum_t), or by di_anextents 8230f712c9SDave Chinner * (a signed 16-bit number, xfs_aextnum_t). 8330f712c9SDave Chinner * 8430f712c9SDave Chinner * Note that we can no longer assume that if we are in ATTR1 that 8530f712c9SDave Chinner * the fork offset of all the inodes will be 8630f712c9SDave Chinner * (xfs_default_attroffset(ip) >> 3) because we could have mounted 8730f712c9SDave Chinner * with ATTR2 and then mounted back with ATTR1, keeping the 8830f712c9SDave Chinner * di_forkoff's fixed but probably at various positions. Therefore, 8930f712c9SDave Chinner * for both ATTR1 and ATTR2 we have to assume the worst case scenario 9030f712c9SDave Chinner * of a minimum size available. 9130f712c9SDave Chinner */ 9230f712c9SDave Chinner if (whichfork == XFS_DATA_FORK) { 9330f712c9SDave Chinner maxleafents = MAXEXTNUM; 9430f712c9SDave Chinner sz = XFS_BMDR_SPACE_CALC(MINDBTPTRS); 9530f712c9SDave Chinner } else { 9630f712c9SDave Chinner maxleafents = MAXAEXTNUM; 9730f712c9SDave Chinner sz = XFS_BMDR_SPACE_CALC(MINABTPTRS); 9830f712c9SDave Chinner } 9930f712c9SDave Chinner maxrootrecs = xfs_bmdr_maxrecs(sz, 0); 10030f712c9SDave Chinner minleafrecs = mp->m_bmap_dmnr[0]; 10130f712c9SDave Chinner minnoderecs = mp->m_bmap_dmnr[1]; 10230f712c9SDave Chinner maxblocks = (maxleafents + minleafrecs - 1) / minleafrecs; 10330f712c9SDave Chinner for (level = 1; maxblocks > 1; level++) { 10430f712c9SDave Chinner if (maxblocks <= maxrootrecs) 10530f712c9SDave Chinner maxblocks = 1; 10630f712c9SDave Chinner else 10730f712c9SDave Chinner maxblocks = (maxblocks + minnoderecs - 1) / minnoderecs; 10830f712c9SDave Chinner } 10930f712c9SDave Chinner mp->m_bm_maxlevels[whichfork] = level; 11030f712c9SDave Chinner } 11130f712c9SDave Chinner 11230f712c9SDave Chinner STATIC int /* error */ 11330f712c9SDave Chinner xfs_bmbt_lookup_eq( 11430f712c9SDave Chinner struct xfs_btree_cur *cur, 115e16cf9b0SChristoph Hellwig struct xfs_bmbt_irec *irec, 11630f712c9SDave Chinner int *stat) /* success/failure */ 11730f712c9SDave Chinner { 118e16cf9b0SChristoph Hellwig cur->bc_rec.b = *irec; 11930f712c9SDave Chinner return xfs_btree_lookup(cur, XFS_LOOKUP_EQ, stat); 12030f712c9SDave Chinner } 12130f712c9SDave Chinner 12230f712c9SDave Chinner STATIC int /* error */ 123b5cfbc22SChristoph Hellwig xfs_bmbt_lookup_first( 12430f712c9SDave Chinner struct xfs_btree_cur *cur, 12530f712c9SDave Chinner int *stat) /* success/failure */ 12630f712c9SDave Chinner { 127b5cfbc22SChristoph Hellwig cur->bc_rec.b.br_startoff = 0; 128b5cfbc22SChristoph Hellwig cur->bc_rec.b.br_startblock = 0; 129b5cfbc22SChristoph Hellwig cur->bc_rec.b.br_blockcount = 0; 13030f712c9SDave Chinner return xfs_btree_lookup(cur, XFS_LOOKUP_GE, stat); 13130f712c9SDave Chinner } 13230f712c9SDave Chinner 13330f712c9SDave Chinner /* 13430f712c9SDave Chinner * Check if the inode needs to be converted to btree format. 13530f712c9SDave Chinner */ 13630f712c9SDave Chinner static inline bool xfs_bmap_needs_btree(struct xfs_inode *ip, int whichfork) 13730f712c9SDave Chinner { 13860b4984fSDarrick J. Wong return whichfork != XFS_COW_FORK && 13960b4984fSDarrick J. Wong XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_EXTENTS && 14030f712c9SDave Chinner XFS_IFORK_NEXTENTS(ip, whichfork) > 14130f712c9SDave Chinner XFS_IFORK_MAXEXT(ip, whichfork); 14230f712c9SDave Chinner } 14330f712c9SDave Chinner 14430f712c9SDave Chinner /* 14530f712c9SDave Chinner * Check if the inode should be converted to extent format. 14630f712c9SDave Chinner */ 14730f712c9SDave Chinner static inline bool xfs_bmap_wants_extents(struct xfs_inode *ip, int whichfork) 14830f712c9SDave Chinner { 14960b4984fSDarrick J. Wong return whichfork != XFS_COW_FORK && 15060b4984fSDarrick J. Wong XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_BTREE && 15130f712c9SDave Chinner XFS_IFORK_NEXTENTS(ip, whichfork) <= 15230f712c9SDave Chinner XFS_IFORK_MAXEXT(ip, whichfork); 15330f712c9SDave Chinner } 15430f712c9SDave Chinner 15530f712c9SDave Chinner /* 156a67d00a5SChristoph Hellwig * Update the record referred to by cur to the value given by irec 15730f712c9SDave Chinner * This either works (return 0) or gets an EFSCORRUPTED error. 15830f712c9SDave Chinner */ 15930f712c9SDave Chinner STATIC int 16030f712c9SDave Chinner xfs_bmbt_update( 16130f712c9SDave Chinner struct xfs_btree_cur *cur, 162a67d00a5SChristoph Hellwig struct xfs_bmbt_irec *irec) 16330f712c9SDave Chinner { 16430f712c9SDave Chinner union xfs_btree_rec rec; 16530f712c9SDave Chinner 166a67d00a5SChristoph Hellwig xfs_bmbt_disk_set_all(&rec.bmbt, irec); 16730f712c9SDave Chinner return xfs_btree_update(cur, &rec); 16830f712c9SDave Chinner } 16930f712c9SDave Chinner 17030f712c9SDave Chinner /* 17130f712c9SDave Chinner * Compute the worst-case number of indirect blocks that will be used 17230f712c9SDave Chinner * for ip's delayed extent of length "len". 17330f712c9SDave Chinner */ 17430f712c9SDave Chinner STATIC xfs_filblks_t 17530f712c9SDave Chinner xfs_bmap_worst_indlen( 17630f712c9SDave Chinner xfs_inode_t *ip, /* incore inode pointer */ 17730f712c9SDave Chinner xfs_filblks_t len) /* delayed extent length */ 17830f712c9SDave Chinner { 17930f712c9SDave Chinner int level; /* btree level number */ 18030f712c9SDave Chinner int maxrecs; /* maximum record count at this level */ 18130f712c9SDave Chinner xfs_mount_t *mp; /* mount structure */ 18230f712c9SDave Chinner xfs_filblks_t rval; /* return value */ 18330f712c9SDave Chinner 18430f712c9SDave Chinner mp = ip->i_mount; 18530f712c9SDave Chinner maxrecs = mp->m_bmap_dmxr[0]; 18630f712c9SDave Chinner for (level = 0, rval = 0; 18730f712c9SDave Chinner level < XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK); 18830f712c9SDave Chinner level++) { 18930f712c9SDave Chinner len += maxrecs - 1; 19030f712c9SDave Chinner do_div(len, maxrecs); 19130f712c9SDave Chinner rval += len; 1925e5c943cSDarrick J. Wong if (len == 1) 1935e5c943cSDarrick J. Wong return rval + XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK) - 19430f712c9SDave Chinner level - 1; 19530f712c9SDave Chinner if (level == 0) 19630f712c9SDave Chinner maxrecs = mp->m_bmap_dmxr[1]; 19730f712c9SDave Chinner } 19830f712c9SDave Chinner return rval; 19930f712c9SDave Chinner } 20030f712c9SDave Chinner 20130f712c9SDave Chinner /* 20230f712c9SDave Chinner * Calculate the default attribute fork offset for newly created inodes. 20330f712c9SDave Chinner */ 20430f712c9SDave Chinner uint 20530f712c9SDave Chinner xfs_default_attroffset( 20630f712c9SDave Chinner struct xfs_inode *ip) 20730f712c9SDave Chinner { 20830f712c9SDave Chinner struct xfs_mount *mp = ip->i_mount; 20930f712c9SDave Chinner uint offset; 21030f712c9SDave Chinner 21130f712c9SDave Chinner if (mp->m_sb.sb_inodesize == 256) { 21230f712c9SDave Chinner offset = XFS_LITINO(mp, ip->i_d.di_version) - 21330f712c9SDave Chinner XFS_BMDR_SPACE_CALC(MINABTPTRS); 21430f712c9SDave Chinner } else { 21530f712c9SDave Chinner offset = XFS_BMDR_SPACE_CALC(6 * MINABTPTRS); 21630f712c9SDave Chinner } 21730f712c9SDave Chinner 21830f712c9SDave Chinner ASSERT(offset < XFS_LITINO(mp, ip->i_d.di_version)); 21930f712c9SDave Chinner return offset; 22030f712c9SDave Chinner } 22130f712c9SDave Chinner 22230f712c9SDave Chinner /* 22330f712c9SDave Chinner * Helper routine to reset inode di_forkoff field when switching 22430f712c9SDave Chinner * attribute fork from local to extent format - we reset it where 22530f712c9SDave Chinner * possible to make space available for inline data fork extents. 22630f712c9SDave Chinner */ 22730f712c9SDave Chinner STATIC void 22830f712c9SDave Chinner xfs_bmap_forkoff_reset( 22930f712c9SDave Chinner xfs_inode_t *ip, 23030f712c9SDave Chinner int whichfork) 23130f712c9SDave Chinner { 23230f712c9SDave Chinner if (whichfork == XFS_ATTR_FORK && 23330f712c9SDave Chinner ip->i_d.di_format != XFS_DINODE_FMT_DEV && 23430f712c9SDave Chinner ip->i_d.di_format != XFS_DINODE_FMT_UUID && 23530f712c9SDave Chinner ip->i_d.di_format != XFS_DINODE_FMT_BTREE) { 23630f712c9SDave Chinner uint dfl_forkoff = xfs_default_attroffset(ip) >> 3; 23730f712c9SDave Chinner 23830f712c9SDave Chinner if (dfl_forkoff > ip->i_d.di_forkoff) 23930f712c9SDave Chinner ip->i_d.di_forkoff = dfl_forkoff; 24030f712c9SDave Chinner } 24130f712c9SDave Chinner } 24230f712c9SDave Chinner 24330f712c9SDave Chinner #ifdef DEBUG 24430f712c9SDave Chinner STATIC struct xfs_buf * 24530f712c9SDave Chinner xfs_bmap_get_bp( 24630f712c9SDave Chinner struct xfs_btree_cur *cur, 24730f712c9SDave Chinner xfs_fsblock_t bno) 24830f712c9SDave Chinner { 24930f712c9SDave Chinner struct xfs_log_item_desc *lidp; 25030f712c9SDave Chinner int i; 25130f712c9SDave Chinner 25230f712c9SDave Chinner if (!cur) 25330f712c9SDave Chinner return NULL; 25430f712c9SDave Chinner 25530f712c9SDave Chinner for (i = 0; i < XFS_BTREE_MAXLEVELS; i++) { 25630f712c9SDave Chinner if (!cur->bc_bufs[i]) 25730f712c9SDave Chinner break; 25830f712c9SDave Chinner if (XFS_BUF_ADDR(cur->bc_bufs[i]) == bno) 25930f712c9SDave Chinner return cur->bc_bufs[i]; 26030f712c9SDave Chinner } 26130f712c9SDave Chinner 26230f712c9SDave Chinner /* Chase down all the log items to see if the bp is there */ 26330f712c9SDave Chinner list_for_each_entry(lidp, &cur->bc_tp->t_items, lid_trans) { 26430f712c9SDave Chinner struct xfs_buf_log_item *bip; 26530f712c9SDave Chinner bip = (struct xfs_buf_log_item *)lidp->lid_item; 26630f712c9SDave Chinner if (bip->bli_item.li_type == XFS_LI_BUF && 26730f712c9SDave Chinner XFS_BUF_ADDR(bip->bli_buf) == bno) 26830f712c9SDave Chinner return bip->bli_buf; 26930f712c9SDave Chinner } 27030f712c9SDave Chinner 27130f712c9SDave Chinner return NULL; 27230f712c9SDave Chinner } 27330f712c9SDave Chinner 27430f712c9SDave Chinner STATIC void 27530f712c9SDave Chinner xfs_check_block( 27630f712c9SDave Chinner struct xfs_btree_block *block, 27730f712c9SDave Chinner xfs_mount_t *mp, 27830f712c9SDave Chinner int root, 27930f712c9SDave Chinner short sz) 28030f712c9SDave Chinner { 28130f712c9SDave Chinner int i, j, dmxr; 28230f712c9SDave Chinner __be64 *pp, *thispa; /* pointer to block address */ 28330f712c9SDave Chinner xfs_bmbt_key_t *prevp, *keyp; 28430f712c9SDave Chinner 28530f712c9SDave Chinner ASSERT(be16_to_cpu(block->bb_level) > 0); 28630f712c9SDave Chinner 28730f712c9SDave Chinner prevp = NULL; 28830f712c9SDave Chinner for( i = 1; i <= xfs_btree_get_numrecs(block); i++) { 28930f712c9SDave Chinner dmxr = mp->m_bmap_dmxr[0]; 29030f712c9SDave Chinner keyp = XFS_BMBT_KEY_ADDR(mp, block, i); 29130f712c9SDave Chinner 29230f712c9SDave Chinner if (prevp) { 29330f712c9SDave Chinner ASSERT(be64_to_cpu(prevp->br_startoff) < 29430f712c9SDave Chinner be64_to_cpu(keyp->br_startoff)); 29530f712c9SDave Chinner } 29630f712c9SDave Chinner prevp = keyp; 29730f712c9SDave Chinner 29830f712c9SDave Chinner /* 29930f712c9SDave Chinner * Compare the block numbers to see if there are dups. 30030f712c9SDave Chinner */ 30130f712c9SDave Chinner if (root) 30230f712c9SDave Chinner pp = XFS_BMAP_BROOT_PTR_ADDR(mp, block, i, sz); 30330f712c9SDave Chinner else 30430f712c9SDave Chinner pp = XFS_BMBT_PTR_ADDR(mp, block, i, dmxr); 30530f712c9SDave Chinner 30630f712c9SDave Chinner for (j = i+1; j <= be16_to_cpu(block->bb_numrecs); j++) { 30730f712c9SDave Chinner if (root) 30830f712c9SDave Chinner thispa = XFS_BMAP_BROOT_PTR_ADDR(mp, block, j, sz); 30930f712c9SDave Chinner else 31030f712c9SDave Chinner thispa = XFS_BMBT_PTR_ADDR(mp, block, j, dmxr); 31130f712c9SDave Chinner if (*thispa == *pp) { 31230f712c9SDave Chinner xfs_warn(mp, "%s: thispa(%d) == pp(%d) %Ld", 31330f712c9SDave Chinner __func__, j, i, 31430f712c9SDave Chinner (unsigned long long)be64_to_cpu(*thispa)); 31530f712c9SDave Chinner panic("%s: ptrs are equal in node\n", 31630f712c9SDave Chinner __func__); 31730f712c9SDave Chinner } 31830f712c9SDave Chinner } 31930f712c9SDave Chinner } 32030f712c9SDave Chinner } 32130f712c9SDave Chinner 32230f712c9SDave Chinner /* 32330f712c9SDave Chinner * Check that the extents for the inode ip are in the right order in all 324e3543819SDave Chinner * btree leaves. THis becomes prohibitively expensive for large extent count 325e3543819SDave Chinner * files, so don't bother with inodes that have more than 10,000 extents in 326e3543819SDave Chinner * them. The btree record ordering checks will still be done, so for such large 327e3543819SDave Chinner * bmapbt constructs that is going to catch most corruptions. 32830f712c9SDave Chinner */ 32930f712c9SDave Chinner STATIC void 33030f712c9SDave Chinner xfs_bmap_check_leaf_extents( 33130f712c9SDave Chinner xfs_btree_cur_t *cur, /* btree cursor or null */ 33230f712c9SDave Chinner xfs_inode_t *ip, /* incore inode pointer */ 33330f712c9SDave Chinner int whichfork) /* data or attr fork */ 33430f712c9SDave Chinner { 33530f712c9SDave Chinner struct xfs_btree_block *block; /* current btree block */ 33630f712c9SDave Chinner xfs_fsblock_t bno; /* block # of "block" */ 33730f712c9SDave Chinner xfs_buf_t *bp; /* buffer for "block" */ 33830f712c9SDave Chinner int error; /* error return value */ 33930f712c9SDave Chinner xfs_extnum_t i=0, j; /* index into the extents list */ 34030f712c9SDave Chinner xfs_ifork_t *ifp; /* fork structure */ 34130f712c9SDave Chinner int level; /* btree level, for checking */ 34230f712c9SDave Chinner xfs_mount_t *mp; /* file system mount structure */ 34330f712c9SDave Chinner __be64 *pp; /* pointer to block address */ 34430f712c9SDave Chinner xfs_bmbt_rec_t *ep; /* pointer to current extent */ 34530f712c9SDave Chinner xfs_bmbt_rec_t last = {0, 0}; /* last extent in prev block */ 34630f712c9SDave Chinner xfs_bmbt_rec_t *nextp; /* pointer to next extent */ 34730f712c9SDave Chinner int bp_release = 0; 34830f712c9SDave Chinner 34930f712c9SDave Chinner if (XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE) { 35030f712c9SDave Chinner return; 35130f712c9SDave Chinner } 35230f712c9SDave Chinner 353e3543819SDave Chinner /* skip large extent count inodes */ 354e3543819SDave Chinner if (ip->i_d.di_nextents > 10000) 355e3543819SDave Chinner return; 356e3543819SDave Chinner 35730f712c9SDave Chinner bno = NULLFSBLOCK; 35830f712c9SDave Chinner mp = ip->i_mount; 35930f712c9SDave Chinner ifp = XFS_IFORK_PTR(ip, whichfork); 36030f712c9SDave Chinner block = ifp->if_broot; 36130f712c9SDave Chinner /* 36230f712c9SDave Chinner * Root level must use BMAP_BROOT_PTR_ADDR macro to get ptr out. 36330f712c9SDave Chinner */ 36430f712c9SDave Chinner level = be16_to_cpu(block->bb_level); 36530f712c9SDave Chinner ASSERT(level > 0); 36630f712c9SDave Chinner xfs_check_block(block, mp, 1, ifp->if_broot_bytes); 36730f712c9SDave Chinner pp = XFS_BMAP_BROOT_PTR_ADDR(mp, block, 1, ifp->if_broot_bytes); 36830f712c9SDave Chinner bno = be64_to_cpu(*pp); 36930f712c9SDave Chinner 370d5cf09baSChristoph Hellwig ASSERT(bno != NULLFSBLOCK); 37130f712c9SDave Chinner ASSERT(XFS_FSB_TO_AGNO(mp, bno) < mp->m_sb.sb_agcount); 37230f712c9SDave Chinner ASSERT(XFS_FSB_TO_AGBNO(mp, bno) < mp->m_sb.sb_agblocks); 37330f712c9SDave Chinner 37430f712c9SDave Chinner /* 37530f712c9SDave Chinner * Go down the tree until leaf level is reached, following the first 37630f712c9SDave Chinner * pointer (leftmost) at each level. 37730f712c9SDave Chinner */ 37830f712c9SDave Chinner while (level-- > 0) { 37930f712c9SDave Chinner /* See if buf is in cur first */ 38030f712c9SDave Chinner bp_release = 0; 38130f712c9SDave Chinner bp = xfs_bmap_get_bp(cur, XFS_FSB_TO_DADDR(mp, bno)); 38230f712c9SDave Chinner if (!bp) { 38330f712c9SDave Chinner bp_release = 1; 38430f712c9SDave Chinner error = xfs_btree_read_bufl(mp, NULL, bno, 0, &bp, 38530f712c9SDave Chinner XFS_BMAP_BTREE_REF, 38630f712c9SDave Chinner &xfs_bmbt_buf_ops); 38730f712c9SDave Chinner if (error) 38830f712c9SDave Chinner goto error_norelse; 38930f712c9SDave Chinner } 39030f712c9SDave Chinner block = XFS_BUF_TO_BLOCK(bp); 39130f712c9SDave Chinner if (level == 0) 39230f712c9SDave Chinner break; 39330f712c9SDave Chinner 39430f712c9SDave Chinner /* 39530f712c9SDave Chinner * Check this block for basic sanity (increasing keys and 39630f712c9SDave Chinner * no duplicate blocks). 39730f712c9SDave Chinner */ 39830f712c9SDave Chinner 39930f712c9SDave Chinner xfs_check_block(block, mp, 0, 0); 40030f712c9SDave Chinner pp = XFS_BMBT_PTR_ADDR(mp, block, 1, mp->m_bmap_dmxr[1]); 40130f712c9SDave Chinner bno = be64_to_cpu(*pp); 402c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, 403c29aad41SEric Sandeen XFS_FSB_SANITY_CHECK(mp, bno), error0); 40430f712c9SDave Chinner if (bp_release) { 40530f712c9SDave Chinner bp_release = 0; 40630f712c9SDave Chinner xfs_trans_brelse(NULL, bp); 40730f712c9SDave Chinner } 40830f712c9SDave Chinner } 40930f712c9SDave Chinner 41030f712c9SDave Chinner /* 41130f712c9SDave Chinner * Here with bp and block set to the leftmost leaf node in the tree. 41230f712c9SDave Chinner */ 41330f712c9SDave Chinner i = 0; 41430f712c9SDave Chinner 41530f712c9SDave Chinner /* 41630f712c9SDave Chinner * Loop over all leaf nodes checking that all extents are in the right order. 41730f712c9SDave Chinner */ 41830f712c9SDave Chinner for (;;) { 41930f712c9SDave Chinner xfs_fsblock_t nextbno; 42030f712c9SDave Chinner xfs_extnum_t num_recs; 42130f712c9SDave Chinner 42230f712c9SDave Chinner 42330f712c9SDave Chinner num_recs = xfs_btree_get_numrecs(block); 42430f712c9SDave Chinner 42530f712c9SDave Chinner /* 42630f712c9SDave Chinner * Read-ahead the next leaf block, if any. 42730f712c9SDave Chinner */ 42830f712c9SDave Chinner 42930f712c9SDave Chinner nextbno = be64_to_cpu(block->bb_u.l.bb_rightsib); 43030f712c9SDave Chinner 43130f712c9SDave Chinner /* 43230f712c9SDave Chinner * Check all the extents to make sure they are OK. 43330f712c9SDave Chinner * If we had a previous block, the last entry should 43430f712c9SDave Chinner * conform with the first entry in this one. 43530f712c9SDave Chinner */ 43630f712c9SDave Chinner 43730f712c9SDave Chinner ep = XFS_BMBT_REC_ADDR(mp, block, 1); 43830f712c9SDave Chinner if (i) { 43930f712c9SDave Chinner ASSERT(xfs_bmbt_disk_get_startoff(&last) + 44030f712c9SDave Chinner xfs_bmbt_disk_get_blockcount(&last) <= 44130f712c9SDave Chinner xfs_bmbt_disk_get_startoff(ep)); 44230f712c9SDave Chinner } 44330f712c9SDave Chinner for (j = 1; j < num_recs; j++) { 44430f712c9SDave Chinner nextp = XFS_BMBT_REC_ADDR(mp, block, j + 1); 44530f712c9SDave Chinner ASSERT(xfs_bmbt_disk_get_startoff(ep) + 44630f712c9SDave Chinner xfs_bmbt_disk_get_blockcount(ep) <= 44730f712c9SDave Chinner xfs_bmbt_disk_get_startoff(nextp)); 44830f712c9SDave Chinner ep = nextp; 44930f712c9SDave Chinner } 45030f712c9SDave Chinner 45130f712c9SDave Chinner last = *ep; 45230f712c9SDave Chinner i += num_recs; 45330f712c9SDave Chinner if (bp_release) { 45430f712c9SDave Chinner bp_release = 0; 45530f712c9SDave Chinner xfs_trans_brelse(NULL, bp); 45630f712c9SDave Chinner } 45730f712c9SDave Chinner bno = nextbno; 45830f712c9SDave Chinner /* 45930f712c9SDave Chinner * If we've reached the end, stop. 46030f712c9SDave Chinner */ 46130f712c9SDave Chinner if (bno == NULLFSBLOCK) 46230f712c9SDave Chinner break; 46330f712c9SDave Chinner 46430f712c9SDave Chinner bp_release = 0; 46530f712c9SDave Chinner bp = xfs_bmap_get_bp(cur, XFS_FSB_TO_DADDR(mp, bno)); 46630f712c9SDave Chinner if (!bp) { 46730f712c9SDave Chinner bp_release = 1; 46830f712c9SDave Chinner error = xfs_btree_read_bufl(mp, NULL, bno, 0, &bp, 46930f712c9SDave Chinner XFS_BMAP_BTREE_REF, 47030f712c9SDave Chinner &xfs_bmbt_buf_ops); 47130f712c9SDave Chinner if (error) 47230f712c9SDave Chinner goto error_norelse; 47330f712c9SDave Chinner } 47430f712c9SDave Chinner block = XFS_BUF_TO_BLOCK(bp); 47530f712c9SDave Chinner } 476a5fd276bSLuis de Bethencourt 47730f712c9SDave Chinner return; 47830f712c9SDave Chinner 47930f712c9SDave Chinner error0: 48030f712c9SDave Chinner xfs_warn(mp, "%s: at error0", __func__); 48130f712c9SDave Chinner if (bp_release) 48230f712c9SDave Chinner xfs_trans_brelse(NULL, bp); 48330f712c9SDave Chinner error_norelse: 48430f712c9SDave Chinner xfs_warn(mp, "%s: BAD after btree leaves for %d extents", 48530f712c9SDave Chinner __func__, i); 48630f712c9SDave Chinner panic("%s: CORRUPTED BTREE OR SOMETHING", __func__); 48730f712c9SDave Chinner return; 48830f712c9SDave Chinner } 48930f712c9SDave Chinner 49030f712c9SDave Chinner /* 49130f712c9SDave Chinner * Add bmap trace insert entries for all the contents of the extent records. 49230f712c9SDave Chinner */ 49330f712c9SDave Chinner void 49430f712c9SDave Chinner xfs_bmap_trace_exlist( 49530f712c9SDave Chinner xfs_inode_t *ip, /* incore inode pointer */ 49630f712c9SDave Chinner xfs_extnum_t cnt, /* count of entries in the list */ 497c44a1f22SEric Sandeen int whichfork, /* data or attr or cow fork */ 49830f712c9SDave Chinner unsigned long caller_ip) 49930f712c9SDave Chinner { 50030f712c9SDave Chinner xfs_extnum_t idx; /* extent record index */ 50130f712c9SDave Chinner xfs_ifork_t *ifp; /* inode fork pointer */ 502060ea65bSChristoph Hellwig int state = xfs_bmap_fork_to_state(whichfork); 50330f712c9SDave Chinner 50430f712c9SDave Chinner ifp = XFS_IFORK_PTR(ip, whichfork); 5055d829300SEric Sandeen ASSERT(cnt == xfs_iext_count(ifp)); 50630f712c9SDave Chinner for (idx = 0; idx < cnt; idx++) 5077710517fSEric Sandeen trace_xfs_extlist(ip, idx, state, caller_ip); 50830f712c9SDave Chinner } 50930f712c9SDave Chinner 51030f712c9SDave Chinner /* 51130f712c9SDave Chinner * Validate that the bmbt_irecs being returned from bmapi are valid 51230f712c9SDave Chinner * given the caller's original parameters. Specifically check the 51330f712c9SDave Chinner * ranges of the returned irecs to ensure that they only extend beyond 51430f712c9SDave Chinner * the given parameters if the XFS_BMAPI_ENTIRE flag was set. 51530f712c9SDave Chinner */ 51630f712c9SDave Chinner STATIC void 51730f712c9SDave Chinner xfs_bmap_validate_ret( 51830f712c9SDave Chinner xfs_fileoff_t bno, 51930f712c9SDave Chinner xfs_filblks_t len, 52030f712c9SDave Chinner int flags, 52130f712c9SDave Chinner xfs_bmbt_irec_t *mval, 52230f712c9SDave Chinner int nmap, 52330f712c9SDave Chinner int ret_nmap) 52430f712c9SDave Chinner { 52530f712c9SDave Chinner int i; /* index to map values */ 52630f712c9SDave Chinner 52730f712c9SDave Chinner ASSERT(ret_nmap <= nmap); 52830f712c9SDave Chinner 52930f712c9SDave Chinner for (i = 0; i < ret_nmap; i++) { 53030f712c9SDave Chinner ASSERT(mval[i].br_blockcount > 0); 53130f712c9SDave Chinner if (!(flags & XFS_BMAPI_ENTIRE)) { 53230f712c9SDave Chinner ASSERT(mval[i].br_startoff >= bno); 53330f712c9SDave Chinner ASSERT(mval[i].br_blockcount <= len); 53430f712c9SDave Chinner ASSERT(mval[i].br_startoff + mval[i].br_blockcount <= 53530f712c9SDave Chinner bno + len); 53630f712c9SDave Chinner } else { 53730f712c9SDave Chinner ASSERT(mval[i].br_startoff < bno + len); 53830f712c9SDave Chinner ASSERT(mval[i].br_startoff + mval[i].br_blockcount > 53930f712c9SDave Chinner bno); 54030f712c9SDave Chinner } 54130f712c9SDave Chinner ASSERT(i == 0 || 54230f712c9SDave Chinner mval[i - 1].br_startoff + mval[i - 1].br_blockcount == 54330f712c9SDave Chinner mval[i].br_startoff); 54430f712c9SDave Chinner ASSERT(mval[i].br_startblock != DELAYSTARTBLOCK && 54530f712c9SDave Chinner mval[i].br_startblock != HOLESTARTBLOCK); 54630f712c9SDave Chinner ASSERT(mval[i].br_state == XFS_EXT_NORM || 54730f712c9SDave Chinner mval[i].br_state == XFS_EXT_UNWRITTEN); 54830f712c9SDave Chinner } 54930f712c9SDave Chinner } 55030f712c9SDave Chinner 55130f712c9SDave Chinner #else 55230f712c9SDave Chinner #define xfs_bmap_check_leaf_extents(cur, ip, whichfork) do { } while (0) 5537bf7a193SDarrick J. Wong #define xfs_bmap_validate_ret(bno,len,flags,mval,onmap,nmap) do { } while (0) 55430f712c9SDave Chinner #endif /* DEBUG */ 55530f712c9SDave Chinner 55630f712c9SDave Chinner /* 55730f712c9SDave Chinner * bmap free list manipulation functions 55830f712c9SDave Chinner */ 55930f712c9SDave Chinner 56030f712c9SDave Chinner /* 56130f712c9SDave Chinner * Add the extent to the list of extents to be free at transaction end. 56230f712c9SDave Chinner * The list is maintained sorted (by block number). 56330f712c9SDave Chinner */ 56430f712c9SDave Chinner void 56530f712c9SDave Chinner xfs_bmap_add_free( 566340785ccSDarrick J. Wong struct xfs_mount *mp, 567340785ccSDarrick J. Wong struct xfs_defer_ops *dfops, 568340785ccSDarrick J. Wong xfs_fsblock_t bno, 569340785ccSDarrick J. Wong xfs_filblks_t len, 570340785ccSDarrick J. Wong struct xfs_owner_info *oinfo) 57130f712c9SDave Chinner { 572310a75a3SDarrick J. Wong struct xfs_extent_free_item *new; /* new element */ 57330f712c9SDave Chinner #ifdef DEBUG 57430f712c9SDave Chinner xfs_agnumber_t agno; 57530f712c9SDave Chinner xfs_agblock_t agbno; 57630f712c9SDave Chinner 57730f712c9SDave Chinner ASSERT(bno != NULLFSBLOCK); 57830f712c9SDave Chinner ASSERT(len > 0); 57930f712c9SDave Chinner ASSERT(len <= MAXEXTLEN); 58030f712c9SDave Chinner ASSERT(!isnullstartblock(bno)); 58130f712c9SDave Chinner agno = XFS_FSB_TO_AGNO(mp, bno); 58230f712c9SDave Chinner agbno = XFS_FSB_TO_AGBNO(mp, bno); 58330f712c9SDave Chinner ASSERT(agno < mp->m_sb.sb_agcount); 58430f712c9SDave Chinner ASSERT(agbno < mp->m_sb.sb_agblocks); 58530f712c9SDave Chinner ASSERT(len < mp->m_sb.sb_agblocks); 58630f712c9SDave Chinner ASSERT(agbno + len <= mp->m_sb.sb_agblocks); 58730f712c9SDave Chinner #endif 58830f712c9SDave Chinner ASSERT(xfs_bmap_free_item_zone != NULL); 589340785ccSDarrick J. Wong 59030f712c9SDave Chinner new = kmem_zone_alloc(xfs_bmap_free_item_zone, KM_SLEEP); 591310a75a3SDarrick J. Wong new->xefi_startblock = bno; 592310a75a3SDarrick J. Wong new->xefi_blockcount = (xfs_extlen_t)len; 593340785ccSDarrick J. Wong if (oinfo) 594340785ccSDarrick J. Wong new->xefi_oinfo = *oinfo; 595340785ccSDarrick J. Wong else 596340785ccSDarrick J. Wong xfs_rmap_skip_owner_update(&new->xefi_oinfo); 597ba9e7802SDarrick J. Wong trace_xfs_bmap_free_defer(mp, XFS_FSB_TO_AGNO(mp, bno), 0, 598ba9e7802SDarrick J. Wong XFS_FSB_TO_AGBNO(mp, bno), len); 5992c3234d1SDarrick J. Wong xfs_defer_add(dfops, XFS_DEFER_OPS_TYPE_FREE, &new->xefi_list); 60030f712c9SDave Chinner } 60130f712c9SDave Chinner 60230f712c9SDave Chinner /* 60330f712c9SDave Chinner * Inode fork format manipulation functions 60430f712c9SDave Chinner */ 60530f712c9SDave Chinner 60630f712c9SDave Chinner /* 60730f712c9SDave Chinner * Transform a btree format file with only one leaf node, where the 60830f712c9SDave Chinner * extents list will fit in the inode, into an extents format file. 60930f712c9SDave Chinner * Since the file extents are already in-core, all we have to do is 61030f712c9SDave Chinner * give up the space for the btree root and pitch the leaf block. 61130f712c9SDave Chinner */ 61230f712c9SDave Chinner STATIC int /* error */ 61330f712c9SDave Chinner xfs_bmap_btree_to_extents( 61430f712c9SDave Chinner xfs_trans_t *tp, /* transaction pointer */ 61530f712c9SDave Chinner xfs_inode_t *ip, /* incore inode pointer */ 61630f712c9SDave Chinner xfs_btree_cur_t *cur, /* btree cursor */ 61730f712c9SDave Chinner int *logflagsp, /* inode logging flags */ 61830f712c9SDave Chinner int whichfork) /* data or attr fork */ 61930f712c9SDave Chinner { 62030f712c9SDave Chinner /* REFERENCED */ 62130f712c9SDave Chinner struct xfs_btree_block *cblock;/* child btree block */ 62230f712c9SDave Chinner xfs_fsblock_t cbno; /* child block number */ 62330f712c9SDave Chinner xfs_buf_t *cbp; /* child block's buffer */ 62430f712c9SDave Chinner int error; /* error return value */ 62530f712c9SDave Chinner xfs_ifork_t *ifp; /* inode fork data */ 62630f712c9SDave Chinner xfs_mount_t *mp; /* mount point structure */ 62730f712c9SDave Chinner __be64 *pp; /* ptr to block address */ 62830f712c9SDave Chinner struct xfs_btree_block *rblock;/* root btree block */ 629340785ccSDarrick J. Wong struct xfs_owner_info oinfo; 63030f712c9SDave Chinner 63130f712c9SDave Chinner mp = ip->i_mount; 63230f712c9SDave Chinner ifp = XFS_IFORK_PTR(ip, whichfork); 63360b4984fSDarrick J. Wong ASSERT(whichfork != XFS_COW_FORK); 63430f712c9SDave Chinner ASSERT(ifp->if_flags & XFS_IFEXTENTS); 63530f712c9SDave Chinner ASSERT(XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_BTREE); 63630f712c9SDave Chinner rblock = ifp->if_broot; 63730f712c9SDave Chinner ASSERT(be16_to_cpu(rblock->bb_level) == 1); 63830f712c9SDave Chinner ASSERT(be16_to_cpu(rblock->bb_numrecs) == 1); 63930f712c9SDave Chinner ASSERT(xfs_bmbt_maxrecs(mp, ifp->if_broot_bytes, 0) == 1); 64030f712c9SDave Chinner pp = XFS_BMAP_BROOT_PTR_ADDR(mp, rblock, 1, ifp->if_broot_bytes); 64130f712c9SDave Chinner cbno = be64_to_cpu(*pp); 64230f712c9SDave Chinner *logflagsp = 0; 64330f712c9SDave Chinner #ifdef DEBUG 644f135761aSDarrick J. Wong XFS_WANT_CORRUPTED_RETURN(cur->bc_mp, 645f135761aSDarrick J. Wong xfs_btree_check_lptr(cur, cbno, 1)); 64630f712c9SDave Chinner #endif 64730f712c9SDave Chinner error = xfs_btree_read_bufl(mp, tp, cbno, 0, &cbp, XFS_BMAP_BTREE_REF, 64830f712c9SDave Chinner &xfs_bmbt_buf_ops); 64930f712c9SDave Chinner if (error) 65030f712c9SDave Chinner return error; 65130f712c9SDave Chinner cblock = XFS_BUF_TO_BLOCK(cbp); 65230f712c9SDave Chinner if ((error = xfs_btree_check_block(cur, cblock, 0, cbp))) 65330f712c9SDave Chinner return error; 654340785ccSDarrick J. Wong xfs_rmap_ino_bmbt_owner(&oinfo, ip->i_ino, whichfork); 655340785ccSDarrick J. Wong xfs_bmap_add_free(mp, cur->bc_private.b.dfops, cbno, 1, &oinfo); 65630f712c9SDave Chinner ip->i_d.di_nblocks--; 65730f712c9SDave Chinner xfs_trans_mod_dquot_byino(tp, ip, XFS_TRANS_DQ_BCOUNT, -1L); 65830f712c9SDave Chinner xfs_trans_binval(tp, cbp); 65930f712c9SDave Chinner if (cur->bc_bufs[0] == cbp) 66030f712c9SDave Chinner cur->bc_bufs[0] = NULL; 66130f712c9SDave Chinner xfs_iroot_realloc(ip, -1, whichfork); 66230f712c9SDave Chinner ASSERT(ifp->if_broot == NULL); 66330f712c9SDave Chinner ASSERT((ifp->if_flags & XFS_IFBROOT) == 0); 66430f712c9SDave Chinner XFS_IFORK_FMT_SET(ip, whichfork, XFS_DINODE_FMT_EXTENTS); 66530f712c9SDave Chinner *logflagsp = XFS_ILOG_CORE | xfs_ilog_fext(whichfork); 66630f712c9SDave Chinner return 0; 66730f712c9SDave Chinner } 66830f712c9SDave Chinner 66930f712c9SDave Chinner /* 67030f712c9SDave Chinner * Convert an extents-format file into a btree-format file. 67130f712c9SDave Chinner * The new file will have a root block (in the inode) and a single child block. 67230f712c9SDave Chinner */ 67330f712c9SDave Chinner STATIC int /* error */ 67430f712c9SDave Chinner xfs_bmap_extents_to_btree( 67530f712c9SDave Chinner xfs_trans_t *tp, /* transaction pointer */ 67630f712c9SDave Chinner xfs_inode_t *ip, /* incore inode pointer */ 67730f712c9SDave Chinner xfs_fsblock_t *firstblock, /* first-block-allocated */ 6782c3234d1SDarrick J. Wong struct xfs_defer_ops *dfops, /* blocks freed in xaction */ 67930f712c9SDave Chinner xfs_btree_cur_t **curp, /* cursor returned to caller */ 68030f712c9SDave Chinner int wasdel, /* converting a delayed alloc */ 68130f712c9SDave Chinner int *logflagsp, /* inode logging flags */ 68230f712c9SDave Chinner int whichfork) /* data or attr fork */ 68330f712c9SDave Chinner { 68430f712c9SDave Chinner struct xfs_btree_block *ablock; /* allocated (child) bt block */ 68530f712c9SDave Chinner xfs_buf_t *abp; /* buffer for ablock */ 68630f712c9SDave Chinner xfs_alloc_arg_t args; /* allocation arguments */ 68730f712c9SDave Chinner xfs_bmbt_rec_t *arp; /* child record pointer */ 68830f712c9SDave Chinner struct xfs_btree_block *block; /* btree root block */ 68930f712c9SDave Chinner xfs_btree_cur_t *cur; /* bmap btree cursor */ 69030f712c9SDave Chinner xfs_bmbt_rec_host_t *ep; /* extent record pointer */ 69130f712c9SDave Chinner int error; /* error return value */ 69230f712c9SDave Chinner xfs_extnum_t i, cnt; /* extent record index */ 69330f712c9SDave Chinner xfs_ifork_t *ifp; /* inode fork pointer */ 69430f712c9SDave Chinner xfs_bmbt_key_t *kp; /* root block key pointer */ 69530f712c9SDave Chinner xfs_mount_t *mp; /* mount structure */ 69630f712c9SDave Chinner xfs_extnum_t nextents; /* number of file extents */ 69730f712c9SDave Chinner xfs_bmbt_ptr_t *pp; /* root block address pointer */ 69830f712c9SDave Chinner 69930f712c9SDave Chinner mp = ip->i_mount; 70060b4984fSDarrick J. Wong ASSERT(whichfork != XFS_COW_FORK); 70130f712c9SDave Chinner ifp = XFS_IFORK_PTR(ip, whichfork); 70230f712c9SDave Chinner ASSERT(XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_EXTENTS); 70330f712c9SDave Chinner 70430f712c9SDave Chinner /* 70530f712c9SDave Chinner * Make space in the inode incore. 70630f712c9SDave Chinner */ 70730f712c9SDave Chinner xfs_iroot_realloc(ip, 1, whichfork); 70830f712c9SDave Chinner ifp->if_flags |= XFS_IFBROOT; 70930f712c9SDave Chinner 71030f712c9SDave Chinner /* 71130f712c9SDave Chinner * Fill in the root. 71230f712c9SDave Chinner */ 71330f712c9SDave Chinner block = ifp->if_broot; 71430f712c9SDave Chinner xfs_btree_init_block_int(mp, block, XFS_BUF_DADDR_NULL, 715b6f41e44SEric Sandeen XFS_BTNUM_BMAP, 1, 1, ip->i_ino, 716f88ae46bSEric Sandeen XFS_BTREE_LONG_PTRS); 71730f712c9SDave Chinner /* 71830f712c9SDave Chinner * Need a cursor. Can't allocate until bb_level is filled in. 71930f712c9SDave Chinner */ 72030f712c9SDave Chinner cur = xfs_bmbt_init_cursor(mp, tp, ip, whichfork); 72130f712c9SDave Chinner cur->bc_private.b.firstblock = *firstblock; 7222c3234d1SDarrick J. Wong cur->bc_private.b.dfops = dfops; 72330f712c9SDave Chinner cur->bc_private.b.flags = wasdel ? XFS_BTCUR_BPRV_WASDEL : 0; 72430f712c9SDave Chinner /* 72530f712c9SDave Chinner * Convert to a btree with two levels, one record in root. 72630f712c9SDave Chinner */ 72730f712c9SDave Chinner XFS_IFORK_FMT_SET(ip, whichfork, XFS_DINODE_FMT_BTREE); 72830f712c9SDave Chinner memset(&args, 0, sizeof(args)); 72930f712c9SDave Chinner args.tp = tp; 73030f712c9SDave Chinner args.mp = mp; 731340785ccSDarrick J. Wong xfs_rmap_ino_bmbt_owner(&args.oinfo, ip->i_ino, whichfork); 73230f712c9SDave Chinner args.firstblock = *firstblock; 73330f712c9SDave Chinner if (*firstblock == NULLFSBLOCK) { 73430f712c9SDave Chinner args.type = XFS_ALLOCTYPE_START_BNO; 73530f712c9SDave Chinner args.fsbno = XFS_INO_TO_FSB(mp, ip->i_ino); 7362c3234d1SDarrick J. Wong } else if (dfops->dop_low) { 73730f712c9SDave Chinner args.type = XFS_ALLOCTYPE_START_BNO; 73830f712c9SDave Chinner args.fsbno = *firstblock; 73930f712c9SDave Chinner } else { 74030f712c9SDave Chinner args.type = XFS_ALLOCTYPE_NEAR_BNO; 74130f712c9SDave Chinner args.fsbno = *firstblock; 74230f712c9SDave Chinner } 74330f712c9SDave Chinner args.minlen = args.maxlen = args.prod = 1; 74430f712c9SDave Chinner args.wasdel = wasdel; 74530f712c9SDave Chinner *logflagsp = 0; 74630f712c9SDave Chinner if ((error = xfs_alloc_vextent(&args))) { 74730f712c9SDave Chinner xfs_iroot_realloc(ip, -1, whichfork); 74830f712c9SDave Chinner xfs_btree_del_cursor(cur, XFS_BTREE_ERROR); 74930f712c9SDave Chinner return error; 75030f712c9SDave Chinner } 75190e2056dSDarrick J. Wong 7522fcc319dSChristoph Hellwig if (WARN_ON_ONCE(args.fsbno == NULLFSBLOCK)) { 7532fcc319dSChristoph Hellwig xfs_iroot_realloc(ip, -1, whichfork); 7542fcc319dSChristoph Hellwig xfs_btree_del_cursor(cur, XFS_BTREE_ERROR); 7552fcc319dSChristoph Hellwig return -ENOSPC; 7562fcc319dSChristoph Hellwig } 75730f712c9SDave Chinner /* 75830f712c9SDave Chinner * Allocation can't fail, the space was reserved. 75930f712c9SDave Chinner */ 76030f712c9SDave Chinner ASSERT(*firstblock == NULLFSBLOCK || 761410d17f6SChristoph Hellwig args.agno >= XFS_FSB_TO_AGNO(mp, *firstblock)); 76230f712c9SDave Chinner *firstblock = cur->bc_private.b.firstblock = args.fsbno; 76330f712c9SDave Chinner cur->bc_private.b.allocated++; 76430f712c9SDave Chinner ip->i_d.di_nblocks++; 76530f712c9SDave Chinner xfs_trans_mod_dquot_byino(tp, ip, XFS_TRANS_DQ_BCOUNT, 1L); 76630f712c9SDave Chinner abp = xfs_btree_get_bufl(mp, tp, args.fsbno, 0); 76730f712c9SDave Chinner /* 76830f712c9SDave Chinner * Fill in the child block. 76930f712c9SDave Chinner */ 77030f712c9SDave Chinner abp->b_ops = &xfs_bmbt_buf_ops; 77130f712c9SDave Chinner ablock = XFS_BUF_TO_BLOCK(abp); 77230f712c9SDave Chinner xfs_btree_init_block_int(mp, ablock, abp->b_bn, 773b6f41e44SEric Sandeen XFS_BTNUM_BMAP, 0, 0, ip->i_ino, 77430f712c9SDave Chinner XFS_BTREE_LONG_PTRS); 77530f712c9SDave Chinner 77630f712c9SDave Chinner arp = XFS_BMBT_REC_ADDR(mp, ablock, 1); 7775d829300SEric Sandeen nextents = xfs_iext_count(ifp); 77830f712c9SDave Chinner for (cnt = i = 0; i < nextents; i++) { 77930f712c9SDave Chinner ep = xfs_iext_get_ext(ifp, i); 78030f712c9SDave Chinner if (!isnullstartblock(xfs_bmbt_get_startblock(ep))) { 78130f712c9SDave Chinner arp->l0 = cpu_to_be64(ep->l0); 78230f712c9SDave Chinner arp->l1 = cpu_to_be64(ep->l1); 78330f712c9SDave Chinner arp++; cnt++; 78430f712c9SDave Chinner } 78530f712c9SDave Chinner } 78630f712c9SDave Chinner ASSERT(cnt == XFS_IFORK_NEXTENTS(ip, whichfork)); 78730f712c9SDave Chinner xfs_btree_set_numrecs(ablock, cnt); 78830f712c9SDave Chinner 78930f712c9SDave Chinner /* 79030f712c9SDave Chinner * Fill in the root key and pointer. 79130f712c9SDave Chinner */ 79230f712c9SDave Chinner kp = XFS_BMBT_KEY_ADDR(mp, block, 1); 79330f712c9SDave Chinner arp = XFS_BMBT_REC_ADDR(mp, ablock, 1); 79430f712c9SDave Chinner kp->br_startoff = cpu_to_be64(xfs_bmbt_disk_get_startoff(arp)); 79530f712c9SDave Chinner pp = XFS_BMBT_PTR_ADDR(mp, block, 1, xfs_bmbt_get_maxrecs(cur, 79630f712c9SDave Chinner be16_to_cpu(block->bb_level))); 79730f712c9SDave Chinner *pp = cpu_to_be64(args.fsbno); 79830f712c9SDave Chinner 79930f712c9SDave Chinner /* 80030f712c9SDave Chinner * Do all this logging at the end so that 80130f712c9SDave Chinner * the root is at the right level. 80230f712c9SDave Chinner */ 80330f712c9SDave Chinner xfs_btree_log_block(cur, abp, XFS_BB_ALL_BITS); 80430f712c9SDave Chinner xfs_btree_log_recs(cur, abp, 1, be16_to_cpu(ablock->bb_numrecs)); 80530f712c9SDave Chinner ASSERT(*curp == NULL); 80630f712c9SDave Chinner *curp = cur; 80730f712c9SDave Chinner *logflagsp = XFS_ILOG_CORE | xfs_ilog_fbroot(whichfork); 80830f712c9SDave Chinner return 0; 80930f712c9SDave Chinner } 81030f712c9SDave Chinner 81130f712c9SDave Chinner /* 81230f712c9SDave Chinner * Convert a local file to an extents file. 81330f712c9SDave Chinner * This code is out of bounds for data forks of regular files, 81430f712c9SDave Chinner * since the file data needs to get logged so things will stay consistent. 81530f712c9SDave Chinner * (The bmap-level manipulations are ok, though). 81630f712c9SDave Chinner */ 81730f712c9SDave Chinner void 81830f712c9SDave Chinner xfs_bmap_local_to_extents_empty( 81930f712c9SDave Chinner struct xfs_inode *ip, 82030f712c9SDave Chinner int whichfork) 82130f712c9SDave Chinner { 82230f712c9SDave Chinner struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, whichfork); 82330f712c9SDave Chinner 82460b4984fSDarrick J. Wong ASSERT(whichfork != XFS_COW_FORK); 82530f712c9SDave Chinner ASSERT(XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_LOCAL); 82630f712c9SDave Chinner ASSERT(ifp->if_bytes == 0); 82730f712c9SDave Chinner ASSERT(XFS_IFORK_NEXTENTS(ip, whichfork) == 0); 82830f712c9SDave Chinner 82930f712c9SDave Chinner xfs_bmap_forkoff_reset(ip, whichfork); 83030f712c9SDave Chinner ifp->if_flags &= ~XFS_IFINLINE; 83130f712c9SDave Chinner ifp->if_flags |= XFS_IFEXTENTS; 83230f712c9SDave Chinner XFS_IFORK_FMT_SET(ip, whichfork, XFS_DINODE_FMT_EXTENTS); 83330f712c9SDave Chinner } 83430f712c9SDave Chinner 83530f712c9SDave Chinner 83630f712c9SDave Chinner STATIC int /* error */ 83730f712c9SDave Chinner xfs_bmap_local_to_extents( 83830f712c9SDave Chinner xfs_trans_t *tp, /* transaction pointer */ 83930f712c9SDave Chinner xfs_inode_t *ip, /* incore inode pointer */ 84030f712c9SDave Chinner xfs_fsblock_t *firstblock, /* first block allocated in xaction */ 84130f712c9SDave Chinner xfs_extlen_t total, /* total blocks needed by transaction */ 84230f712c9SDave Chinner int *logflagsp, /* inode logging flags */ 84330f712c9SDave Chinner int whichfork, 84430f712c9SDave Chinner void (*init_fn)(struct xfs_trans *tp, 84530f712c9SDave Chinner struct xfs_buf *bp, 84630f712c9SDave Chinner struct xfs_inode *ip, 84730f712c9SDave Chinner struct xfs_ifork *ifp)) 84830f712c9SDave Chinner { 84930f712c9SDave Chinner int error = 0; 85030f712c9SDave Chinner int flags; /* logging flags returned */ 85130f712c9SDave Chinner xfs_ifork_t *ifp; /* inode fork pointer */ 85230f712c9SDave Chinner xfs_alloc_arg_t args; /* allocation arguments */ 85330f712c9SDave Chinner xfs_buf_t *bp; /* buffer for extent block */ 85450bb44c2SChristoph Hellwig struct xfs_bmbt_irec rec; 85530f712c9SDave Chinner 85630f712c9SDave Chinner /* 85730f712c9SDave Chinner * We don't want to deal with the case of keeping inode data inline yet. 85830f712c9SDave Chinner * So sending the data fork of a regular inode is invalid. 85930f712c9SDave Chinner */ 860c19b3b05SDave Chinner ASSERT(!(S_ISREG(VFS_I(ip)->i_mode) && whichfork == XFS_DATA_FORK)); 86130f712c9SDave Chinner ifp = XFS_IFORK_PTR(ip, whichfork); 86230f712c9SDave Chinner ASSERT(XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_LOCAL); 86330f712c9SDave Chinner 86430f712c9SDave Chinner if (!ifp->if_bytes) { 86530f712c9SDave Chinner xfs_bmap_local_to_extents_empty(ip, whichfork); 86630f712c9SDave Chinner flags = XFS_ILOG_CORE; 86730f712c9SDave Chinner goto done; 86830f712c9SDave Chinner } 86930f712c9SDave Chinner 87030f712c9SDave Chinner flags = 0; 87130f712c9SDave Chinner error = 0; 87230f712c9SDave Chinner ASSERT((ifp->if_flags & (XFS_IFINLINE|XFS_IFEXTENTS|XFS_IFEXTIREC)) == 87330f712c9SDave Chinner XFS_IFINLINE); 87430f712c9SDave Chinner memset(&args, 0, sizeof(args)); 87530f712c9SDave Chinner args.tp = tp; 87630f712c9SDave Chinner args.mp = ip->i_mount; 877340785ccSDarrick J. Wong xfs_rmap_ino_owner(&args.oinfo, ip->i_ino, whichfork, 0); 87830f712c9SDave Chinner args.firstblock = *firstblock; 87930f712c9SDave Chinner /* 88030f712c9SDave Chinner * Allocate a block. We know we need only one, since the 88130f712c9SDave Chinner * file currently fits in an inode. 88230f712c9SDave Chinner */ 88330f712c9SDave Chinner if (*firstblock == NULLFSBLOCK) { 88430f712c9SDave Chinner args.fsbno = XFS_INO_TO_FSB(args.mp, ip->i_ino); 88530f712c9SDave Chinner args.type = XFS_ALLOCTYPE_START_BNO; 88630f712c9SDave Chinner } else { 88730f712c9SDave Chinner args.fsbno = *firstblock; 88830f712c9SDave Chinner args.type = XFS_ALLOCTYPE_NEAR_BNO; 88930f712c9SDave Chinner } 89030f712c9SDave Chinner args.total = total; 89130f712c9SDave Chinner args.minlen = args.maxlen = args.prod = 1; 89230f712c9SDave Chinner error = xfs_alloc_vextent(&args); 89330f712c9SDave Chinner if (error) 89430f712c9SDave Chinner goto done; 89530f712c9SDave Chinner 89630f712c9SDave Chinner /* Can't fail, the space was reserved. */ 89730f712c9SDave Chinner ASSERT(args.fsbno != NULLFSBLOCK); 89830f712c9SDave Chinner ASSERT(args.len == 1); 89930f712c9SDave Chinner *firstblock = args.fsbno; 90030f712c9SDave Chinner bp = xfs_btree_get_bufl(args.mp, tp, args.fsbno, 0); 90130f712c9SDave Chinner 902fe22d552SDave Chinner /* 903b7cdc66bSBrian Foster * Initialize the block, copy the data and log the remote buffer. 904fe22d552SDave Chinner * 905b7cdc66bSBrian Foster * The callout is responsible for logging because the remote format 906b7cdc66bSBrian Foster * might differ from the local format and thus we don't know how much to 907b7cdc66bSBrian Foster * log here. Note that init_fn must also set the buffer log item type 908b7cdc66bSBrian Foster * correctly. 909fe22d552SDave Chinner */ 91030f712c9SDave Chinner init_fn(tp, bp, ip, ifp); 91130f712c9SDave Chinner 912b7cdc66bSBrian Foster /* account for the change in fork size */ 91330f712c9SDave Chinner xfs_idata_realloc(ip, -ifp->if_bytes, whichfork); 91430f712c9SDave Chinner xfs_bmap_local_to_extents_empty(ip, whichfork); 91530f712c9SDave Chinner flags |= XFS_ILOG_CORE; 91630f712c9SDave Chinner 91750bb44c2SChristoph Hellwig rec.br_startoff = 0; 91850bb44c2SChristoph Hellwig rec.br_startblock = args.fsbno; 91950bb44c2SChristoph Hellwig rec.br_blockcount = 1; 92050bb44c2SChristoph Hellwig rec.br_state = XFS_EXT_NORM; 92150bb44c2SChristoph Hellwig xfs_iext_insert(ip, 0, 1, &rec, 0); 92250bb44c2SChristoph Hellwig 923060ea65bSChristoph Hellwig trace_xfs_bmap_post_update(ip, 0, xfs_bmap_fork_to_state(whichfork), 92430f712c9SDave Chinner _THIS_IP_); 92530f712c9SDave Chinner XFS_IFORK_NEXT_SET(ip, whichfork, 1); 92630f712c9SDave Chinner ip->i_d.di_nblocks = 1; 92730f712c9SDave Chinner xfs_trans_mod_dquot_byino(tp, ip, 92830f712c9SDave Chinner XFS_TRANS_DQ_BCOUNT, 1L); 92930f712c9SDave Chinner flags |= xfs_ilog_fext(whichfork); 93030f712c9SDave Chinner 93130f712c9SDave Chinner done: 93230f712c9SDave Chinner *logflagsp = flags; 93330f712c9SDave Chinner return error; 93430f712c9SDave Chinner } 93530f712c9SDave Chinner 93630f712c9SDave Chinner /* 93730f712c9SDave Chinner * Called from xfs_bmap_add_attrfork to handle btree format files. 93830f712c9SDave Chinner */ 93930f712c9SDave Chinner STATIC int /* error */ 94030f712c9SDave Chinner xfs_bmap_add_attrfork_btree( 94130f712c9SDave Chinner xfs_trans_t *tp, /* transaction pointer */ 94230f712c9SDave Chinner xfs_inode_t *ip, /* incore inode pointer */ 94330f712c9SDave Chinner xfs_fsblock_t *firstblock, /* first block allocated */ 9442c3234d1SDarrick J. Wong struct xfs_defer_ops *dfops, /* blocks to free at commit */ 94530f712c9SDave Chinner int *flags) /* inode logging flags */ 94630f712c9SDave Chinner { 94730f712c9SDave Chinner xfs_btree_cur_t *cur; /* btree cursor */ 94830f712c9SDave Chinner int error; /* error return value */ 94930f712c9SDave Chinner xfs_mount_t *mp; /* file system mount struct */ 95030f712c9SDave Chinner int stat; /* newroot status */ 95130f712c9SDave Chinner 95230f712c9SDave Chinner mp = ip->i_mount; 95330f712c9SDave Chinner if (ip->i_df.if_broot_bytes <= XFS_IFORK_DSIZE(ip)) 95430f712c9SDave Chinner *flags |= XFS_ILOG_DBROOT; 95530f712c9SDave Chinner else { 95630f712c9SDave Chinner cur = xfs_bmbt_init_cursor(mp, tp, ip, XFS_DATA_FORK); 9572c3234d1SDarrick J. Wong cur->bc_private.b.dfops = dfops; 95830f712c9SDave Chinner cur->bc_private.b.firstblock = *firstblock; 959b5cfbc22SChristoph Hellwig error = xfs_bmbt_lookup_first(cur, &stat); 960b5cfbc22SChristoph Hellwig if (error) 96130f712c9SDave Chinner goto error0; 96230f712c9SDave Chinner /* must be at least one entry */ 963c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, stat == 1, error0); 96430f712c9SDave Chinner if ((error = xfs_btree_new_iroot(cur, flags, &stat))) 96530f712c9SDave Chinner goto error0; 96630f712c9SDave Chinner if (stat == 0) { 96730f712c9SDave Chinner xfs_btree_del_cursor(cur, XFS_BTREE_NOERROR); 9682451337dSDave Chinner return -ENOSPC; 96930f712c9SDave Chinner } 97030f712c9SDave Chinner *firstblock = cur->bc_private.b.firstblock; 97130f712c9SDave Chinner cur->bc_private.b.allocated = 0; 97230f712c9SDave Chinner xfs_btree_del_cursor(cur, XFS_BTREE_NOERROR); 97330f712c9SDave Chinner } 97430f712c9SDave Chinner return 0; 97530f712c9SDave Chinner error0: 97630f712c9SDave Chinner xfs_btree_del_cursor(cur, XFS_BTREE_ERROR); 97730f712c9SDave Chinner return error; 97830f712c9SDave Chinner } 97930f712c9SDave Chinner 98030f712c9SDave Chinner /* 98130f712c9SDave Chinner * Called from xfs_bmap_add_attrfork to handle extents format files. 98230f712c9SDave Chinner */ 98330f712c9SDave Chinner STATIC int /* error */ 98430f712c9SDave Chinner xfs_bmap_add_attrfork_extents( 98530f712c9SDave Chinner xfs_trans_t *tp, /* transaction pointer */ 98630f712c9SDave Chinner xfs_inode_t *ip, /* incore inode pointer */ 98730f712c9SDave Chinner xfs_fsblock_t *firstblock, /* first block allocated */ 9882c3234d1SDarrick J. Wong struct xfs_defer_ops *dfops, /* blocks to free at commit */ 98930f712c9SDave Chinner int *flags) /* inode logging flags */ 99030f712c9SDave Chinner { 99130f712c9SDave Chinner xfs_btree_cur_t *cur; /* bmap btree cursor */ 99230f712c9SDave Chinner int error; /* error return value */ 99330f712c9SDave Chinner 99430f712c9SDave Chinner if (ip->i_d.di_nextents * sizeof(xfs_bmbt_rec_t) <= XFS_IFORK_DSIZE(ip)) 99530f712c9SDave Chinner return 0; 99630f712c9SDave Chinner cur = NULL; 9972c3234d1SDarrick J. Wong error = xfs_bmap_extents_to_btree(tp, ip, firstblock, dfops, &cur, 0, 99830f712c9SDave Chinner flags, XFS_DATA_FORK); 99930f712c9SDave Chinner if (cur) { 100030f712c9SDave Chinner cur->bc_private.b.allocated = 0; 100130f712c9SDave Chinner xfs_btree_del_cursor(cur, 100230f712c9SDave Chinner error ? XFS_BTREE_ERROR : XFS_BTREE_NOERROR); 100330f712c9SDave Chinner } 100430f712c9SDave Chinner return error; 100530f712c9SDave Chinner } 100630f712c9SDave Chinner 100730f712c9SDave Chinner /* 100830f712c9SDave Chinner * Called from xfs_bmap_add_attrfork to handle local format files. Each 100930f712c9SDave Chinner * different data fork content type needs a different callout to do the 101030f712c9SDave Chinner * conversion. Some are basic and only require special block initialisation 101130f712c9SDave Chinner * callouts for the data formating, others (directories) are so specialised they 101230f712c9SDave Chinner * handle everything themselves. 101330f712c9SDave Chinner * 101430f712c9SDave Chinner * XXX (dgc): investigate whether directory conversion can use the generic 101530f712c9SDave Chinner * formatting callout. It should be possible - it's just a very complex 101630f712c9SDave Chinner * formatter. 101730f712c9SDave Chinner */ 101830f712c9SDave Chinner STATIC int /* error */ 101930f712c9SDave Chinner xfs_bmap_add_attrfork_local( 102030f712c9SDave Chinner xfs_trans_t *tp, /* transaction pointer */ 102130f712c9SDave Chinner xfs_inode_t *ip, /* incore inode pointer */ 102230f712c9SDave Chinner xfs_fsblock_t *firstblock, /* first block allocated */ 10232c3234d1SDarrick J. Wong struct xfs_defer_ops *dfops, /* blocks to free at commit */ 102430f712c9SDave Chinner int *flags) /* inode logging flags */ 102530f712c9SDave Chinner { 102630f712c9SDave Chinner xfs_da_args_t dargs; /* args for dir/attr code */ 102730f712c9SDave Chinner 102830f712c9SDave Chinner if (ip->i_df.if_bytes <= XFS_IFORK_DSIZE(ip)) 102930f712c9SDave Chinner return 0; 103030f712c9SDave Chinner 1031c19b3b05SDave Chinner if (S_ISDIR(VFS_I(ip)->i_mode)) { 103230f712c9SDave Chinner memset(&dargs, 0, sizeof(dargs)); 103330f712c9SDave Chinner dargs.geo = ip->i_mount->m_dir_geo; 103430f712c9SDave Chinner dargs.dp = ip; 103530f712c9SDave Chinner dargs.firstblock = firstblock; 10362c3234d1SDarrick J. Wong dargs.dfops = dfops; 103730f712c9SDave Chinner dargs.total = dargs.geo->fsbcount; 103830f712c9SDave Chinner dargs.whichfork = XFS_DATA_FORK; 103930f712c9SDave Chinner dargs.trans = tp; 104030f712c9SDave Chinner return xfs_dir2_sf_to_block(&dargs); 104130f712c9SDave Chinner } 104230f712c9SDave Chinner 1043c19b3b05SDave Chinner if (S_ISLNK(VFS_I(ip)->i_mode)) 104430f712c9SDave Chinner return xfs_bmap_local_to_extents(tp, ip, firstblock, 1, 104530f712c9SDave Chinner flags, XFS_DATA_FORK, 104630f712c9SDave Chinner xfs_symlink_local_to_remote); 104730f712c9SDave Chinner 104830f712c9SDave Chinner /* should only be called for types that support local format data */ 104930f712c9SDave Chinner ASSERT(0); 10502451337dSDave Chinner return -EFSCORRUPTED; 105130f712c9SDave Chinner } 105230f712c9SDave Chinner 105330f712c9SDave Chinner /* 105430f712c9SDave Chinner * Convert inode from non-attributed to attributed. 105530f712c9SDave Chinner * Must not be in a transaction, ip must not be locked. 105630f712c9SDave Chinner */ 105730f712c9SDave Chinner int /* error code */ 105830f712c9SDave Chinner xfs_bmap_add_attrfork( 105930f712c9SDave Chinner xfs_inode_t *ip, /* incore inode pointer */ 106030f712c9SDave Chinner int size, /* space new attribute needs */ 106130f712c9SDave Chinner int rsvd) /* xact may use reserved blks */ 106230f712c9SDave Chinner { 106330f712c9SDave Chinner xfs_fsblock_t firstblock; /* 1st block/ag allocated */ 10642c3234d1SDarrick J. Wong struct xfs_defer_ops dfops; /* freed extent records */ 106530f712c9SDave Chinner xfs_mount_t *mp; /* mount structure */ 106630f712c9SDave Chinner xfs_trans_t *tp; /* transaction pointer */ 106730f712c9SDave Chinner int blks; /* space reservation */ 106830f712c9SDave Chinner int version = 1; /* superblock attr version */ 106930f712c9SDave Chinner int logflags; /* logging flags */ 107030f712c9SDave Chinner int error; /* error return value */ 107130f712c9SDave Chinner 107230f712c9SDave Chinner ASSERT(XFS_IFORK_Q(ip) == 0); 107330f712c9SDave Chinner 107430f712c9SDave Chinner mp = ip->i_mount; 107530f712c9SDave Chinner ASSERT(!XFS_NOT_DQATTACHED(mp, ip)); 1076253f4911SChristoph Hellwig 107730f712c9SDave Chinner blks = XFS_ADDAFORK_SPACE_RES(mp); 1078253f4911SChristoph Hellwig 1079253f4911SChristoph Hellwig error = xfs_trans_alloc(mp, &M_RES(mp)->tr_addafork, blks, 0, 1080253f4911SChristoph Hellwig rsvd ? XFS_TRANS_RESERVE : 0, &tp); 1081253f4911SChristoph Hellwig if (error) 108230f712c9SDave Chinner return error; 1083253f4911SChristoph Hellwig 108430f712c9SDave Chinner xfs_ilock(ip, XFS_ILOCK_EXCL); 108530f712c9SDave Chinner error = xfs_trans_reserve_quota_nblks(tp, ip, blks, 0, rsvd ? 108630f712c9SDave Chinner XFS_QMOPT_RES_REGBLKS | XFS_QMOPT_FORCE_RES : 108730f712c9SDave Chinner XFS_QMOPT_RES_REGBLKS); 108830f712c9SDave Chinner if (error) 108930f712c9SDave Chinner goto trans_cancel; 109030f712c9SDave Chinner if (XFS_IFORK_Q(ip)) 109130f712c9SDave Chinner goto trans_cancel; 10920f352f8eSDarrick J. Wong if (ip->i_d.di_anextents != 0) { 10930f352f8eSDarrick J. Wong error = -EFSCORRUPTED; 10940f352f8eSDarrick J. Wong goto trans_cancel; 10950f352f8eSDarrick J. Wong } 109630f712c9SDave Chinner if (ip->i_d.di_aformat != XFS_DINODE_FMT_EXTENTS) { 109730f712c9SDave Chinner /* 109830f712c9SDave Chinner * For inodes coming from pre-6.2 filesystems. 109930f712c9SDave Chinner */ 110030f712c9SDave Chinner ASSERT(ip->i_d.di_aformat == 0); 110130f712c9SDave Chinner ip->i_d.di_aformat = XFS_DINODE_FMT_EXTENTS; 110230f712c9SDave Chinner } 110330f712c9SDave Chinner 110430f712c9SDave Chinner xfs_trans_ijoin(tp, ip, 0); 110530f712c9SDave Chinner xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE); 110630f712c9SDave Chinner 110730f712c9SDave Chinner switch (ip->i_d.di_format) { 110830f712c9SDave Chinner case XFS_DINODE_FMT_DEV: 110930f712c9SDave Chinner ip->i_d.di_forkoff = roundup(sizeof(xfs_dev_t), 8) >> 3; 111030f712c9SDave Chinner break; 111130f712c9SDave Chinner case XFS_DINODE_FMT_UUID: 111230f712c9SDave Chinner ip->i_d.di_forkoff = roundup(sizeof(uuid_t), 8) >> 3; 111330f712c9SDave Chinner break; 111430f712c9SDave Chinner case XFS_DINODE_FMT_LOCAL: 111530f712c9SDave Chinner case XFS_DINODE_FMT_EXTENTS: 111630f712c9SDave Chinner case XFS_DINODE_FMT_BTREE: 111730f712c9SDave Chinner ip->i_d.di_forkoff = xfs_attr_shortform_bytesfit(ip, size); 111830f712c9SDave Chinner if (!ip->i_d.di_forkoff) 111930f712c9SDave Chinner ip->i_d.di_forkoff = xfs_default_attroffset(ip) >> 3; 112030f712c9SDave Chinner else if (mp->m_flags & XFS_MOUNT_ATTR2) 112130f712c9SDave Chinner version = 2; 112230f712c9SDave Chinner break; 112330f712c9SDave Chinner default: 112430f712c9SDave Chinner ASSERT(0); 11252451337dSDave Chinner error = -EINVAL; 112630f712c9SDave Chinner goto trans_cancel; 112730f712c9SDave Chinner } 112830f712c9SDave Chinner 112930f712c9SDave Chinner ASSERT(ip->i_afp == NULL); 113030f712c9SDave Chinner ip->i_afp = kmem_zone_zalloc(xfs_ifork_zone, KM_SLEEP); 113130f712c9SDave Chinner ip->i_afp->if_flags = XFS_IFEXTENTS; 113230f712c9SDave Chinner logflags = 0; 11332c3234d1SDarrick J. Wong xfs_defer_init(&dfops, &firstblock); 113430f712c9SDave Chinner switch (ip->i_d.di_format) { 113530f712c9SDave Chinner case XFS_DINODE_FMT_LOCAL: 11362c3234d1SDarrick J. Wong error = xfs_bmap_add_attrfork_local(tp, ip, &firstblock, &dfops, 113730f712c9SDave Chinner &logflags); 113830f712c9SDave Chinner break; 113930f712c9SDave Chinner case XFS_DINODE_FMT_EXTENTS: 114030f712c9SDave Chinner error = xfs_bmap_add_attrfork_extents(tp, ip, &firstblock, 11412c3234d1SDarrick J. Wong &dfops, &logflags); 114230f712c9SDave Chinner break; 114330f712c9SDave Chinner case XFS_DINODE_FMT_BTREE: 11442c3234d1SDarrick J. Wong error = xfs_bmap_add_attrfork_btree(tp, ip, &firstblock, &dfops, 114530f712c9SDave Chinner &logflags); 114630f712c9SDave Chinner break; 114730f712c9SDave Chinner default: 114830f712c9SDave Chinner error = 0; 114930f712c9SDave Chinner break; 115030f712c9SDave Chinner } 115130f712c9SDave Chinner if (logflags) 115230f712c9SDave Chinner xfs_trans_log_inode(tp, ip, logflags); 115330f712c9SDave Chinner if (error) 115430f712c9SDave Chinner goto bmap_cancel; 115530f712c9SDave Chinner if (!xfs_sb_version_hasattr(&mp->m_sb) || 115630f712c9SDave Chinner (!xfs_sb_version_hasattr2(&mp->m_sb) && version == 2)) { 115761e63ecbSDave Chinner bool log_sb = false; 115830f712c9SDave Chinner 115930f712c9SDave Chinner spin_lock(&mp->m_sb_lock); 116030f712c9SDave Chinner if (!xfs_sb_version_hasattr(&mp->m_sb)) { 116130f712c9SDave Chinner xfs_sb_version_addattr(&mp->m_sb); 116261e63ecbSDave Chinner log_sb = true; 116330f712c9SDave Chinner } 116430f712c9SDave Chinner if (!xfs_sb_version_hasattr2(&mp->m_sb) && version == 2) { 116530f712c9SDave Chinner xfs_sb_version_addattr2(&mp->m_sb); 116661e63ecbSDave Chinner log_sb = true; 116730f712c9SDave Chinner } 116830f712c9SDave Chinner spin_unlock(&mp->m_sb_lock); 116961e63ecbSDave Chinner if (log_sb) 117061e63ecbSDave Chinner xfs_log_sb(tp); 117130f712c9SDave Chinner } 117230f712c9SDave Chinner 11738ad7c629SChristoph Hellwig error = xfs_defer_finish(&tp, &dfops); 117430f712c9SDave Chinner if (error) 117530f712c9SDave Chinner goto bmap_cancel; 117670393313SChristoph Hellwig error = xfs_trans_commit(tp); 117730f712c9SDave Chinner xfs_iunlock(ip, XFS_ILOCK_EXCL); 117830f712c9SDave Chinner return error; 117930f712c9SDave Chinner 118030f712c9SDave Chinner bmap_cancel: 11812c3234d1SDarrick J. Wong xfs_defer_cancel(&dfops); 118230f712c9SDave Chinner trans_cancel: 11834906e215SChristoph Hellwig xfs_trans_cancel(tp); 118430f712c9SDave Chinner xfs_iunlock(ip, XFS_ILOCK_EXCL); 118530f712c9SDave Chinner return error; 118630f712c9SDave Chinner } 118730f712c9SDave Chinner 118830f712c9SDave Chinner /* 118930f712c9SDave Chinner * Internal and external extent tree search functions. 119030f712c9SDave Chinner */ 119130f712c9SDave Chinner 119230f712c9SDave Chinner /* 119330f712c9SDave Chinner * Read in the extents to if_extents. 119430f712c9SDave Chinner * All inode fields are set up by caller, we just traverse the btree 119530f712c9SDave Chinner * and copy the records in. If the file system cannot contain unwritten 119630f712c9SDave Chinner * extents, the records are checked for no "state" flags. 119730f712c9SDave Chinner */ 119830f712c9SDave Chinner int /* error */ 119930f712c9SDave Chinner xfs_bmap_read_extents( 120030f712c9SDave Chinner xfs_trans_t *tp, /* transaction pointer */ 120130f712c9SDave Chinner xfs_inode_t *ip, /* incore inode */ 120230f712c9SDave Chinner int whichfork) /* data or attr fork */ 120330f712c9SDave Chinner { 120430f712c9SDave Chinner struct xfs_btree_block *block; /* current btree block */ 120530f712c9SDave Chinner xfs_fsblock_t bno; /* block # of "block" */ 120630f712c9SDave Chinner xfs_buf_t *bp; /* buffer for "block" */ 120730f712c9SDave Chinner int error; /* error return value */ 120830f712c9SDave Chinner xfs_extnum_t i, j; /* index into the extents list */ 120930f712c9SDave Chinner xfs_ifork_t *ifp; /* fork structure */ 121030f712c9SDave Chinner int level; /* btree level, for checking */ 121130f712c9SDave Chinner xfs_mount_t *mp; /* file system mount structure */ 121230f712c9SDave Chinner __be64 *pp; /* pointer to block address */ 121330f712c9SDave Chinner /* REFERENCED */ 121430f712c9SDave Chinner xfs_extnum_t room; /* number of entries there's room for */ 121530f712c9SDave Chinner 121630f712c9SDave Chinner mp = ip->i_mount; 121730f712c9SDave Chinner ifp = XFS_IFORK_PTR(ip, whichfork); 121830f712c9SDave Chinner block = ifp->if_broot; 121930f712c9SDave Chinner /* 122030f712c9SDave Chinner * Root level must use BMAP_BROOT_PTR_ADDR macro to get ptr out. 122130f712c9SDave Chinner */ 122230f712c9SDave Chinner level = be16_to_cpu(block->bb_level); 122330f712c9SDave Chinner ASSERT(level > 0); 122430f712c9SDave Chinner pp = XFS_BMAP_BROOT_PTR_ADDR(mp, block, 1, ifp->if_broot_bytes); 122530f712c9SDave Chinner bno = be64_to_cpu(*pp); 1226d5a91baeSDarrick J. Wong 122730f712c9SDave Chinner /* 122830f712c9SDave Chinner * Go down the tree until leaf level is reached, following the first 122930f712c9SDave Chinner * pointer (leftmost) at each level. 123030f712c9SDave Chinner */ 123130f712c9SDave Chinner while (level-- > 0) { 123230f712c9SDave Chinner error = xfs_btree_read_bufl(mp, tp, bno, 0, &bp, 123330f712c9SDave Chinner XFS_BMAP_BTREE_REF, &xfs_bmbt_buf_ops); 123430f712c9SDave Chinner if (error) 123530f712c9SDave Chinner return error; 123630f712c9SDave Chinner block = XFS_BUF_TO_BLOCK(bp); 123730f712c9SDave Chinner if (level == 0) 123830f712c9SDave Chinner break; 123930f712c9SDave Chinner pp = XFS_BMBT_PTR_ADDR(mp, block, 1, mp->m_bmap_dmxr[1]); 124030f712c9SDave Chinner bno = be64_to_cpu(*pp); 1241c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, 1242c29aad41SEric Sandeen XFS_FSB_SANITY_CHECK(mp, bno), error0); 124330f712c9SDave Chinner xfs_trans_brelse(tp, bp); 124430f712c9SDave Chinner } 124530f712c9SDave Chinner /* 124630f712c9SDave Chinner * Here with bp and block set to the leftmost leaf node in the tree. 124730f712c9SDave Chinner */ 12485d829300SEric Sandeen room = xfs_iext_count(ifp); 124930f712c9SDave Chinner i = 0; 125030f712c9SDave Chinner /* 125130f712c9SDave Chinner * Loop over all leaf nodes. Copy information to the extent records. 125230f712c9SDave Chinner */ 125330f712c9SDave Chinner for (;;) { 125430f712c9SDave Chinner xfs_bmbt_rec_t *frp; 125530f712c9SDave Chinner xfs_fsblock_t nextbno; 125630f712c9SDave Chinner xfs_extnum_t num_recs; 125730f712c9SDave Chinner 125830f712c9SDave Chinner num_recs = xfs_btree_get_numrecs(block); 125930f712c9SDave Chinner if (unlikely(i + num_recs > room)) { 126030f712c9SDave Chinner ASSERT(i + num_recs <= room); 126130f712c9SDave Chinner xfs_warn(ip->i_mount, 126230f712c9SDave Chinner "corrupt dinode %Lu, (btree extents).", 126330f712c9SDave Chinner (unsigned long long) ip->i_ino); 126430f712c9SDave Chinner XFS_CORRUPTION_ERROR("xfs_bmap_read_extents(1)", 126530f712c9SDave Chinner XFS_ERRLEVEL_LOW, ip->i_mount, block); 126630f712c9SDave Chinner goto error0; 126730f712c9SDave Chinner } 126830f712c9SDave Chinner /* 126930f712c9SDave Chinner * Read-ahead the next leaf block, if any. 127030f712c9SDave Chinner */ 127130f712c9SDave Chinner nextbno = be64_to_cpu(block->bb_u.l.bb_rightsib); 127230f712c9SDave Chinner if (nextbno != NULLFSBLOCK) 127330f712c9SDave Chinner xfs_btree_reada_bufl(mp, nextbno, 1, 127430f712c9SDave Chinner &xfs_bmbt_buf_ops); 127530f712c9SDave Chinner /* 127630f712c9SDave Chinner * Copy records into the extent records. 127730f712c9SDave Chinner */ 127830f712c9SDave Chinner frp = XFS_BMBT_REC_ADDR(mp, block, 1); 127930f712c9SDave Chinner for (j = 0; j < num_recs; j++, i++, frp++) { 128030f712c9SDave Chinner xfs_bmbt_rec_host_t *trp = xfs_iext_get_ext(ifp, i); 128130f712c9SDave Chinner trp->l0 = be64_to_cpu(frp->l0); 128230f712c9SDave Chinner trp->l1 = be64_to_cpu(frp->l1); 12830c1d9e4aSChristoph Hellwig if (!xfs_bmbt_validate_extent(mp, whichfork, trp)) { 128430f712c9SDave Chinner XFS_ERROR_REPORT("xfs_bmap_read_extents(2)", 12850c1d9e4aSChristoph Hellwig XFS_ERRLEVEL_LOW, mp); 128630f712c9SDave Chinner goto error0; 128730f712c9SDave Chinner } 128830f712c9SDave Chinner } 128930f712c9SDave Chinner xfs_trans_brelse(tp, bp); 129030f712c9SDave Chinner bno = nextbno; 129130f712c9SDave Chinner /* 129230f712c9SDave Chinner * If we've reached the end, stop. 129330f712c9SDave Chinner */ 129430f712c9SDave Chinner if (bno == NULLFSBLOCK) 129530f712c9SDave Chinner break; 129630f712c9SDave Chinner error = xfs_btree_read_bufl(mp, tp, bno, 0, &bp, 129730f712c9SDave Chinner XFS_BMAP_BTREE_REF, &xfs_bmbt_buf_ops); 129830f712c9SDave Chinner if (error) 129930f712c9SDave Chinner return error; 130030f712c9SDave Chinner block = XFS_BUF_TO_BLOCK(bp); 130130f712c9SDave Chinner } 1302356a3225SDarrick J. Wong if (i != XFS_IFORK_NEXTENTS(ip, whichfork)) 1303356a3225SDarrick J. Wong return -EFSCORRUPTED; 13045d829300SEric Sandeen ASSERT(i == xfs_iext_count(ifp)); 130530f712c9SDave Chinner XFS_BMAP_TRACE_EXLIST(ip, i, whichfork); 130630f712c9SDave Chinner return 0; 130730f712c9SDave Chinner error0: 130830f712c9SDave Chinner xfs_trans_brelse(tp, bp); 13092451337dSDave Chinner return -EFSCORRUPTED; 131030f712c9SDave Chinner } 131130f712c9SDave Chinner 131230f712c9SDave Chinner /* 131330f712c9SDave Chinner * Returns the file-relative block number of the first unused block(s) 131430f712c9SDave Chinner * in the file with at least "len" logically contiguous blocks free. 131530f712c9SDave Chinner * This is the lowest-address hole if the file has holes, else the first block 131630f712c9SDave Chinner * past the end of file. 131730f712c9SDave Chinner * Return 0 if the file is currently local (in-inode). 131830f712c9SDave Chinner */ 131930f712c9SDave Chinner int /* error */ 132030f712c9SDave Chinner xfs_bmap_first_unused( 132130f712c9SDave Chinner xfs_trans_t *tp, /* transaction pointer */ 132230f712c9SDave Chinner xfs_inode_t *ip, /* incore inode */ 132330f712c9SDave Chinner xfs_extlen_t len, /* size of hole to find */ 132430f712c9SDave Chinner xfs_fileoff_t *first_unused, /* unused block */ 132530f712c9SDave Chinner int whichfork) /* data or attr fork */ 132630f712c9SDave Chinner { 132730f712c9SDave Chinner int error; /* error return value */ 132830f712c9SDave Chinner int idx; /* extent record index */ 132930f712c9SDave Chinner xfs_ifork_t *ifp; /* inode fork pointer */ 133030f712c9SDave Chinner xfs_fileoff_t lastaddr; /* last block number seen */ 133130f712c9SDave Chinner xfs_fileoff_t lowest; /* lowest useful block */ 133230f712c9SDave Chinner xfs_fileoff_t max; /* starting useful block */ 133330f712c9SDave Chinner xfs_extnum_t nextents; /* number of extent entries */ 133430f712c9SDave Chinner 133530f712c9SDave Chinner ASSERT(XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_BTREE || 133630f712c9SDave Chinner XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_EXTENTS || 133730f712c9SDave Chinner XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_LOCAL); 133830f712c9SDave Chinner if (XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_LOCAL) { 133930f712c9SDave Chinner *first_unused = 0; 134030f712c9SDave Chinner return 0; 134130f712c9SDave Chinner } 134230f712c9SDave Chinner ifp = XFS_IFORK_PTR(ip, whichfork); 134330f712c9SDave Chinner if (!(ifp->if_flags & XFS_IFEXTENTS) && 134430f712c9SDave Chinner (error = xfs_iread_extents(tp, ip, whichfork))) 134530f712c9SDave Chinner return error; 134630f712c9SDave Chinner lowest = *first_unused; 13475d829300SEric Sandeen nextents = xfs_iext_count(ifp); 134830f712c9SDave Chinner for (idx = 0, lastaddr = 0, max = lowest; idx < nextents; idx++) { 1349f2285c14SChristoph Hellwig struct xfs_bmbt_irec got; 1350f2285c14SChristoph Hellwig 1351f2285c14SChristoph Hellwig xfs_iext_get_extent(ifp, idx, &got); 1352f2285c14SChristoph Hellwig 135330f712c9SDave Chinner /* 135430f712c9SDave Chinner * See if the hole before this extent will work. 135530f712c9SDave Chinner */ 1356f2285c14SChristoph Hellwig if (got.br_startoff >= lowest + len && 1357f2285c14SChristoph Hellwig got.br_startoff - max >= len) { 135830f712c9SDave Chinner *first_unused = max; 135930f712c9SDave Chinner return 0; 136030f712c9SDave Chinner } 1361f2285c14SChristoph Hellwig lastaddr = got.br_startoff + got.br_blockcount; 136230f712c9SDave Chinner max = XFS_FILEOFF_MAX(lastaddr, lowest); 136330f712c9SDave Chinner } 136430f712c9SDave Chinner *first_unused = max; 136530f712c9SDave Chinner return 0; 136630f712c9SDave Chinner } 136730f712c9SDave Chinner 136830f712c9SDave Chinner /* 136930f712c9SDave Chinner * Returns the file-relative block number of the last block - 1 before 137030f712c9SDave Chinner * last_block (input value) in the file. 137130f712c9SDave Chinner * This is not based on i_size, it is based on the extent records. 137230f712c9SDave Chinner * Returns 0 for local files, as they do not have extent records. 137330f712c9SDave Chinner */ 137430f712c9SDave Chinner int /* error */ 137530f712c9SDave Chinner xfs_bmap_last_before( 137686685f7bSChristoph Hellwig struct xfs_trans *tp, /* transaction pointer */ 137786685f7bSChristoph Hellwig struct xfs_inode *ip, /* incore inode */ 137830f712c9SDave Chinner xfs_fileoff_t *last_block, /* last block */ 137930f712c9SDave Chinner int whichfork) /* data or attr fork */ 138030f712c9SDave Chinner { 138186685f7bSChristoph Hellwig struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, whichfork); 138286685f7bSChristoph Hellwig struct xfs_bmbt_irec got; 138386685f7bSChristoph Hellwig xfs_extnum_t idx; 138486685f7bSChristoph Hellwig int error; 138530f712c9SDave Chinner 138686685f7bSChristoph Hellwig switch (XFS_IFORK_FORMAT(ip, whichfork)) { 138786685f7bSChristoph Hellwig case XFS_DINODE_FMT_LOCAL: 138830f712c9SDave Chinner *last_block = 0; 138930f712c9SDave Chinner return 0; 139086685f7bSChristoph Hellwig case XFS_DINODE_FMT_BTREE: 139186685f7bSChristoph Hellwig case XFS_DINODE_FMT_EXTENTS: 139286685f7bSChristoph Hellwig break; 139386685f7bSChristoph Hellwig default: 139486685f7bSChristoph Hellwig return -EIO; 139530f712c9SDave Chinner } 139686685f7bSChristoph Hellwig 139786685f7bSChristoph Hellwig if (!(ifp->if_flags & XFS_IFEXTENTS)) { 139886685f7bSChristoph Hellwig error = xfs_iread_extents(tp, ip, whichfork); 139986685f7bSChristoph Hellwig if (error) 140030f712c9SDave Chinner return error; 140130f712c9SDave Chinner } 140286685f7bSChristoph Hellwig 140386685f7bSChristoph Hellwig if (xfs_iext_lookup_extent(ip, ifp, *last_block - 1, &idx, &got)) { 140486685f7bSChristoph Hellwig if (got.br_startoff <= *last_block - 1) 140586685f7bSChristoph Hellwig return 0; 140686685f7bSChristoph Hellwig } 140786685f7bSChristoph Hellwig 140886685f7bSChristoph Hellwig if (xfs_iext_get_extent(ifp, idx - 1, &got)) { 140986685f7bSChristoph Hellwig *last_block = got.br_startoff + got.br_blockcount; 141086685f7bSChristoph Hellwig return 0; 141186685f7bSChristoph Hellwig } 141286685f7bSChristoph Hellwig 141386685f7bSChristoph Hellwig *last_block = 0; 141430f712c9SDave Chinner return 0; 141530f712c9SDave Chinner } 141630f712c9SDave Chinner 141730f712c9SDave Chinner int 141830f712c9SDave Chinner xfs_bmap_last_extent( 141930f712c9SDave Chinner struct xfs_trans *tp, 142030f712c9SDave Chinner struct xfs_inode *ip, 142130f712c9SDave Chinner int whichfork, 142230f712c9SDave Chinner struct xfs_bmbt_irec *rec, 142330f712c9SDave Chinner int *is_empty) 142430f712c9SDave Chinner { 142530f712c9SDave Chinner struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, whichfork); 142630f712c9SDave Chinner int error; 142730f712c9SDave Chinner int nextents; 142830f712c9SDave Chinner 142930f712c9SDave Chinner if (!(ifp->if_flags & XFS_IFEXTENTS)) { 143030f712c9SDave Chinner error = xfs_iread_extents(tp, ip, whichfork); 143130f712c9SDave Chinner if (error) 143230f712c9SDave Chinner return error; 143330f712c9SDave Chinner } 143430f712c9SDave Chinner 14355d829300SEric Sandeen nextents = xfs_iext_count(ifp); 143630f712c9SDave Chinner if (nextents == 0) { 143730f712c9SDave Chinner *is_empty = 1; 143830f712c9SDave Chinner return 0; 143930f712c9SDave Chinner } 144030f712c9SDave Chinner 1441e3f0f756SChristoph Hellwig xfs_iext_get_extent(ifp, nextents - 1, rec); 144230f712c9SDave Chinner *is_empty = 0; 144330f712c9SDave Chinner return 0; 144430f712c9SDave Chinner } 144530f712c9SDave Chinner 144630f712c9SDave Chinner /* 144730f712c9SDave Chinner * Check the last inode extent to determine whether this allocation will result 144830f712c9SDave Chinner * in blocks being allocated at the end of the file. When we allocate new data 144930f712c9SDave Chinner * blocks at the end of the file which do not start at the previous data block, 145030f712c9SDave Chinner * we will try to align the new blocks at stripe unit boundaries. 145130f712c9SDave Chinner * 145230f712c9SDave Chinner * Returns 1 in bma->aeof if the file (fork) is empty as any new write will be 145330f712c9SDave Chinner * at, or past the EOF. 145430f712c9SDave Chinner */ 145530f712c9SDave Chinner STATIC int 145630f712c9SDave Chinner xfs_bmap_isaeof( 145730f712c9SDave Chinner struct xfs_bmalloca *bma, 145830f712c9SDave Chinner int whichfork) 145930f712c9SDave Chinner { 146030f712c9SDave Chinner struct xfs_bmbt_irec rec; 146130f712c9SDave Chinner int is_empty; 146230f712c9SDave Chinner int error; 146330f712c9SDave Chinner 1464749f24f3SThomas Meyer bma->aeof = false; 146530f712c9SDave Chinner error = xfs_bmap_last_extent(NULL, bma->ip, whichfork, &rec, 146630f712c9SDave Chinner &is_empty); 146730f712c9SDave Chinner if (error) 146830f712c9SDave Chinner return error; 146930f712c9SDave Chinner 147030f712c9SDave Chinner if (is_empty) { 1471749f24f3SThomas Meyer bma->aeof = true; 147230f712c9SDave Chinner return 0; 147330f712c9SDave Chinner } 147430f712c9SDave Chinner 147530f712c9SDave Chinner /* 147630f712c9SDave Chinner * Check if we are allocation or past the last extent, or at least into 147730f712c9SDave Chinner * the last delayed allocated extent. 147830f712c9SDave Chinner */ 147930f712c9SDave Chinner bma->aeof = bma->offset >= rec.br_startoff + rec.br_blockcount || 148030f712c9SDave Chinner (bma->offset >= rec.br_startoff && 148130f712c9SDave Chinner isnullstartblock(rec.br_startblock)); 148230f712c9SDave Chinner return 0; 148330f712c9SDave Chinner } 148430f712c9SDave Chinner 148530f712c9SDave Chinner /* 148630f712c9SDave Chinner * Returns the file-relative block number of the first block past eof in 148730f712c9SDave Chinner * the file. This is not based on i_size, it is based on the extent records. 148830f712c9SDave Chinner * Returns 0 for local files, as they do not have extent records. 148930f712c9SDave Chinner */ 149030f712c9SDave Chinner int 149130f712c9SDave Chinner xfs_bmap_last_offset( 149230f712c9SDave Chinner struct xfs_inode *ip, 149330f712c9SDave Chinner xfs_fileoff_t *last_block, 149430f712c9SDave Chinner int whichfork) 149530f712c9SDave Chinner { 149630f712c9SDave Chinner struct xfs_bmbt_irec rec; 149730f712c9SDave Chinner int is_empty; 149830f712c9SDave Chinner int error; 149930f712c9SDave Chinner 150030f712c9SDave Chinner *last_block = 0; 150130f712c9SDave Chinner 150230f712c9SDave Chinner if (XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_LOCAL) 150330f712c9SDave Chinner return 0; 150430f712c9SDave Chinner 150530f712c9SDave Chinner if (XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE && 150630f712c9SDave Chinner XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS) 15072451337dSDave Chinner return -EIO; 150830f712c9SDave Chinner 150930f712c9SDave Chinner error = xfs_bmap_last_extent(NULL, ip, whichfork, &rec, &is_empty); 151030f712c9SDave Chinner if (error || is_empty) 151130f712c9SDave Chinner return error; 151230f712c9SDave Chinner 151330f712c9SDave Chinner *last_block = rec.br_startoff + rec.br_blockcount; 151430f712c9SDave Chinner return 0; 151530f712c9SDave Chinner } 151630f712c9SDave Chinner 151730f712c9SDave Chinner /* 151830f712c9SDave Chinner * Returns whether the selected fork of the inode has exactly one 151930f712c9SDave Chinner * block or not. For the data fork we check this matches di_size, 152030f712c9SDave Chinner * implying the file's range is 0..bsize-1. 152130f712c9SDave Chinner */ 152230f712c9SDave Chinner int /* 1=>1 block, 0=>otherwise */ 152330f712c9SDave Chinner xfs_bmap_one_block( 152430f712c9SDave Chinner xfs_inode_t *ip, /* incore inode */ 152530f712c9SDave Chinner int whichfork) /* data or attr fork */ 152630f712c9SDave Chinner { 152730f712c9SDave Chinner xfs_ifork_t *ifp; /* inode fork pointer */ 152830f712c9SDave Chinner int rval; /* return value */ 152930f712c9SDave Chinner xfs_bmbt_irec_t s; /* internal version of extent */ 153030f712c9SDave Chinner 153130f712c9SDave Chinner #ifndef DEBUG 153230f712c9SDave Chinner if (whichfork == XFS_DATA_FORK) 153330f712c9SDave Chinner return XFS_ISIZE(ip) == ip->i_mount->m_sb.sb_blocksize; 153430f712c9SDave Chinner #endif /* !DEBUG */ 153530f712c9SDave Chinner if (XFS_IFORK_NEXTENTS(ip, whichfork) != 1) 153630f712c9SDave Chinner return 0; 153730f712c9SDave Chinner if (XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS) 153830f712c9SDave Chinner return 0; 153930f712c9SDave Chinner ifp = XFS_IFORK_PTR(ip, whichfork); 154030f712c9SDave Chinner ASSERT(ifp->if_flags & XFS_IFEXTENTS); 1541e3f0f756SChristoph Hellwig xfs_iext_get_extent(ifp, 0, &s); 154230f712c9SDave Chinner rval = s.br_startoff == 0 && s.br_blockcount == 1; 154330f712c9SDave Chinner if (rval && whichfork == XFS_DATA_FORK) 154430f712c9SDave Chinner ASSERT(XFS_ISIZE(ip) == ip->i_mount->m_sb.sb_blocksize); 154530f712c9SDave Chinner return rval; 154630f712c9SDave Chinner } 154730f712c9SDave Chinner 154830f712c9SDave Chinner /* 154930f712c9SDave Chinner * Extent tree manipulation functions used during allocation. 155030f712c9SDave Chinner */ 155130f712c9SDave Chinner 155230f712c9SDave Chinner /* 155330f712c9SDave Chinner * Convert a delayed allocation to a real allocation. 155430f712c9SDave Chinner */ 155530f712c9SDave Chinner STATIC int /* error */ 155630f712c9SDave Chinner xfs_bmap_add_extent_delay_real( 155760b4984fSDarrick J. Wong struct xfs_bmalloca *bma, 155860b4984fSDarrick J. Wong int whichfork) 155930f712c9SDave Chinner { 156030f712c9SDave Chinner struct xfs_bmbt_irec *new = &bma->got; 156130f712c9SDave Chinner int error; /* error return value */ 156230f712c9SDave Chinner int i; /* temp state */ 156330f712c9SDave Chinner xfs_ifork_t *ifp; /* inode fork pointer */ 156430f712c9SDave Chinner xfs_fileoff_t new_endoff; /* end offset of new entry */ 156530f712c9SDave Chinner xfs_bmbt_irec_t r[3]; /* neighbor extent entries */ 156630f712c9SDave Chinner /* left is 0, right is 1, prev is 2 */ 156730f712c9SDave Chinner int rval=0; /* return value (logging flags) */ 1568060ea65bSChristoph Hellwig int state = xfs_bmap_fork_to_state(whichfork); 156930f712c9SDave Chinner xfs_filblks_t da_new; /* new count del alloc blocks used */ 157030f712c9SDave Chinner xfs_filblks_t da_old; /* old count del alloc blocks used */ 157130f712c9SDave Chinner xfs_filblks_t temp=0; /* value for da_new calculations */ 157230f712c9SDave Chinner int tmp_rval; /* partial logging flags */ 1573c29aad41SEric Sandeen struct xfs_mount *mp; 157460b4984fSDarrick J. Wong xfs_extnum_t *nextents; 15754dcb8869SChristoph Hellwig struct xfs_bmbt_irec old; 157630f712c9SDave Chinner 1577f1f96c49SEric Sandeen mp = bma->ip->i_mount; 15786d3eb1ecSDarrick J. Wong ifp = XFS_IFORK_PTR(bma->ip, whichfork); 157960b4984fSDarrick J. Wong ASSERT(whichfork != XFS_ATTR_FORK); 158060b4984fSDarrick J. Wong nextents = (whichfork == XFS_COW_FORK ? &bma->ip->i_cnextents : 158160b4984fSDarrick J. Wong &bma->ip->i_d.di_nextents); 158230f712c9SDave Chinner 158330f712c9SDave Chinner ASSERT(bma->idx >= 0); 15845d829300SEric Sandeen ASSERT(bma->idx <= xfs_iext_count(ifp)); 158530f712c9SDave Chinner ASSERT(!isnullstartblock(new->br_startblock)); 158630f712c9SDave Chinner ASSERT(!bma->cur || 158730f712c9SDave Chinner (bma->cur->bc_private.b.flags & XFS_BTCUR_BPRV_WASDEL)); 158830f712c9SDave Chinner 1589ff6d6af2SBill O'Donnell XFS_STATS_INC(mp, xs_add_exlist); 159030f712c9SDave Chinner 159130f712c9SDave Chinner #define LEFT r[0] 159230f712c9SDave Chinner #define RIGHT r[1] 159330f712c9SDave Chinner #define PREV r[2] 159430f712c9SDave Chinner 159530f712c9SDave Chinner /* 159630f712c9SDave Chinner * Set up a bunch of variables to make the tests simpler. 159730f712c9SDave Chinner */ 15984dcb8869SChristoph Hellwig xfs_iext_get_extent(ifp, bma->idx, &PREV); 159930f712c9SDave Chinner new_endoff = new->br_startoff + new->br_blockcount; 16004dcb8869SChristoph Hellwig ASSERT(isnullstartblock(PREV.br_startblock)); 160130f712c9SDave Chinner ASSERT(PREV.br_startoff <= new->br_startoff); 160230f712c9SDave Chinner ASSERT(PREV.br_startoff + PREV.br_blockcount >= new_endoff); 160330f712c9SDave Chinner 160430f712c9SDave Chinner da_old = startblockval(PREV.br_startblock); 160530f712c9SDave Chinner da_new = 0; 160630f712c9SDave Chinner 160730f712c9SDave Chinner /* 160830f712c9SDave Chinner * Set flags determining what part of the previous delayed allocation 160930f712c9SDave Chinner * extent is being replaced by a real allocation. 161030f712c9SDave Chinner */ 161130f712c9SDave Chinner if (PREV.br_startoff == new->br_startoff) 161230f712c9SDave Chinner state |= BMAP_LEFT_FILLING; 161330f712c9SDave Chinner if (PREV.br_startoff + PREV.br_blockcount == new_endoff) 161430f712c9SDave Chinner state |= BMAP_RIGHT_FILLING; 161530f712c9SDave Chinner 161630f712c9SDave Chinner /* 161730f712c9SDave Chinner * Check and set flags if this segment has a left neighbor. 161830f712c9SDave Chinner * Don't set contiguous if the combined extent would be too large. 161930f712c9SDave Chinner */ 162030f712c9SDave Chinner if (bma->idx > 0) { 162130f712c9SDave Chinner state |= BMAP_LEFT_VALID; 1622e3f0f756SChristoph Hellwig xfs_iext_get_extent(ifp, bma->idx - 1, &LEFT); 162330f712c9SDave Chinner 162430f712c9SDave Chinner if (isnullstartblock(LEFT.br_startblock)) 162530f712c9SDave Chinner state |= BMAP_LEFT_DELAY; 162630f712c9SDave Chinner } 162730f712c9SDave Chinner 162830f712c9SDave Chinner if ((state & BMAP_LEFT_VALID) && !(state & BMAP_LEFT_DELAY) && 162930f712c9SDave Chinner LEFT.br_startoff + LEFT.br_blockcount == new->br_startoff && 163030f712c9SDave Chinner LEFT.br_startblock + LEFT.br_blockcount == new->br_startblock && 163130f712c9SDave Chinner LEFT.br_state == new->br_state && 163230f712c9SDave Chinner LEFT.br_blockcount + new->br_blockcount <= MAXEXTLEN) 163330f712c9SDave Chinner state |= BMAP_LEFT_CONTIG; 163430f712c9SDave Chinner 163530f712c9SDave Chinner /* 163630f712c9SDave Chinner * Check and set flags if this segment has a right neighbor. 163730f712c9SDave Chinner * Don't set contiguous if the combined extent would be too large. 163830f712c9SDave Chinner * Also check for all-three-contiguous being too large. 163930f712c9SDave Chinner */ 16405d829300SEric Sandeen if (bma->idx < xfs_iext_count(ifp) - 1) { 164130f712c9SDave Chinner state |= BMAP_RIGHT_VALID; 1642e3f0f756SChristoph Hellwig xfs_iext_get_extent(ifp, bma->idx + 1, &RIGHT); 164330f712c9SDave Chinner 164430f712c9SDave Chinner if (isnullstartblock(RIGHT.br_startblock)) 164530f712c9SDave Chinner state |= BMAP_RIGHT_DELAY; 164630f712c9SDave Chinner } 164730f712c9SDave Chinner 164830f712c9SDave Chinner if ((state & BMAP_RIGHT_VALID) && !(state & BMAP_RIGHT_DELAY) && 164930f712c9SDave Chinner new_endoff == RIGHT.br_startoff && 165030f712c9SDave Chinner new->br_startblock + new->br_blockcount == RIGHT.br_startblock && 165130f712c9SDave Chinner new->br_state == RIGHT.br_state && 165230f712c9SDave Chinner new->br_blockcount + RIGHT.br_blockcount <= MAXEXTLEN && 165330f712c9SDave Chinner ((state & (BMAP_LEFT_CONTIG | BMAP_LEFT_FILLING | 165430f712c9SDave Chinner BMAP_RIGHT_FILLING)) != 165530f712c9SDave Chinner (BMAP_LEFT_CONTIG | BMAP_LEFT_FILLING | 165630f712c9SDave Chinner BMAP_RIGHT_FILLING) || 165730f712c9SDave Chinner LEFT.br_blockcount + new->br_blockcount + RIGHT.br_blockcount 165830f712c9SDave Chinner <= MAXEXTLEN)) 165930f712c9SDave Chinner state |= BMAP_RIGHT_CONTIG; 166030f712c9SDave Chinner 166130f712c9SDave Chinner error = 0; 166230f712c9SDave Chinner /* 166330f712c9SDave Chinner * Switch out based on the FILLING and CONTIG state bits. 166430f712c9SDave Chinner */ 166530f712c9SDave Chinner switch (state & (BMAP_LEFT_FILLING | BMAP_LEFT_CONTIG | 166630f712c9SDave Chinner BMAP_RIGHT_FILLING | BMAP_RIGHT_CONTIG)) { 166730f712c9SDave Chinner case BMAP_LEFT_FILLING | BMAP_LEFT_CONTIG | 166830f712c9SDave Chinner BMAP_RIGHT_FILLING | BMAP_RIGHT_CONTIG: 166930f712c9SDave Chinner /* 167030f712c9SDave Chinner * Filling in all of a previously delayed allocation extent. 167130f712c9SDave Chinner * The left and right neighbors are both contiguous with new. 167230f712c9SDave Chinner */ 167330f712c9SDave Chinner bma->idx--; 167430f712c9SDave Chinner trace_xfs_bmap_pre_update(bma->ip, bma->idx, state, _THIS_IP_); 16754dcb8869SChristoph Hellwig LEFT.br_blockcount += PREV.br_blockcount + RIGHT.br_blockcount; 16764dcb8869SChristoph Hellwig xfs_iext_update_extent(ifp, bma->idx, &LEFT); 167730f712c9SDave Chinner trace_xfs_bmap_post_update(bma->ip, bma->idx, state, _THIS_IP_); 167830f712c9SDave Chinner 167930f712c9SDave Chinner xfs_iext_remove(bma->ip, bma->idx + 1, 2, state); 168060b4984fSDarrick J. Wong (*nextents)--; 168130f712c9SDave Chinner if (bma->cur == NULL) 168230f712c9SDave Chinner rval = XFS_ILOG_CORE | XFS_ILOG_DEXT; 168330f712c9SDave Chinner else { 168430f712c9SDave Chinner rval = XFS_ILOG_CORE; 1685e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(bma->cur, &RIGHT, &i); 168630f712c9SDave Chinner if (error) 168730f712c9SDave Chinner goto done; 1688c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 168930f712c9SDave Chinner error = xfs_btree_delete(bma->cur, &i); 169030f712c9SDave Chinner if (error) 169130f712c9SDave Chinner goto done; 1692c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 169330f712c9SDave Chinner error = xfs_btree_decrement(bma->cur, 0, &i); 169430f712c9SDave Chinner if (error) 169530f712c9SDave Chinner goto done; 1696c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 1697a67d00a5SChristoph Hellwig error = xfs_bmbt_update(bma->cur, &LEFT); 169830f712c9SDave Chinner if (error) 169930f712c9SDave Chinner goto done; 170030f712c9SDave Chinner } 170130f712c9SDave Chinner break; 170230f712c9SDave Chinner 170330f712c9SDave Chinner case BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING | BMAP_LEFT_CONTIG: 170430f712c9SDave Chinner /* 170530f712c9SDave Chinner * Filling in all of a previously delayed allocation extent. 170630f712c9SDave Chinner * The left neighbor is contiguous, the right is not. 170730f712c9SDave Chinner */ 170830f712c9SDave Chinner bma->idx--; 170930f712c9SDave Chinner 17104dcb8869SChristoph Hellwig old = LEFT; 171130f712c9SDave Chinner trace_xfs_bmap_pre_update(bma->ip, bma->idx, state, _THIS_IP_); 17124dcb8869SChristoph Hellwig LEFT.br_blockcount += PREV.br_blockcount; 17134dcb8869SChristoph Hellwig xfs_iext_update_extent(ifp, bma->idx, &LEFT); 171430f712c9SDave Chinner trace_xfs_bmap_post_update(bma->ip, bma->idx, state, _THIS_IP_); 171530f712c9SDave Chinner 171630f712c9SDave Chinner xfs_iext_remove(bma->ip, bma->idx + 1, 1, state); 171730f712c9SDave Chinner if (bma->cur == NULL) 171830f712c9SDave Chinner rval = XFS_ILOG_DEXT; 171930f712c9SDave Chinner else { 172030f712c9SDave Chinner rval = 0; 1721e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(bma->cur, &old, &i); 172230f712c9SDave Chinner if (error) 172330f712c9SDave Chinner goto done; 1724c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 1725a67d00a5SChristoph Hellwig error = xfs_bmbt_update(bma->cur, &LEFT); 172630f712c9SDave Chinner if (error) 172730f712c9SDave Chinner goto done; 172830f712c9SDave Chinner } 172930f712c9SDave Chinner break; 173030f712c9SDave Chinner 173130f712c9SDave Chinner case BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING | BMAP_RIGHT_CONTIG: 173230f712c9SDave Chinner /* 173330f712c9SDave Chinner * Filling in all of a previously delayed allocation extent. 173430f712c9SDave Chinner * The right neighbor is contiguous, the left is not. 173530f712c9SDave Chinner */ 173630f712c9SDave Chinner trace_xfs_bmap_pre_update(bma->ip, bma->idx, state, _THIS_IP_); 17374dcb8869SChristoph Hellwig PREV.br_startblock = new->br_startblock; 17384dcb8869SChristoph Hellwig PREV.br_blockcount += RIGHT.br_blockcount; 17394dcb8869SChristoph Hellwig xfs_iext_update_extent(ifp, bma->idx, &PREV); 174030f712c9SDave Chinner trace_xfs_bmap_post_update(bma->ip, bma->idx, state, _THIS_IP_); 174130f712c9SDave Chinner 174230f712c9SDave Chinner xfs_iext_remove(bma->ip, bma->idx + 1, 1, state); 174330f712c9SDave Chinner if (bma->cur == NULL) 174430f712c9SDave Chinner rval = XFS_ILOG_DEXT; 174530f712c9SDave Chinner else { 174630f712c9SDave Chinner rval = 0; 1747e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(bma->cur, &RIGHT, &i); 174830f712c9SDave Chinner if (error) 174930f712c9SDave Chinner goto done; 1750c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 1751a67d00a5SChristoph Hellwig error = xfs_bmbt_update(bma->cur, &PREV); 175230f712c9SDave Chinner if (error) 175330f712c9SDave Chinner goto done; 175430f712c9SDave Chinner } 175530f712c9SDave Chinner break; 175630f712c9SDave Chinner 175730f712c9SDave Chinner case BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING: 175830f712c9SDave Chinner /* 175930f712c9SDave Chinner * Filling in all of a previously delayed allocation extent. 176030f712c9SDave Chinner * Neither the left nor right neighbors are contiguous with 176130f712c9SDave Chinner * the new one. 176230f712c9SDave Chinner */ 176330f712c9SDave Chinner trace_xfs_bmap_pre_update(bma->ip, bma->idx, state, _THIS_IP_); 17644dcb8869SChristoph Hellwig PREV.br_startblock = new->br_startblock; 17654dcb8869SChristoph Hellwig PREV.br_state = new->br_state; 17664dcb8869SChristoph Hellwig xfs_iext_update_extent(ifp, bma->idx, &PREV); 176730f712c9SDave Chinner trace_xfs_bmap_post_update(bma->ip, bma->idx, state, _THIS_IP_); 176830f712c9SDave Chinner 176960b4984fSDarrick J. Wong (*nextents)++; 177030f712c9SDave Chinner if (bma->cur == NULL) 177130f712c9SDave Chinner rval = XFS_ILOG_CORE | XFS_ILOG_DEXT; 177230f712c9SDave Chinner else { 177330f712c9SDave Chinner rval = XFS_ILOG_CORE; 1774e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(bma->cur, new, &i); 177530f712c9SDave Chinner if (error) 177630f712c9SDave Chinner goto done; 1777c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 0, done); 177830f712c9SDave Chinner error = xfs_btree_insert(bma->cur, &i); 177930f712c9SDave Chinner if (error) 178030f712c9SDave Chinner goto done; 1781c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 178230f712c9SDave Chinner } 178330f712c9SDave Chinner break; 178430f712c9SDave Chinner 178530f712c9SDave Chinner case BMAP_LEFT_FILLING | BMAP_LEFT_CONTIG: 178630f712c9SDave Chinner /* 178730f712c9SDave Chinner * Filling in the first part of a previous delayed allocation. 178830f712c9SDave Chinner * The left neighbor is contiguous. 178930f712c9SDave Chinner */ 17904dcb8869SChristoph Hellwig old = LEFT; 17914dcb8869SChristoph Hellwig temp = PREV.br_blockcount - new->br_blockcount; 17924dcb8869SChristoph Hellwig da_new = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(bma->ip, temp), 17934dcb8869SChristoph Hellwig startblockval(PREV.br_startblock)); 17944dcb8869SChristoph Hellwig 179530f712c9SDave Chinner trace_xfs_bmap_pre_update(bma->ip, bma->idx - 1, state, _THIS_IP_); 17964dcb8869SChristoph Hellwig LEFT.br_blockcount += new->br_blockcount; 17974dcb8869SChristoph Hellwig xfs_iext_update_extent(ifp, bma->idx - 1, &LEFT); 179830f712c9SDave Chinner trace_xfs_bmap_post_update(bma->ip, bma->idx - 1, state, _THIS_IP_); 179930f712c9SDave Chinner 180030f712c9SDave Chinner trace_xfs_bmap_pre_update(bma->ip, bma->idx, state, _THIS_IP_); 18014dcb8869SChristoph Hellwig PREV.br_blockcount = temp = PREV.br_blockcount - new->br_blockcount; 18024dcb8869SChristoph Hellwig PREV.br_startoff += new->br_blockcount; 18034dcb8869SChristoph Hellwig PREV.br_startblock = nullstartblock(da_new); 18044dcb8869SChristoph Hellwig xfs_iext_update_extent(ifp, bma->idx, &PREV); 18054dcb8869SChristoph Hellwig trace_xfs_bmap_post_update(bma->ip, bma->idx, state, _THIS_IP_); 18064dcb8869SChristoph Hellwig 180730f712c9SDave Chinner if (bma->cur == NULL) 180830f712c9SDave Chinner rval = XFS_ILOG_DEXT; 180930f712c9SDave Chinner else { 181030f712c9SDave Chinner rval = 0; 1811e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(bma->cur, &old, &i); 181230f712c9SDave Chinner if (error) 181330f712c9SDave Chinner goto done; 1814c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 1815a67d00a5SChristoph Hellwig error = xfs_bmbt_update(bma->cur, &LEFT); 181630f712c9SDave Chinner if (error) 181730f712c9SDave Chinner goto done; 181830f712c9SDave Chinner } 181930f712c9SDave Chinner 182030f712c9SDave Chinner bma->idx--; 182130f712c9SDave Chinner break; 182230f712c9SDave Chinner 182330f712c9SDave Chinner case BMAP_LEFT_FILLING: 182430f712c9SDave Chinner /* 182530f712c9SDave Chinner * Filling in the first part of a previous delayed allocation. 182630f712c9SDave Chinner * The left neighbor is not contiguous. 182730f712c9SDave Chinner */ 182830f712c9SDave Chinner xfs_iext_insert(bma->ip, bma->idx, 1, new, state); 182960b4984fSDarrick J. Wong (*nextents)++; 183030f712c9SDave Chinner if (bma->cur == NULL) 183130f712c9SDave Chinner rval = XFS_ILOG_CORE | XFS_ILOG_DEXT; 183230f712c9SDave Chinner else { 183330f712c9SDave Chinner rval = XFS_ILOG_CORE; 1834e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(bma->cur, new, &i); 183530f712c9SDave Chinner if (error) 183630f712c9SDave Chinner goto done; 1837c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 0, done); 183830f712c9SDave Chinner error = xfs_btree_insert(bma->cur, &i); 183930f712c9SDave Chinner if (error) 184030f712c9SDave Chinner goto done; 1841c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 184230f712c9SDave Chinner } 184330f712c9SDave Chinner 18446d3eb1ecSDarrick J. Wong if (xfs_bmap_needs_btree(bma->ip, whichfork)) { 184530f712c9SDave Chinner error = xfs_bmap_extents_to_btree(bma->tp, bma->ip, 18462c3234d1SDarrick J. Wong bma->firstblock, bma->dfops, 18476d3eb1ecSDarrick J. Wong &bma->cur, 1, &tmp_rval, whichfork); 184830f712c9SDave Chinner rval |= tmp_rval; 184930f712c9SDave Chinner if (error) 185030f712c9SDave Chinner goto done; 185130f712c9SDave Chinner } 18524dcb8869SChristoph Hellwig 18534dcb8869SChristoph Hellwig temp = PREV.br_blockcount - new->br_blockcount; 185430f712c9SDave Chinner da_new = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(bma->ip, temp), 185530f712c9SDave Chinner startblockval(PREV.br_startblock) - 185630f712c9SDave Chinner (bma->cur ? bma->cur->bc_private.b.allocated : 0)); 18574dcb8869SChristoph Hellwig 18584dcb8869SChristoph Hellwig trace_xfs_bmap_pre_update(bma->ip, bma->idx + 1, state, _THIS_IP_); 18594dcb8869SChristoph Hellwig PREV.br_startoff = new_endoff; 18604dcb8869SChristoph Hellwig PREV.br_blockcount = temp; 18614dcb8869SChristoph Hellwig PREV.br_startblock = nullstartblock(da_new); 18624dcb8869SChristoph Hellwig xfs_iext_update_extent(ifp, bma->idx + 1, &PREV); 186330f712c9SDave Chinner trace_xfs_bmap_post_update(bma->ip, bma->idx + 1, state, _THIS_IP_); 18644dcb8869SChristoph Hellwig 186530f712c9SDave Chinner break; 186630f712c9SDave Chinner 186730f712c9SDave Chinner case BMAP_RIGHT_FILLING | BMAP_RIGHT_CONTIG: 186830f712c9SDave Chinner /* 186930f712c9SDave Chinner * Filling in the last part of a previous delayed allocation. 187030f712c9SDave Chinner * The right neighbor is contiguous with the new allocation. 187130f712c9SDave Chinner */ 18724dcb8869SChristoph Hellwig old = RIGHT; 187330f712c9SDave Chinner trace_xfs_bmap_pre_update(bma->ip, bma->idx + 1, state, _THIS_IP_); 18744dcb8869SChristoph Hellwig RIGHT.br_startoff = new->br_startoff; 18754dcb8869SChristoph Hellwig RIGHT.br_startblock = new->br_startblock; 18764dcb8869SChristoph Hellwig RIGHT.br_blockcount += new->br_blockcount; 18774dcb8869SChristoph Hellwig xfs_iext_update_extent(ifp, bma->idx + 1, &RIGHT); 187830f712c9SDave Chinner trace_xfs_bmap_post_update(bma->ip, bma->idx + 1, state, _THIS_IP_); 18794dcb8869SChristoph Hellwig 188030f712c9SDave Chinner if (bma->cur == NULL) 188130f712c9SDave Chinner rval = XFS_ILOG_DEXT; 188230f712c9SDave Chinner else { 188330f712c9SDave Chinner rval = 0; 1884e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(bma->cur, &old, &i); 188530f712c9SDave Chinner if (error) 188630f712c9SDave Chinner goto done; 1887c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 1888a67d00a5SChristoph Hellwig error = xfs_bmbt_update(bma->cur, &RIGHT); 188930f712c9SDave Chinner if (error) 189030f712c9SDave Chinner goto done; 189130f712c9SDave Chinner } 189230f712c9SDave Chinner 18934dcb8869SChristoph Hellwig temp = PREV.br_blockcount - new->br_blockcount; 189430f712c9SDave Chinner da_new = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(bma->ip, temp), 189530f712c9SDave Chinner startblockval(PREV.br_startblock)); 18964dcb8869SChristoph Hellwig 189730f712c9SDave Chinner trace_xfs_bmap_pre_update(bma->ip, bma->idx, state, _THIS_IP_); 18984dcb8869SChristoph Hellwig PREV.br_blockcount = temp; 18994dcb8869SChristoph Hellwig PREV.br_startblock = nullstartblock(da_new); 19004dcb8869SChristoph Hellwig xfs_iext_update_extent(ifp, bma->idx, &PREV); 190130f712c9SDave Chinner trace_xfs_bmap_post_update(bma->ip, bma->idx, state, _THIS_IP_); 190230f712c9SDave Chinner 190330f712c9SDave Chinner bma->idx++; 190430f712c9SDave Chinner break; 190530f712c9SDave Chinner 190630f712c9SDave Chinner case BMAP_RIGHT_FILLING: 190730f712c9SDave Chinner /* 190830f712c9SDave Chinner * Filling in the last part of a previous delayed allocation. 190930f712c9SDave Chinner * The right neighbor is not contiguous. 191030f712c9SDave Chinner */ 191130f712c9SDave Chinner xfs_iext_insert(bma->ip, bma->idx + 1, 1, new, state); 191260b4984fSDarrick J. Wong (*nextents)++; 191330f712c9SDave Chinner if (bma->cur == NULL) 191430f712c9SDave Chinner rval = XFS_ILOG_CORE | XFS_ILOG_DEXT; 191530f712c9SDave Chinner else { 191630f712c9SDave Chinner rval = XFS_ILOG_CORE; 1917e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(bma->cur, new, &i); 191830f712c9SDave Chinner if (error) 191930f712c9SDave Chinner goto done; 1920c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 0, done); 192130f712c9SDave Chinner error = xfs_btree_insert(bma->cur, &i); 192230f712c9SDave Chinner if (error) 192330f712c9SDave Chinner goto done; 1924c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 192530f712c9SDave Chinner } 192630f712c9SDave Chinner 19276d3eb1ecSDarrick J. Wong if (xfs_bmap_needs_btree(bma->ip, whichfork)) { 192830f712c9SDave Chinner error = xfs_bmap_extents_to_btree(bma->tp, bma->ip, 19292c3234d1SDarrick J. Wong bma->firstblock, bma->dfops, &bma->cur, 1, 19306d3eb1ecSDarrick J. Wong &tmp_rval, whichfork); 193130f712c9SDave Chinner rval |= tmp_rval; 193230f712c9SDave Chinner if (error) 193330f712c9SDave Chinner goto done; 193430f712c9SDave Chinner } 19354dcb8869SChristoph Hellwig 19364dcb8869SChristoph Hellwig temp = PREV.br_blockcount - new->br_blockcount; 193730f712c9SDave Chinner da_new = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(bma->ip, temp), 193830f712c9SDave Chinner startblockval(PREV.br_startblock) - 193930f712c9SDave Chinner (bma->cur ? bma->cur->bc_private.b.allocated : 0)); 19404dcb8869SChristoph Hellwig 19414dcb8869SChristoph Hellwig trace_xfs_bmap_pre_update(bma->ip, bma->idx, state, _THIS_IP_); 19424dcb8869SChristoph Hellwig PREV.br_startblock = nullstartblock(da_new); 19434dcb8869SChristoph Hellwig PREV.br_blockcount = temp; 19444dcb8869SChristoph Hellwig xfs_iext_update_extent(ifp, bma->idx, &PREV); 194530f712c9SDave Chinner trace_xfs_bmap_post_update(bma->ip, bma->idx, state, _THIS_IP_); 194630f712c9SDave Chinner 194730f712c9SDave Chinner bma->idx++; 194830f712c9SDave Chinner break; 194930f712c9SDave Chinner 195030f712c9SDave Chinner case 0: 195130f712c9SDave Chinner /* 195230f712c9SDave Chinner * Filling in the middle part of a previous delayed allocation. 195330f712c9SDave Chinner * Contiguity is impossible here. 195430f712c9SDave Chinner * This case is avoided almost all the time. 195530f712c9SDave Chinner * 195630f712c9SDave Chinner * We start with a delayed allocation: 195730f712c9SDave Chinner * 195830f712c9SDave Chinner * +ddddddddddddddddddddddddddddddddddddddddddddddddddddddd+ 195930f712c9SDave Chinner * PREV @ idx 196030f712c9SDave Chinner * 196130f712c9SDave Chinner * and we are allocating: 196230f712c9SDave Chinner * +rrrrrrrrrrrrrrrrr+ 196330f712c9SDave Chinner * new 196430f712c9SDave Chinner * 196530f712c9SDave Chinner * and we set it up for insertion as: 196630f712c9SDave Chinner * +ddddddddddddddddddd+rrrrrrrrrrrrrrrrr+ddddddddddddddddd+ 196730f712c9SDave Chinner * new 196830f712c9SDave Chinner * PREV @ idx LEFT RIGHT 196930f712c9SDave Chinner * inserted at idx + 1 197030f712c9SDave Chinner */ 19714dcb8869SChristoph Hellwig old = PREV; 19724dcb8869SChristoph Hellwig 19734dcb8869SChristoph Hellwig /* LEFT is the new middle */ 197430f712c9SDave Chinner LEFT = *new; 19754dcb8869SChristoph Hellwig 19764dcb8869SChristoph Hellwig /* RIGHT is the new right */ 197730f712c9SDave Chinner RIGHT.br_state = PREV.br_state; 197830f712c9SDave Chinner RIGHT.br_startoff = new_endoff; 19794dcb8869SChristoph Hellwig RIGHT.br_blockcount = 19804dcb8869SChristoph Hellwig PREV.br_startoff + PREV.br_blockcount - new_endoff; 19814dcb8869SChristoph Hellwig RIGHT.br_startblock = 19824dcb8869SChristoph Hellwig nullstartblock(xfs_bmap_worst_indlen(bma->ip, 19834dcb8869SChristoph Hellwig RIGHT.br_blockcount)); 19844dcb8869SChristoph Hellwig 19854dcb8869SChristoph Hellwig /* truncate PREV */ 19864dcb8869SChristoph Hellwig trace_xfs_bmap_pre_update(bma->ip, bma->idx, 0, _THIS_IP_); 19874dcb8869SChristoph Hellwig PREV.br_blockcount = new->br_startoff - PREV.br_startoff; 19884dcb8869SChristoph Hellwig PREV.br_startblock = 19894dcb8869SChristoph Hellwig nullstartblock(xfs_bmap_worst_indlen(bma->ip, 19904dcb8869SChristoph Hellwig PREV.br_blockcount)); 19914dcb8869SChristoph Hellwig xfs_iext_update_extent(ifp, bma->idx, &PREV); 19924dcb8869SChristoph Hellwig trace_xfs_bmap_post_update(bma->ip, bma->idx, state, _THIS_IP_); 19934dcb8869SChristoph Hellwig 199430f712c9SDave Chinner /* insert LEFT (r[0]) and RIGHT (r[1]) at the same time */ 199530f712c9SDave Chinner xfs_iext_insert(bma->ip, bma->idx + 1, 2, &LEFT, state); 199660b4984fSDarrick J. Wong (*nextents)++; 19974dcb8869SChristoph Hellwig 199830f712c9SDave Chinner if (bma->cur == NULL) 199930f712c9SDave Chinner rval = XFS_ILOG_CORE | XFS_ILOG_DEXT; 200030f712c9SDave Chinner else { 200130f712c9SDave Chinner rval = XFS_ILOG_CORE; 2002e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(bma->cur, new, &i); 200330f712c9SDave Chinner if (error) 200430f712c9SDave Chinner goto done; 2005c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 0, done); 200630f712c9SDave Chinner error = xfs_btree_insert(bma->cur, &i); 200730f712c9SDave Chinner if (error) 200830f712c9SDave Chinner goto done; 2009c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 201030f712c9SDave Chinner } 201130f712c9SDave Chinner 20126d3eb1ecSDarrick J. Wong if (xfs_bmap_needs_btree(bma->ip, whichfork)) { 201330f712c9SDave Chinner error = xfs_bmap_extents_to_btree(bma->tp, bma->ip, 20142c3234d1SDarrick J. Wong bma->firstblock, bma->dfops, &bma->cur, 20156d3eb1ecSDarrick J. Wong 1, &tmp_rval, whichfork); 201630f712c9SDave Chinner rval |= tmp_rval; 201730f712c9SDave Chinner if (error) 201830f712c9SDave Chinner goto done; 201930f712c9SDave Chinner } 20204dcb8869SChristoph Hellwig 20214dcb8869SChristoph Hellwig da_new = startblockval(PREV.br_startblock) + 20224dcb8869SChristoph Hellwig startblockval(RIGHT.br_startblock); 202330f712c9SDave Chinner bma->idx++; 202430f712c9SDave Chinner break; 202530f712c9SDave Chinner 202630f712c9SDave Chinner case BMAP_LEFT_FILLING | BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG: 202730f712c9SDave Chinner case BMAP_RIGHT_FILLING | BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG: 202830f712c9SDave Chinner case BMAP_LEFT_FILLING | BMAP_RIGHT_CONTIG: 202930f712c9SDave Chinner case BMAP_RIGHT_FILLING | BMAP_LEFT_CONTIG: 203030f712c9SDave Chinner case BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG: 203130f712c9SDave Chinner case BMAP_LEFT_CONTIG: 203230f712c9SDave Chinner case BMAP_RIGHT_CONTIG: 203330f712c9SDave Chinner /* 203430f712c9SDave Chinner * These cases are all impossible. 203530f712c9SDave Chinner */ 203630f712c9SDave Chinner ASSERT(0); 203730f712c9SDave Chinner } 203830f712c9SDave Chinner 20399c194644SDarrick J. Wong /* add reverse mapping */ 20409c194644SDarrick J. Wong error = xfs_rmap_map_extent(mp, bma->dfops, bma->ip, whichfork, new); 20419c194644SDarrick J. Wong if (error) 20429c194644SDarrick J. Wong goto done; 20439c194644SDarrick J. Wong 204430f712c9SDave Chinner /* convert to a btree if necessary */ 20456d3eb1ecSDarrick J. Wong if (xfs_bmap_needs_btree(bma->ip, whichfork)) { 204630f712c9SDave Chinner int tmp_logflags; /* partial log flag return val */ 204730f712c9SDave Chinner 204830f712c9SDave Chinner ASSERT(bma->cur == NULL); 204930f712c9SDave Chinner error = xfs_bmap_extents_to_btree(bma->tp, bma->ip, 20502c3234d1SDarrick J. Wong bma->firstblock, bma->dfops, &bma->cur, 20516d3eb1ecSDarrick J. Wong da_old > 0, &tmp_logflags, whichfork); 205230f712c9SDave Chinner bma->logflags |= tmp_logflags; 205330f712c9SDave Chinner if (error) 205430f712c9SDave Chinner goto done; 205530f712c9SDave Chinner } 205630f712c9SDave Chinner 2057ca1862b0SChristoph Hellwig if (bma->cur) { 2058ca1862b0SChristoph Hellwig da_new += bma->cur->bc_private.b.allocated; 2059ca1862b0SChristoph Hellwig bma->cur->bc_private.b.allocated = 0; 206030f712c9SDave Chinner } 206130f712c9SDave Chinner 2062ca1862b0SChristoph Hellwig /* adjust for changes in reserved delayed indirect blocks */ 2063ca1862b0SChristoph Hellwig if (da_new != da_old) { 2064ca1862b0SChristoph Hellwig ASSERT(state == 0 || da_new < da_old); 2065ca1862b0SChristoph Hellwig error = xfs_mod_fdblocks(mp, (int64_t)(da_old - da_new), 2066ca1862b0SChristoph Hellwig false); 2067ca1862b0SChristoph Hellwig } 206830f712c9SDave Chinner 20696d3eb1ecSDarrick J. Wong xfs_bmap_check_leaf_extents(bma->cur, bma->ip, whichfork); 207030f712c9SDave Chinner done: 207160b4984fSDarrick J. Wong if (whichfork != XFS_COW_FORK) 207230f712c9SDave Chinner bma->logflags |= rval; 207330f712c9SDave Chinner return error; 207430f712c9SDave Chinner #undef LEFT 207530f712c9SDave Chinner #undef RIGHT 207630f712c9SDave Chinner #undef PREV 207730f712c9SDave Chinner } 207830f712c9SDave Chinner 207930f712c9SDave Chinner /* 208030f712c9SDave Chinner * Convert an unwritten allocation to a real allocation or vice versa. 208130f712c9SDave Chinner */ 208230f712c9SDave Chinner STATIC int /* error */ 208330f712c9SDave Chinner xfs_bmap_add_extent_unwritten_real( 208430f712c9SDave Chinner struct xfs_trans *tp, 208530f712c9SDave Chinner xfs_inode_t *ip, /* incore inode pointer */ 208605a630d7SDarrick J. Wong int whichfork, 208730f712c9SDave Chinner xfs_extnum_t *idx, /* extent number to update/insert */ 208830f712c9SDave Chinner xfs_btree_cur_t **curp, /* if *curp is null, not a btree */ 208930f712c9SDave Chinner xfs_bmbt_irec_t *new, /* new data to add to file extents */ 209030f712c9SDave Chinner xfs_fsblock_t *first, /* pointer to firstblock variable */ 20912c3234d1SDarrick J. Wong struct xfs_defer_ops *dfops, /* list of extents to be freed */ 209230f712c9SDave Chinner int *logflagsp) /* inode logging flags */ 209330f712c9SDave Chinner { 209430f712c9SDave Chinner xfs_btree_cur_t *cur; /* btree cursor */ 209530f712c9SDave Chinner int error; /* error return value */ 209630f712c9SDave Chinner int i; /* temp state */ 209730f712c9SDave Chinner xfs_ifork_t *ifp; /* inode fork pointer */ 209830f712c9SDave Chinner xfs_fileoff_t new_endoff; /* end offset of new entry */ 209930f712c9SDave Chinner xfs_bmbt_irec_t r[3]; /* neighbor extent entries */ 210030f712c9SDave Chinner /* left is 0, right is 1, prev is 2 */ 210130f712c9SDave Chinner int rval=0; /* return value (logging flags) */ 2102060ea65bSChristoph Hellwig int state = xfs_bmap_fork_to_state(whichfork); 210305a630d7SDarrick J. Wong struct xfs_mount *mp = ip->i_mount; 210479fa6143SChristoph Hellwig struct xfs_bmbt_irec old; 210530f712c9SDave Chinner 210630f712c9SDave Chinner *logflagsp = 0; 210730f712c9SDave Chinner 210830f712c9SDave Chinner cur = *curp; 210905a630d7SDarrick J. Wong ifp = XFS_IFORK_PTR(ip, whichfork); 211030f712c9SDave Chinner 211130f712c9SDave Chinner ASSERT(*idx >= 0); 21125d829300SEric Sandeen ASSERT(*idx <= xfs_iext_count(ifp)); 211330f712c9SDave Chinner ASSERT(!isnullstartblock(new->br_startblock)); 211430f712c9SDave Chinner 2115ff6d6af2SBill O'Donnell XFS_STATS_INC(mp, xs_add_exlist); 211630f712c9SDave Chinner 211730f712c9SDave Chinner #define LEFT r[0] 211830f712c9SDave Chinner #define RIGHT r[1] 211930f712c9SDave Chinner #define PREV r[2] 212030f712c9SDave Chinner 212130f712c9SDave Chinner /* 212230f712c9SDave Chinner * Set up a bunch of variables to make the tests simpler. 212330f712c9SDave Chinner */ 212430f712c9SDave Chinner error = 0; 212579fa6143SChristoph Hellwig xfs_iext_get_extent(ifp, *idx, &PREV); 212679fa6143SChristoph Hellwig ASSERT(new->br_state != PREV.br_state); 212730f712c9SDave Chinner new_endoff = new->br_startoff + new->br_blockcount; 212830f712c9SDave Chinner ASSERT(PREV.br_startoff <= new->br_startoff); 212930f712c9SDave Chinner ASSERT(PREV.br_startoff + PREV.br_blockcount >= new_endoff); 213030f712c9SDave Chinner 213130f712c9SDave Chinner /* 213230f712c9SDave Chinner * Set flags determining what part of the previous oldext allocation 213330f712c9SDave Chinner * extent is being replaced by a newext allocation. 213430f712c9SDave Chinner */ 213530f712c9SDave Chinner if (PREV.br_startoff == new->br_startoff) 213630f712c9SDave Chinner state |= BMAP_LEFT_FILLING; 213730f712c9SDave Chinner if (PREV.br_startoff + PREV.br_blockcount == new_endoff) 213830f712c9SDave Chinner state |= BMAP_RIGHT_FILLING; 213930f712c9SDave Chinner 214030f712c9SDave Chinner /* 214130f712c9SDave Chinner * Check and set flags if this segment has a left neighbor. 214230f712c9SDave Chinner * Don't set contiguous if the combined extent would be too large. 214330f712c9SDave Chinner */ 214430f712c9SDave Chinner if (*idx > 0) { 214530f712c9SDave Chinner state |= BMAP_LEFT_VALID; 2146e3f0f756SChristoph Hellwig xfs_iext_get_extent(ifp, *idx - 1, &LEFT); 214730f712c9SDave Chinner 214830f712c9SDave Chinner if (isnullstartblock(LEFT.br_startblock)) 214930f712c9SDave Chinner state |= BMAP_LEFT_DELAY; 215030f712c9SDave Chinner } 215130f712c9SDave Chinner 215230f712c9SDave Chinner if ((state & BMAP_LEFT_VALID) && !(state & BMAP_LEFT_DELAY) && 215330f712c9SDave Chinner LEFT.br_startoff + LEFT.br_blockcount == new->br_startoff && 215430f712c9SDave Chinner LEFT.br_startblock + LEFT.br_blockcount == new->br_startblock && 215579fa6143SChristoph Hellwig LEFT.br_state == new->br_state && 215630f712c9SDave Chinner LEFT.br_blockcount + new->br_blockcount <= MAXEXTLEN) 215730f712c9SDave Chinner state |= BMAP_LEFT_CONTIG; 215830f712c9SDave Chinner 215930f712c9SDave Chinner /* 216030f712c9SDave Chinner * Check and set flags if this segment has a right neighbor. 216130f712c9SDave Chinner * Don't set contiguous if the combined extent would be too large. 216230f712c9SDave Chinner * Also check for all-three-contiguous being too large. 216330f712c9SDave Chinner */ 216405a630d7SDarrick J. Wong if (*idx < xfs_iext_count(ifp) - 1) { 216530f712c9SDave Chinner state |= BMAP_RIGHT_VALID; 2166e3f0f756SChristoph Hellwig xfs_iext_get_extent(ifp, *idx + 1, &RIGHT); 216730f712c9SDave Chinner if (isnullstartblock(RIGHT.br_startblock)) 216830f712c9SDave Chinner state |= BMAP_RIGHT_DELAY; 216930f712c9SDave Chinner } 217030f712c9SDave Chinner 217130f712c9SDave Chinner if ((state & BMAP_RIGHT_VALID) && !(state & BMAP_RIGHT_DELAY) && 217230f712c9SDave Chinner new_endoff == RIGHT.br_startoff && 217330f712c9SDave Chinner new->br_startblock + new->br_blockcount == RIGHT.br_startblock && 217479fa6143SChristoph Hellwig new->br_state == RIGHT.br_state && 217530f712c9SDave Chinner new->br_blockcount + RIGHT.br_blockcount <= MAXEXTLEN && 217630f712c9SDave Chinner ((state & (BMAP_LEFT_CONTIG | BMAP_LEFT_FILLING | 217730f712c9SDave Chinner BMAP_RIGHT_FILLING)) != 217830f712c9SDave Chinner (BMAP_LEFT_CONTIG | BMAP_LEFT_FILLING | 217930f712c9SDave Chinner BMAP_RIGHT_FILLING) || 218030f712c9SDave Chinner LEFT.br_blockcount + new->br_blockcount + RIGHT.br_blockcount 218130f712c9SDave Chinner <= MAXEXTLEN)) 218230f712c9SDave Chinner state |= BMAP_RIGHT_CONTIG; 218330f712c9SDave Chinner 218430f712c9SDave Chinner /* 218530f712c9SDave Chinner * Switch out based on the FILLING and CONTIG state bits. 218630f712c9SDave Chinner */ 218730f712c9SDave Chinner switch (state & (BMAP_LEFT_FILLING | BMAP_LEFT_CONTIG | 218830f712c9SDave Chinner BMAP_RIGHT_FILLING | BMAP_RIGHT_CONTIG)) { 218930f712c9SDave Chinner case BMAP_LEFT_FILLING | BMAP_LEFT_CONTIG | 219030f712c9SDave Chinner BMAP_RIGHT_FILLING | BMAP_RIGHT_CONTIG: 219130f712c9SDave Chinner /* 219230f712c9SDave Chinner * Setting all of a previous oldext extent to newext. 219330f712c9SDave Chinner * The left and right neighbors are both contiguous with new. 219430f712c9SDave Chinner */ 219530f712c9SDave Chinner --*idx; 219630f712c9SDave Chinner 219730f712c9SDave Chinner trace_xfs_bmap_pre_update(ip, *idx, state, _THIS_IP_); 219879fa6143SChristoph Hellwig LEFT.br_blockcount += PREV.br_blockcount + RIGHT.br_blockcount; 219979fa6143SChristoph Hellwig xfs_iext_update_extent(ifp, *idx, &LEFT); 220030f712c9SDave Chinner trace_xfs_bmap_post_update(ip, *idx, state, _THIS_IP_); 220130f712c9SDave Chinner 220230f712c9SDave Chinner xfs_iext_remove(ip, *idx + 1, 2, state); 220305a630d7SDarrick J. Wong XFS_IFORK_NEXT_SET(ip, whichfork, 220405a630d7SDarrick J. Wong XFS_IFORK_NEXTENTS(ip, whichfork) - 2); 220530f712c9SDave Chinner if (cur == NULL) 220630f712c9SDave Chinner rval = XFS_ILOG_CORE | XFS_ILOG_DEXT; 220730f712c9SDave Chinner else { 220830f712c9SDave Chinner rval = XFS_ILOG_CORE; 2209e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(cur, &RIGHT, &i); 2210e16cf9b0SChristoph Hellwig if (error) 221130f712c9SDave Chinner goto done; 2212c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 221330f712c9SDave Chinner if ((error = xfs_btree_delete(cur, &i))) 221430f712c9SDave Chinner goto done; 2215c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 221630f712c9SDave Chinner if ((error = xfs_btree_decrement(cur, 0, &i))) 221730f712c9SDave Chinner goto done; 2218c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 221930f712c9SDave Chinner if ((error = xfs_btree_delete(cur, &i))) 222030f712c9SDave Chinner goto done; 2221c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 222230f712c9SDave Chinner if ((error = xfs_btree_decrement(cur, 0, &i))) 222330f712c9SDave Chinner goto done; 2224c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 2225a67d00a5SChristoph Hellwig error = xfs_bmbt_update(cur, &LEFT); 222679fa6143SChristoph Hellwig if (error) 222730f712c9SDave Chinner goto done; 222830f712c9SDave Chinner } 222930f712c9SDave Chinner break; 223030f712c9SDave Chinner 223130f712c9SDave Chinner case BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING | BMAP_LEFT_CONTIG: 223230f712c9SDave Chinner /* 223330f712c9SDave Chinner * Setting all of a previous oldext extent to newext. 223430f712c9SDave Chinner * The left neighbor is contiguous, the right is not. 223530f712c9SDave Chinner */ 223630f712c9SDave Chinner --*idx; 223730f712c9SDave Chinner 223830f712c9SDave Chinner trace_xfs_bmap_pre_update(ip, *idx, state, _THIS_IP_); 223979fa6143SChristoph Hellwig LEFT.br_blockcount += PREV.br_blockcount; 224079fa6143SChristoph Hellwig xfs_iext_update_extent(ifp, *idx, &LEFT); 224130f712c9SDave Chinner trace_xfs_bmap_post_update(ip, *idx, state, _THIS_IP_); 224230f712c9SDave Chinner 224330f712c9SDave Chinner xfs_iext_remove(ip, *idx + 1, 1, state); 224405a630d7SDarrick J. Wong XFS_IFORK_NEXT_SET(ip, whichfork, 224505a630d7SDarrick J. Wong XFS_IFORK_NEXTENTS(ip, whichfork) - 1); 224630f712c9SDave Chinner if (cur == NULL) 224730f712c9SDave Chinner rval = XFS_ILOG_CORE | XFS_ILOG_DEXT; 224830f712c9SDave Chinner else { 224930f712c9SDave Chinner rval = XFS_ILOG_CORE; 2250e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(cur, &PREV, &i); 2251e16cf9b0SChristoph Hellwig if (error) 225230f712c9SDave Chinner goto done; 2253c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 225430f712c9SDave Chinner if ((error = xfs_btree_delete(cur, &i))) 225530f712c9SDave Chinner goto done; 2256c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 225730f712c9SDave Chinner if ((error = xfs_btree_decrement(cur, 0, &i))) 225830f712c9SDave Chinner goto done; 2259c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 2260a67d00a5SChristoph Hellwig error = xfs_bmbt_update(cur, &LEFT); 226179fa6143SChristoph Hellwig if (error) 226230f712c9SDave Chinner goto done; 226330f712c9SDave Chinner } 226430f712c9SDave Chinner break; 226530f712c9SDave Chinner 226630f712c9SDave Chinner case BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING | BMAP_RIGHT_CONTIG: 226730f712c9SDave Chinner /* 226830f712c9SDave Chinner * Setting all of a previous oldext extent to newext. 226930f712c9SDave Chinner * The right neighbor is contiguous, the left is not. 227030f712c9SDave Chinner */ 227130f712c9SDave Chinner trace_xfs_bmap_pre_update(ip, *idx, state, _THIS_IP_); 227279fa6143SChristoph Hellwig PREV.br_blockcount += RIGHT.br_blockcount; 227379fa6143SChristoph Hellwig PREV.br_state = new->br_state; 227479fa6143SChristoph Hellwig xfs_iext_update_extent(ifp, *idx, &PREV); 227530f712c9SDave Chinner trace_xfs_bmap_post_update(ip, *idx, state, _THIS_IP_); 227679fa6143SChristoph Hellwig 227730f712c9SDave Chinner xfs_iext_remove(ip, *idx + 1, 1, state); 227805a630d7SDarrick J. Wong XFS_IFORK_NEXT_SET(ip, whichfork, 227905a630d7SDarrick J. Wong XFS_IFORK_NEXTENTS(ip, whichfork) - 1); 228030f712c9SDave Chinner if (cur == NULL) 228130f712c9SDave Chinner rval = XFS_ILOG_CORE | XFS_ILOG_DEXT; 228230f712c9SDave Chinner else { 228330f712c9SDave Chinner rval = XFS_ILOG_CORE; 2284e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(cur, &RIGHT, &i); 2285e16cf9b0SChristoph Hellwig if (error) 228630f712c9SDave Chinner goto done; 2287c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 228830f712c9SDave Chinner if ((error = xfs_btree_delete(cur, &i))) 228930f712c9SDave Chinner goto done; 2290c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 229130f712c9SDave Chinner if ((error = xfs_btree_decrement(cur, 0, &i))) 229230f712c9SDave Chinner goto done; 2293c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 2294a67d00a5SChristoph Hellwig error = xfs_bmbt_update(cur, &PREV); 229579fa6143SChristoph Hellwig if (error) 229630f712c9SDave Chinner goto done; 229730f712c9SDave Chinner } 229830f712c9SDave Chinner break; 229930f712c9SDave Chinner 230030f712c9SDave Chinner case BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING: 230130f712c9SDave Chinner /* 230230f712c9SDave Chinner * Setting all of a previous oldext extent to newext. 230330f712c9SDave Chinner * Neither the left nor right neighbors are contiguous with 230430f712c9SDave Chinner * the new one. 230530f712c9SDave Chinner */ 230630f712c9SDave Chinner trace_xfs_bmap_pre_update(ip, *idx, state, _THIS_IP_); 230779fa6143SChristoph Hellwig PREV.br_state = new->br_state; 230879fa6143SChristoph Hellwig xfs_iext_update_extent(ifp, *idx, &PREV); 230930f712c9SDave Chinner trace_xfs_bmap_post_update(ip, *idx, state, _THIS_IP_); 231030f712c9SDave Chinner 231130f712c9SDave Chinner if (cur == NULL) 231230f712c9SDave Chinner rval = XFS_ILOG_DEXT; 231330f712c9SDave Chinner else { 231430f712c9SDave Chinner rval = 0; 2315e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(cur, new, &i); 2316e16cf9b0SChristoph Hellwig if (error) 231730f712c9SDave Chinner goto done; 2318c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 2319a67d00a5SChristoph Hellwig error = xfs_bmbt_update(cur, &PREV); 232079fa6143SChristoph Hellwig if (error) 232130f712c9SDave Chinner goto done; 232230f712c9SDave Chinner } 232330f712c9SDave Chinner break; 232430f712c9SDave Chinner 232530f712c9SDave Chinner case BMAP_LEFT_FILLING | BMAP_LEFT_CONTIG: 232630f712c9SDave Chinner /* 232730f712c9SDave Chinner * Setting the first part of a previous oldext extent to newext. 232830f712c9SDave Chinner * The left neighbor is contiguous. 232930f712c9SDave Chinner */ 233030f712c9SDave Chinner trace_xfs_bmap_pre_update(ip, *idx - 1, state, _THIS_IP_); 233179fa6143SChristoph Hellwig LEFT.br_blockcount += new->br_blockcount; 233279fa6143SChristoph Hellwig xfs_iext_update_extent(ifp, *idx - 1, &LEFT); 233330f712c9SDave Chinner trace_xfs_bmap_post_update(ip, *idx - 1, state, _THIS_IP_); 233430f712c9SDave Chinner 233579fa6143SChristoph Hellwig old = PREV; 233630f712c9SDave Chinner trace_xfs_bmap_pre_update(ip, *idx, state, _THIS_IP_); 233779fa6143SChristoph Hellwig PREV.br_startoff += new->br_blockcount; 233879fa6143SChristoph Hellwig PREV.br_startblock += new->br_blockcount; 233979fa6143SChristoph Hellwig PREV.br_blockcount -= new->br_blockcount; 234079fa6143SChristoph Hellwig xfs_iext_update_extent(ifp, *idx, &PREV); 234130f712c9SDave Chinner trace_xfs_bmap_post_update(ip, *idx, state, _THIS_IP_); 234230f712c9SDave Chinner 234330f712c9SDave Chinner --*idx; 234430f712c9SDave Chinner 234530f712c9SDave Chinner if (cur == NULL) 234630f712c9SDave Chinner rval = XFS_ILOG_DEXT; 234730f712c9SDave Chinner else { 234830f712c9SDave Chinner rval = 0; 2349e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(cur, &old, &i); 235079fa6143SChristoph Hellwig if (error) 235130f712c9SDave Chinner goto done; 2352c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 2353a67d00a5SChristoph Hellwig error = xfs_bmbt_update(cur, &PREV); 235479fa6143SChristoph Hellwig if (error) 235530f712c9SDave Chinner goto done; 235679fa6143SChristoph Hellwig error = xfs_btree_decrement(cur, 0, &i); 235779fa6143SChristoph Hellwig if (error) 235830f712c9SDave Chinner goto done; 2359a67d00a5SChristoph Hellwig error = xfs_bmbt_update(cur, &LEFT); 236030f712c9SDave Chinner if (error) 236130f712c9SDave Chinner goto done; 236230f712c9SDave Chinner } 236330f712c9SDave Chinner break; 236430f712c9SDave Chinner 236530f712c9SDave Chinner case BMAP_LEFT_FILLING: 236630f712c9SDave Chinner /* 236730f712c9SDave Chinner * Setting the first part of a previous oldext extent to newext. 236830f712c9SDave Chinner * The left neighbor is not contiguous. 236930f712c9SDave Chinner */ 237079fa6143SChristoph Hellwig old = PREV; 237130f712c9SDave Chinner trace_xfs_bmap_pre_update(ip, *idx, state, _THIS_IP_); 237279fa6143SChristoph Hellwig PREV.br_startoff += new->br_blockcount; 237379fa6143SChristoph Hellwig PREV.br_startblock += new->br_blockcount; 237479fa6143SChristoph Hellwig PREV.br_blockcount -= new->br_blockcount; 237579fa6143SChristoph Hellwig xfs_iext_update_extent(ifp, *idx, &PREV); 237630f712c9SDave Chinner trace_xfs_bmap_post_update(ip, *idx, state, _THIS_IP_); 237730f712c9SDave Chinner 237830f712c9SDave Chinner xfs_iext_insert(ip, *idx, 1, new, state); 237905a630d7SDarrick J. Wong XFS_IFORK_NEXT_SET(ip, whichfork, 238005a630d7SDarrick J. Wong XFS_IFORK_NEXTENTS(ip, whichfork) + 1); 238130f712c9SDave Chinner if (cur == NULL) 238230f712c9SDave Chinner rval = XFS_ILOG_CORE | XFS_ILOG_DEXT; 238330f712c9SDave Chinner else { 238430f712c9SDave Chinner rval = XFS_ILOG_CORE; 2385e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(cur, &old, &i); 238679fa6143SChristoph Hellwig if (error) 238730f712c9SDave Chinner goto done; 2388c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 2389a67d00a5SChristoph Hellwig error = xfs_bmbt_update(cur, &PREV); 239079fa6143SChristoph Hellwig if (error) 239130f712c9SDave Chinner goto done; 239230f712c9SDave Chinner cur->bc_rec.b = *new; 239330f712c9SDave Chinner if ((error = xfs_btree_insert(cur, &i))) 239430f712c9SDave Chinner goto done; 2395c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 239630f712c9SDave Chinner } 239730f712c9SDave Chinner break; 239830f712c9SDave Chinner 239930f712c9SDave Chinner case BMAP_RIGHT_FILLING | BMAP_RIGHT_CONTIG: 240030f712c9SDave Chinner /* 240130f712c9SDave Chinner * Setting the last part of a previous oldext extent to newext. 240230f712c9SDave Chinner * The right neighbor is contiguous with the new allocation. 240330f712c9SDave Chinner */ 240479fa6143SChristoph Hellwig old = PREV; 240530f712c9SDave Chinner trace_xfs_bmap_pre_update(ip, *idx, state, _THIS_IP_); 240679fa6143SChristoph Hellwig PREV.br_blockcount -= new->br_blockcount; 240779fa6143SChristoph Hellwig xfs_iext_update_extent(ifp, *idx, &PREV); 240830f712c9SDave Chinner trace_xfs_bmap_post_update(ip, *idx, state, _THIS_IP_); 240930f712c9SDave Chinner 241030f712c9SDave Chinner ++*idx; 241130f712c9SDave Chinner 241230f712c9SDave Chinner trace_xfs_bmap_pre_update(ip, *idx, state, _THIS_IP_); 241379fa6143SChristoph Hellwig RIGHT.br_startoff = new->br_startoff; 241479fa6143SChristoph Hellwig RIGHT.br_startblock = new->br_startblock; 241579fa6143SChristoph Hellwig RIGHT.br_blockcount += new->br_blockcount; 241679fa6143SChristoph Hellwig xfs_iext_update_extent(ifp, *idx, &RIGHT); 241730f712c9SDave Chinner trace_xfs_bmap_post_update(ip, *idx, state, _THIS_IP_); 241830f712c9SDave Chinner 241930f712c9SDave Chinner if (cur == NULL) 242030f712c9SDave Chinner rval = XFS_ILOG_DEXT; 242130f712c9SDave Chinner else { 242230f712c9SDave Chinner rval = 0; 2423e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(cur, &old, &i); 242479fa6143SChristoph Hellwig if (error) 242530f712c9SDave Chinner goto done; 2426c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 2427a67d00a5SChristoph Hellwig error = xfs_bmbt_update(cur, &PREV); 242879fa6143SChristoph Hellwig if (error) 242930f712c9SDave Chinner goto done; 243079fa6143SChristoph Hellwig error = xfs_btree_increment(cur, 0, &i); 243179fa6143SChristoph Hellwig if (error) 243230f712c9SDave Chinner goto done; 2433a67d00a5SChristoph Hellwig error = xfs_bmbt_update(cur, &RIGHT); 243479fa6143SChristoph Hellwig if (error) 243530f712c9SDave Chinner goto done; 243630f712c9SDave Chinner } 243730f712c9SDave Chinner break; 243830f712c9SDave Chinner 243930f712c9SDave Chinner case BMAP_RIGHT_FILLING: 244030f712c9SDave Chinner /* 244130f712c9SDave Chinner * Setting the last part of a previous oldext extent to newext. 244230f712c9SDave Chinner * The right neighbor is not contiguous. 244330f712c9SDave Chinner */ 244479fa6143SChristoph Hellwig old = PREV; 244530f712c9SDave Chinner trace_xfs_bmap_pre_update(ip, *idx, state, _THIS_IP_); 244679fa6143SChristoph Hellwig PREV.br_blockcount -= new->br_blockcount; 244779fa6143SChristoph Hellwig xfs_iext_update_extent(ifp, *idx, &PREV); 244830f712c9SDave Chinner trace_xfs_bmap_post_update(ip, *idx, state, _THIS_IP_); 244930f712c9SDave Chinner 245030f712c9SDave Chinner ++*idx; 245130f712c9SDave Chinner xfs_iext_insert(ip, *idx, 1, new, state); 245230f712c9SDave Chinner 245305a630d7SDarrick J. Wong XFS_IFORK_NEXT_SET(ip, whichfork, 245405a630d7SDarrick J. Wong XFS_IFORK_NEXTENTS(ip, whichfork) + 1); 245530f712c9SDave Chinner if (cur == NULL) 245630f712c9SDave Chinner rval = XFS_ILOG_CORE | XFS_ILOG_DEXT; 245730f712c9SDave Chinner else { 245830f712c9SDave Chinner rval = XFS_ILOG_CORE; 2459e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(cur, &old, &i); 246079fa6143SChristoph Hellwig if (error) 246130f712c9SDave Chinner goto done; 2462c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 2463a67d00a5SChristoph Hellwig error = xfs_bmbt_update(cur, &PREV); 246479fa6143SChristoph Hellwig if (error) 246530f712c9SDave Chinner goto done; 2466e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(cur, new, &i); 2467e16cf9b0SChristoph Hellwig if (error) 246830f712c9SDave Chinner goto done; 2469c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 0, done); 247030f712c9SDave Chinner if ((error = xfs_btree_insert(cur, &i))) 247130f712c9SDave Chinner goto done; 2472c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 247330f712c9SDave Chinner } 247430f712c9SDave Chinner break; 247530f712c9SDave Chinner 247630f712c9SDave Chinner case 0: 247730f712c9SDave Chinner /* 247830f712c9SDave Chinner * Setting the middle part of a previous oldext extent to 247930f712c9SDave Chinner * newext. Contiguity is impossible here. 248030f712c9SDave Chinner * One extent becomes three extents. 248130f712c9SDave Chinner */ 248279fa6143SChristoph Hellwig old = PREV; 248330f712c9SDave Chinner trace_xfs_bmap_pre_update(ip, *idx, state, _THIS_IP_); 248479fa6143SChristoph Hellwig PREV.br_blockcount = new->br_startoff - PREV.br_startoff; 248579fa6143SChristoph Hellwig xfs_iext_update_extent(ifp, *idx, &PREV); 248630f712c9SDave Chinner trace_xfs_bmap_post_update(ip, *idx, state, _THIS_IP_); 248730f712c9SDave Chinner 248830f712c9SDave Chinner r[0] = *new; 248930f712c9SDave Chinner r[1].br_startoff = new_endoff; 249030f712c9SDave Chinner r[1].br_blockcount = 249179fa6143SChristoph Hellwig old.br_startoff + old.br_blockcount - new_endoff; 249230f712c9SDave Chinner r[1].br_startblock = new->br_startblock + new->br_blockcount; 249379fa6143SChristoph Hellwig r[1].br_state = PREV.br_state; 249430f712c9SDave Chinner 249530f712c9SDave Chinner ++*idx; 249630f712c9SDave Chinner xfs_iext_insert(ip, *idx, 2, &r[0], state); 249730f712c9SDave Chinner 249805a630d7SDarrick J. Wong XFS_IFORK_NEXT_SET(ip, whichfork, 249905a630d7SDarrick J. Wong XFS_IFORK_NEXTENTS(ip, whichfork) + 2); 250030f712c9SDave Chinner if (cur == NULL) 250130f712c9SDave Chinner rval = XFS_ILOG_CORE | XFS_ILOG_DEXT; 250230f712c9SDave Chinner else { 250330f712c9SDave Chinner rval = XFS_ILOG_CORE; 2504e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(cur, &old, &i); 250579fa6143SChristoph Hellwig if (error) 250630f712c9SDave Chinner goto done; 2507c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 250830f712c9SDave Chinner /* new right extent - oldext */ 2509a67d00a5SChristoph Hellwig error = xfs_bmbt_update(cur, &r[1]); 2510a67d00a5SChristoph Hellwig if (error) 251130f712c9SDave Chinner goto done; 251230f712c9SDave Chinner /* new left extent - oldext */ 251330f712c9SDave Chinner cur->bc_rec.b = PREV; 251430f712c9SDave Chinner if ((error = xfs_btree_insert(cur, &i))) 251530f712c9SDave Chinner goto done; 2516c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 251730f712c9SDave Chinner /* 251830f712c9SDave Chinner * Reset the cursor to the position of the new extent 251930f712c9SDave Chinner * we are about to insert as we can't trust it after 252030f712c9SDave Chinner * the previous insert. 252130f712c9SDave Chinner */ 2522e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(cur, new, &i); 2523e16cf9b0SChristoph Hellwig if (error) 252430f712c9SDave Chinner goto done; 2525c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 0, done); 252630f712c9SDave Chinner /* new middle extent - newext */ 252730f712c9SDave Chinner if ((error = xfs_btree_insert(cur, &i))) 252830f712c9SDave Chinner goto done; 2529c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 253030f712c9SDave Chinner } 253130f712c9SDave Chinner break; 253230f712c9SDave Chinner 253330f712c9SDave Chinner case BMAP_LEFT_FILLING | BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG: 253430f712c9SDave Chinner case BMAP_RIGHT_FILLING | BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG: 253530f712c9SDave Chinner case BMAP_LEFT_FILLING | BMAP_RIGHT_CONTIG: 253630f712c9SDave Chinner case BMAP_RIGHT_FILLING | BMAP_LEFT_CONTIG: 253730f712c9SDave Chinner case BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG: 253830f712c9SDave Chinner case BMAP_LEFT_CONTIG: 253930f712c9SDave Chinner case BMAP_RIGHT_CONTIG: 254030f712c9SDave Chinner /* 254130f712c9SDave Chinner * These cases are all impossible. 254230f712c9SDave Chinner */ 254330f712c9SDave Chinner ASSERT(0); 254430f712c9SDave Chinner } 254530f712c9SDave Chinner 25469c194644SDarrick J. Wong /* update reverse mappings */ 254705a630d7SDarrick J. Wong error = xfs_rmap_convert_extent(mp, dfops, ip, whichfork, new); 25489c194644SDarrick J. Wong if (error) 25499c194644SDarrick J. Wong goto done; 25509c194644SDarrick J. Wong 255130f712c9SDave Chinner /* convert to a btree if necessary */ 255205a630d7SDarrick J. Wong if (xfs_bmap_needs_btree(ip, whichfork)) { 255330f712c9SDave Chinner int tmp_logflags; /* partial log flag return val */ 255430f712c9SDave Chinner 255530f712c9SDave Chinner ASSERT(cur == NULL); 25562c3234d1SDarrick J. Wong error = xfs_bmap_extents_to_btree(tp, ip, first, dfops, &cur, 255705a630d7SDarrick J. Wong 0, &tmp_logflags, whichfork); 255830f712c9SDave Chinner *logflagsp |= tmp_logflags; 255930f712c9SDave Chinner if (error) 256030f712c9SDave Chinner goto done; 256130f712c9SDave Chinner } 256230f712c9SDave Chinner 256330f712c9SDave Chinner /* clear out the allocated field, done with it now in any case. */ 256430f712c9SDave Chinner if (cur) { 256530f712c9SDave Chinner cur->bc_private.b.allocated = 0; 256630f712c9SDave Chinner *curp = cur; 256730f712c9SDave Chinner } 256830f712c9SDave Chinner 256905a630d7SDarrick J. Wong xfs_bmap_check_leaf_extents(*curp, ip, whichfork); 257030f712c9SDave Chinner done: 257130f712c9SDave Chinner *logflagsp |= rval; 257230f712c9SDave Chinner return error; 257330f712c9SDave Chinner #undef LEFT 257430f712c9SDave Chinner #undef RIGHT 257530f712c9SDave Chinner #undef PREV 257630f712c9SDave Chinner } 257730f712c9SDave Chinner 257830f712c9SDave Chinner /* 257930f712c9SDave Chinner * Convert a hole to a delayed allocation. 258030f712c9SDave Chinner */ 258130f712c9SDave Chinner STATIC void 258230f712c9SDave Chinner xfs_bmap_add_extent_hole_delay( 258330f712c9SDave Chinner xfs_inode_t *ip, /* incore inode pointer */ 2584be51f811SDarrick J. Wong int whichfork, 258530f712c9SDave Chinner xfs_extnum_t *idx, /* extent number to update/insert */ 258630f712c9SDave Chinner xfs_bmbt_irec_t *new) /* new data to add to file extents */ 258730f712c9SDave Chinner { 258830f712c9SDave Chinner xfs_ifork_t *ifp; /* inode fork pointer */ 258930f712c9SDave Chinner xfs_bmbt_irec_t left; /* left neighbor extent entry */ 259030f712c9SDave Chinner xfs_filblks_t newlen=0; /* new indirect size */ 259130f712c9SDave Chinner xfs_filblks_t oldlen=0; /* old indirect size */ 259230f712c9SDave Chinner xfs_bmbt_irec_t right; /* right neighbor extent entry */ 2593060ea65bSChristoph Hellwig int state = xfs_bmap_fork_to_state(whichfork); 25943ffc18ecSChristoph Hellwig xfs_filblks_t temp; /* temp for indirect calculations */ 259530f712c9SDave Chinner 2596be51f811SDarrick J. Wong ifp = XFS_IFORK_PTR(ip, whichfork); 259730f712c9SDave Chinner ASSERT(isnullstartblock(new->br_startblock)); 259830f712c9SDave Chinner 259930f712c9SDave Chinner /* 260030f712c9SDave Chinner * Check and set flags if this segment has a left neighbor 260130f712c9SDave Chinner */ 260230f712c9SDave Chinner if (*idx > 0) { 260330f712c9SDave Chinner state |= BMAP_LEFT_VALID; 2604e3f0f756SChristoph Hellwig xfs_iext_get_extent(ifp, *idx - 1, &left); 260530f712c9SDave Chinner 260630f712c9SDave Chinner if (isnullstartblock(left.br_startblock)) 260730f712c9SDave Chinner state |= BMAP_LEFT_DELAY; 260830f712c9SDave Chinner } 260930f712c9SDave Chinner 261030f712c9SDave Chinner /* 261130f712c9SDave Chinner * Check and set flags if the current (right) segment exists. 261230f712c9SDave Chinner * If it doesn't exist, we're converting the hole at end-of-file. 261330f712c9SDave Chinner */ 26145d829300SEric Sandeen if (*idx < xfs_iext_count(ifp)) { 261530f712c9SDave Chinner state |= BMAP_RIGHT_VALID; 2616e3f0f756SChristoph Hellwig xfs_iext_get_extent(ifp, *idx, &right); 261730f712c9SDave Chinner 261830f712c9SDave Chinner if (isnullstartblock(right.br_startblock)) 261930f712c9SDave Chinner state |= BMAP_RIGHT_DELAY; 262030f712c9SDave Chinner } 262130f712c9SDave Chinner 262230f712c9SDave Chinner /* 262330f712c9SDave Chinner * Set contiguity flags on the left and right neighbors. 262430f712c9SDave Chinner * Don't let extents get too large, even if the pieces are contiguous. 262530f712c9SDave Chinner */ 262630f712c9SDave Chinner if ((state & BMAP_LEFT_VALID) && (state & BMAP_LEFT_DELAY) && 262730f712c9SDave Chinner left.br_startoff + left.br_blockcount == new->br_startoff && 262830f712c9SDave Chinner left.br_blockcount + new->br_blockcount <= MAXEXTLEN) 262930f712c9SDave Chinner state |= BMAP_LEFT_CONTIG; 263030f712c9SDave Chinner 263130f712c9SDave Chinner if ((state & BMAP_RIGHT_VALID) && (state & BMAP_RIGHT_DELAY) && 263230f712c9SDave Chinner new->br_startoff + new->br_blockcount == right.br_startoff && 263330f712c9SDave Chinner new->br_blockcount + right.br_blockcount <= MAXEXTLEN && 263430f712c9SDave Chinner (!(state & BMAP_LEFT_CONTIG) || 263530f712c9SDave Chinner (left.br_blockcount + new->br_blockcount + 263630f712c9SDave Chinner right.br_blockcount <= MAXEXTLEN))) 263730f712c9SDave Chinner state |= BMAP_RIGHT_CONTIG; 263830f712c9SDave Chinner 263930f712c9SDave Chinner /* 264030f712c9SDave Chinner * Switch out based on the contiguity flags. 264130f712c9SDave Chinner */ 264230f712c9SDave Chinner switch (state & (BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG)) { 264330f712c9SDave Chinner case BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG: 264430f712c9SDave Chinner /* 264530f712c9SDave Chinner * New allocation is contiguous with delayed allocations 264630f712c9SDave Chinner * on the left and on the right. 264730f712c9SDave Chinner * Merge all three into a single extent record. 264830f712c9SDave Chinner */ 264930f712c9SDave Chinner --*idx; 265030f712c9SDave Chinner temp = left.br_blockcount + new->br_blockcount + 265130f712c9SDave Chinner right.br_blockcount; 265230f712c9SDave Chinner 265330f712c9SDave Chinner trace_xfs_bmap_pre_update(ip, *idx, state, _THIS_IP_); 265430f712c9SDave Chinner oldlen = startblockval(left.br_startblock) + 265530f712c9SDave Chinner startblockval(new->br_startblock) + 265630f712c9SDave Chinner startblockval(right.br_startblock); 26570e339ef8SBrian Foster newlen = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(ip, temp), 26580e339ef8SBrian Foster oldlen); 26593ffc18ecSChristoph Hellwig left.br_startblock = nullstartblock(newlen); 26603ffc18ecSChristoph Hellwig left.br_blockcount = temp; 26613ffc18ecSChristoph Hellwig xfs_iext_update_extent(ifp, *idx, &left); 266230f712c9SDave Chinner trace_xfs_bmap_post_update(ip, *idx, state, _THIS_IP_); 266330f712c9SDave Chinner 266430f712c9SDave Chinner xfs_iext_remove(ip, *idx + 1, 1, state); 266530f712c9SDave Chinner break; 266630f712c9SDave Chinner 266730f712c9SDave Chinner case BMAP_LEFT_CONTIG: 266830f712c9SDave Chinner /* 266930f712c9SDave Chinner * New allocation is contiguous with a delayed allocation 267030f712c9SDave Chinner * on the left. 267130f712c9SDave Chinner * Merge the new allocation with the left neighbor. 267230f712c9SDave Chinner */ 267330f712c9SDave Chinner --*idx; 267430f712c9SDave Chinner temp = left.br_blockcount + new->br_blockcount; 267530f712c9SDave Chinner 267630f712c9SDave Chinner trace_xfs_bmap_pre_update(ip, *idx, state, _THIS_IP_); 267730f712c9SDave Chinner oldlen = startblockval(left.br_startblock) + 267830f712c9SDave Chinner startblockval(new->br_startblock); 26790e339ef8SBrian Foster newlen = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(ip, temp), 26800e339ef8SBrian Foster oldlen); 26813ffc18ecSChristoph Hellwig left.br_blockcount = temp; 26823ffc18ecSChristoph Hellwig left.br_startblock = nullstartblock(newlen); 26833ffc18ecSChristoph Hellwig xfs_iext_update_extent(ifp, *idx, &left); 268430f712c9SDave Chinner trace_xfs_bmap_post_update(ip, *idx, state, _THIS_IP_); 268530f712c9SDave Chinner break; 268630f712c9SDave Chinner 268730f712c9SDave Chinner case BMAP_RIGHT_CONTIG: 268830f712c9SDave Chinner /* 268930f712c9SDave Chinner * New allocation is contiguous with a delayed allocation 269030f712c9SDave Chinner * on the right. 269130f712c9SDave Chinner * Merge the new allocation with the right neighbor. 269230f712c9SDave Chinner */ 269330f712c9SDave Chinner trace_xfs_bmap_pre_update(ip, *idx, state, _THIS_IP_); 269430f712c9SDave Chinner temp = new->br_blockcount + right.br_blockcount; 269530f712c9SDave Chinner oldlen = startblockval(new->br_startblock) + 269630f712c9SDave Chinner startblockval(right.br_startblock); 26970e339ef8SBrian Foster newlen = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(ip, temp), 26980e339ef8SBrian Foster oldlen); 26993ffc18ecSChristoph Hellwig right.br_startoff = new->br_startoff; 27003ffc18ecSChristoph Hellwig right.br_startblock = nullstartblock(newlen); 27013ffc18ecSChristoph Hellwig right.br_blockcount = temp; 27023ffc18ecSChristoph Hellwig xfs_iext_update_extent(ifp, *idx, &right); 270330f712c9SDave Chinner trace_xfs_bmap_post_update(ip, *idx, state, _THIS_IP_); 270430f712c9SDave Chinner break; 270530f712c9SDave Chinner 270630f712c9SDave Chinner case 0: 270730f712c9SDave Chinner /* 270830f712c9SDave Chinner * New allocation is not contiguous with another 270930f712c9SDave Chinner * delayed allocation. 271030f712c9SDave Chinner * Insert a new entry. 271130f712c9SDave Chinner */ 271230f712c9SDave Chinner oldlen = newlen = 0; 271330f712c9SDave Chinner xfs_iext_insert(ip, *idx, 1, new, state); 271430f712c9SDave Chinner break; 271530f712c9SDave Chinner } 271630f712c9SDave Chinner if (oldlen != newlen) { 271730f712c9SDave Chinner ASSERT(oldlen > newlen); 27180d485adaSDave Chinner xfs_mod_fdblocks(ip->i_mount, (int64_t)(oldlen - newlen), 27190d485adaSDave Chinner false); 272030f712c9SDave Chinner /* 272130f712c9SDave Chinner * Nothing to do for disk quota accounting here. 272230f712c9SDave Chinner */ 272330f712c9SDave Chinner } 272430f712c9SDave Chinner } 272530f712c9SDave Chinner 272630f712c9SDave Chinner /* 272730f712c9SDave Chinner * Convert a hole to a real allocation. 272830f712c9SDave Chinner */ 272930f712c9SDave Chinner STATIC int /* error */ 273030f712c9SDave Chinner xfs_bmap_add_extent_hole_real( 27316d04558fSChristoph Hellwig struct xfs_trans *tp, 27326d04558fSChristoph Hellwig struct xfs_inode *ip, 27336d04558fSChristoph Hellwig int whichfork, 27346d04558fSChristoph Hellwig xfs_extnum_t *idx, 27356d04558fSChristoph Hellwig struct xfs_btree_cur **curp, 27366d04558fSChristoph Hellwig struct xfs_bmbt_irec *new, 27376d04558fSChristoph Hellwig xfs_fsblock_t *first, 27386d04558fSChristoph Hellwig struct xfs_defer_ops *dfops, 27396d04558fSChristoph Hellwig int *logflagsp) 274030f712c9SDave Chinner { 27416d04558fSChristoph Hellwig struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, whichfork); 27426d04558fSChristoph Hellwig struct xfs_mount *mp = ip->i_mount; 27436d04558fSChristoph Hellwig struct xfs_btree_cur *cur = *curp; 274430f712c9SDave Chinner int error; /* error return value */ 274530f712c9SDave Chinner int i; /* temp state */ 274630f712c9SDave Chinner xfs_bmbt_irec_t left; /* left neighbor extent entry */ 274730f712c9SDave Chinner xfs_bmbt_irec_t right; /* right neighbor extent entry */ 274830f712c9SDave Chinner int rval=0; /* return value (logging flags) */ 2749060ea65bSChristoph Hellwig int state = xfs_bmap_fork_to_state(whichfork); 27501abb9e55SChristoph Hellwig struct xfs_bmbt_irec old; 275130f712c9SDave Chinner 27526d04558fSChristoph Hellwig ASSERT(*idx >= 0); 27536d04558fSChristoph Hellwig ASSERT(*idx <= xfs_iext_count(ifp)); 275430f712c9SDave Chinner ASSERT(!isnullstartblock(new->br_startblock)); 27556d04558fSChristoph Hellwig ASSERT(!cur || !(cur->bc_private.b.flags & XFS_BTCUR_BPRV_WASDEL)); 275630f712c9SDave Chinner 2757ff6d6af2SBill O'Donnell XFS_STATS_INC(mp, xs_add_exlist); 275830f712c9SDave Chinner 275930f712c9SDave Chinner /* 276030f712c9SDave Chinner * Check and set flags if this segment has a left neighbor. 276130f712c9SDave Chinner */ 27626d04558fSChristoph Hellwig if (*idx > 0) { 276330f712c9SDave Chinner state |= BMAP_LEFT_VALID; 2764e3f0f756SChristoph Hellwig xfs_iext_get_extent(ifp, *idx - 1, &left); 276530f712c9SDave Chinner if (isnullstartblock(left.br_startblock)) 276630f712c9SDave Chinner state |= BMAP_LEFT_DELAY; 276730f712c9SDave Chinner } 276830f712c9SDave Chinner 276930f712c9SDave Chinner /* 277030f712c9SDave Chinner * Check and set flags if this segment has a current value. 277130f712c9SDave Chinner * Not true if we're inserting into the "hole" at eof. 277230f712c9SDave Chinner */ 27736d04558fSChristoph Hellwig if (*idx < xfs_iext_count(ifp)) { 277430f712c9SDave Chinner state |= BMAP_RIGHT_VALID; 2775e3f0f756SChristoph Hellwig xfs_iext_get_extent(ifp, *idx, &right); 277630f712c9SDave Chinner if (isnullstartblock(right.br_startblock)) 277730f712c9SDave Chinner state |= BMAP_RIGHT_DELAY; 277830f712c9SDave Chinner } 277930f712c9SDave Chinner 278030f712c9SDave Chinner /* 278130f712c9SDave Chinner * We're inserting a real allocation between "left" and "right". 278230f712c9SDave Chinner * Set the contiguity flags. Don't let extents get too large. 278330f712c9SDave Chinner */ 278430f712c9SDave Chinner if ((state & BMAP_LEFT_VALID) && !(state & BMAP_LEFT_DELAY) && 278530f712c9SDave Chinner left.br_startoff + left.br_blockcount == new->br_startoff && 278630f712c9SDave Chinner left.br_startblock + left.br_blockcount == new->br_startblock && 278730f712c9SDave Chinner left.br_state == new->br_state && 278830f712c9SDave Chinner left.br_blockcount + new->br_blockcount <= MAXEXTLEN) 278930f712c9SDave Chinner state |= BMAP_LEFT_CONTIG; 279030f712c9SDave Chinner 279130f712c9SDave Chinner if ((state & BMAP_RIGHT_VALID) && !(state & BMAP_RIGHT_DELAY) && 279230f712c9SDave Chinner new->br_startoff + new->br_blockcount == right.br_startoff && 279330f712c9SDave Chinner new->br_startblock + new->br_blockcount == right.br_startblock && 279430f712c9SDave Chinner new->br_state == right.br_state && 279530f712c9SDave Chinner new->br_blockcount + right.br_blockcount <= MAXEXTLEN && 279630f712c9SDave Chinner (!(state & BMAP_LEFT_CONTIG) || 279730f712c9SDave Chinner left.br_blockcount + new->br_blockcount + 279830f712c9SDave Chinner right.br_blockcount <= MAXEXTLEN)) 279930f712c9SDave Chinner state |= BMAP_RIGHT_CONTIG; 280030f712c9SDave Chinner 280130f712c9SDave Chinner error = 0; 280230f712c9SDave Chinner /* 280330f712c9SDave Chinner * Select which case we're in here, and implement it. 280430f712c9SDave Chinner */ 280530f712c9SDave Chinner switch (state & (BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG)) { 280630f712c9SDave Chinner case BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG: 280730f712c9SDave Chinner /* 280830f712c9SDave Chinner * New allocation is contiguous with real allocations on the 280930f712c9SDave Chinner * left and on the right. 281030f712c9SDave Chinner * Merge all three into a single extent record. 281130f712c9SDave Chinner */ 28126d04558fSChristoph Hellwig --*idx; 28136d04558fSChristoph Hellwig trace_xfs_bmap_pre_update(ip, *idx, state, _THIS_IP_); 28141abb9e55SChristoph Hellwig left.br_blockcount += new->br_blockcount + right.br_blockcount; 28151abb9e55SChristoph Hellwig xfs_iext_update_extent(ifp, *idx, &left); 28166d04558fSChristoph Hellwig trace_xfs_bmap_post_update(ip, *idx, state, _THIS_IP_); 281730f712c9SDave Chinner 28186d04558fSChristoph Hellwig xfs_iext_remove(ip, *idx + 1, 1, state); 281930f712c9SDave Chinner 28206d04558fSChristoph Hellwig XFS_IFORK_NEXT_SET(ip, whichfork, 28216d04558fSChristoph Hellwig XFS_IFORK_NEXTENTS(ip, whichfork) - 1); 28226d04558fSChristoph Hellwig if (cur == NULL) { 282330f712c9SDave Chinner rval = XFS_ILOG_CORE | xfs_ilog_fext(whichfork); 282430f712c9SDave Chinner } else { 282530f712c9SDave Chinner rval = XFS_ILOG_CORE; 2826e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(cur, &right, &i); 282730f712c9SDave Chinner if (error) 282830f712c9SDave Chinner goto done; 2829c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 28306d04558fSChristoph Hellwig error = xfs_btree_delete(cur, &i); 283130f712c9SDave Chinner if (error) 283230f712c9SDave Chinner goto done; 2833c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 28346d04558fSChristoph Hellwig error = xfs_btree_decrement(cur, 0, &i); 283530f712c9SDave Chinner if (error) 283630f712c9SDave Chinner goto done; 2837c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 2838a67d00a5SChristoph Hellwig error = xfs_bmbt_update(cur, &left); 283930f712c9SDave Chinner if (error) 284030f712c9SDave Chinner goto done; 284130f712c9SDave Chinner } 284230f712c9SDave Chinner break; 284330f712c9SDave Chinner 284430f712c9SDave Chinner case BMAP_LEFT_CONTIG: 284530f712c9SDave Chinner /* 284630f712c9SDave Chinner * New allocation is contiguous with a real allocation 284730f712c9SDave Chinner * on the left. 284830f712c9SDave Chinner * Merge the new allocation with the left neighbor. 284930f712c9SDave Chinner */ 28506d04558fSChristoph Hellwig --*idx; 28511abb9e55SChristoph Hellwig old = left; 28526d04558fSChristoph Hellwig trace_xfs_bmap_pre_update(ip, *idx, state, _THIS_IP_); 28531abb9e55SChristoph Hellwig left.br_blockcount += new->br_blockcount; 28541abb9e55SChristoph Hellwig xfs_iext_update_extent(ifp, *idx, &left); 28556d04558fSChristoph Hellwig trace_xfs_bmap_post_update(ip, *idx, state, _THIS_IP_); 285630f712c9SDave Chinner 28576d04558fSChristoph Hellwig if (cur == NULL) { 285830f712c9SDave Chinner rval = xfs_ilog_fext(whichfork); 285930f712c9SDave Chinner } else { 286030f712c9SDave Chinner rval = 0; 2861e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(cur, &old, &i); 286230f712c9SDave Chinner if (error) 286330f712c9SDave Chinner goto done; 2864c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 2865a67d00a5SChristoph Hellwig error = xfs_bmbt_update(cur, &left); 286630f712c9SDave Chinner if (error) 286730f712c9SDave Chinner goto done; 286830f712c9SDave Chinner } 286930f712c9SDave Chinner break; 287030f712c9SDave Chinner 287130f712c9SDave Chinner case BMAP_RIGHT_CONTIG: 287230f712c9SDave Chinner /* 287330f712c9SDave Chinner * New allocation is contiguous with a real allocation 287430f712c9SDave Chinner * on the right. 287530f712c9SDave Chinner * Merge the new allocation with the right neighbor. 287630f712c9SDave Chinner */ 28771abb9e55SChristoph Hellwig old = right; 28786d04558fSChristoph Hellwig trace_xfs_bmap_pre_update(ip, *idx, state, _THIS_IP_); 28791abb9e55SChristoph Hellwig right.br_startoff = new->br_startoff; 28801abb9e55SChristoph Hellwig right.br_startblock = new->br_startblock; 28811abb9e55SChristoph Hellwig right.br_blockcount += new->br_blockcount; 28821abb9e55SChristoph Hellwig xfs_iext_update_extent(ifp, *idx, &right); 28836d04558fSChristoph Hellwig trace_xfs_bmap_post_update(ip, *idx, state, _THIS_IP_); 288430f712c9SDave Chinner 28856d04558fSChristoph Hellwig if (cur == NULL) { 288630f712c9SDave Chinner rval = xfs_ilog_fext(whichfork); 288730f712c9SDave Chinner } else { 288830f712c9SDave Chinner rval = 0; 2889e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(cur, &old, &i); 289030f712c9SDave Chinner if (error) 289130f712c9SDave Chinner goto done; 2892c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 2893a67d00a5SChristoph Hellwig error = xfs_bmbt_update(cur, &right); 289430f712c9SDave Chinner if (error) 289530f712c9SDave Chinner goto done; 289630f712c9SDave Chinner } 289730f712c9SDave Chinner break; 289830f712c9SDave Chinner 289930f712c9SDave Chinner case 0: 290030f712c9SDave Chinner /* 290130f712c9SDave Chinner * New allocation is not contiguous with another 290230f712c9SDave Chinner * real allocation. 290330f712c9SDave Chinner * Insert a new entry. 290430f712c9SDave Chinner */ 29056d04558fSChristoph Hellwig xfs_iext_insert(ip, *idx, 1, new, state); 29066d04558fSChristoph Hellwig XFS_IFORK_NEXT_SET(ip, whichfork, 29076d04558fSChristoph Hellwig XFS_IFORK_NEXTENTS(ip, whichfork) + 1); 29086d04558fSChristoph Hellwig if (cur == NULL) { 290930f712c9SDave Chinner rval = XFS_ILOG_CORE | xfs_ilog_fext(whichfork); 291030f712c9SDave Chinner } else { 291130f712c9SDave Chinner rval = XFS_ILOG_CORE; 2912e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(cur, new, &i); 291330f712c9SDave Chinner if (error) 291430f712c9SDave Chinner goto done; 2915c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 0, done); 29166d04558fSChristoph Hellwig error = xfs_btree_insert(cur, &i); 291730f712c9SDave Chinner if (error) 291830f712c9SDave Chinner goto done; 2919c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 292030f712c9SDave Chinner } 292130f712c9SDave Chinner break; 292230f712c9SDave Chinner } 292330f712c9SDave Chinner 29249c194644SDarrick J. Wong /* add reverse mapping */ 29256d04558fSChristoph Hellwig error = xfs_rmap_map_extent(mp, dfops, ip, whichfork, new); 29269c194644SDarrick J. Wong if (error) 29279c194644SDarrick J. Wong goto done; 29289c194644SDarrick J. Wong 292930f712c9SDave Chinner /* convert to a btree if necessary */ 29306d04558fSChristoph Hellwig if (xfs_bmap_needs_btree(ip, whichfork)) { 293130f712c9SDave Chinner int tmp_logflags; /* partial log flag return val */ 293230f712c9SDave Chinner 29336d04558fSChristoph Hellwig ASSERT(cur == NULL); 29346d04558fSChristoph Hellwig error = xfs_bmap_extents_to_btree(tp, ip, first, dfops, curp, 293530f712c9SDave Chinner 0, &tmp_logflags, whichfork); 29366d04558fSChristoph Hellwig *logflagsp |= tmp_logflags; 29376d04558fSChristoph Hellwig cur = *curp; 293830f712c9SDave Chinner if (error) 293930f712c9SDave Chinner goto done; 294030f712c9SDave Chinner } 294130f712c9SDave Chinner 294230f712c9SDave Chinner /* clear out the allocated field, done with it now in any case. */ 29436d04558fSChristoph Hellwig if (cur) 29446d04558fSChristoph Hellwig cur->bc_private.b.allocated = 0; 294530f712c9SDave Chinner 29466d04558fSChristoph Hellwig xfs_bmap_check_leaf_extents(cur, ip, whichfork); 294730f712c9SDave Chinner done: 29486d04558fSChristoph Hellwig *logflagsp |= rval; 294930f712c9SDave Chinner return error; 295030f712c9SDave Chinner } 295130f712c9SDave Chinner 295230f712c9SDave Chinner /* 295330f712c9SDave Chinner * Functions used in the extent read, allocate and remove paths 295430f712c9SDave Chinner */ 295530f712c9SDave Chinner 295630f712c9SDave Chinner /* 295730f712c9SDave Chinner * Adjust the size of the new extent based on di_extsize and rt extsize. 295830f712c9SDave Chinner */ 295930f712c9SDave Chinner int 296030f712c9SDave Chinner xfs_bmap_extsize_align( 296130f712c9SDave Chinner xfs_mount_t *mp, 296230f712c9SDave Chinner xfs_bmbt_irec_t *gotp, /* next extent pointer */ 296330f712c9SDave Chinner xfs_bmbt_irec_t *prevp, /* previous extent pointer */ 296430f712c9SDave Chinner xfs_extlen_t extsz, /* align to this extent size */ 296530f712c9SDave Chinner int rt, /* is this a realtime inode? */ 296630f712c9SDave Chinner int eof, /* is extent at end-of-file? */ 296730f712c9SDave Chinner int delay, /* creating delalloc extent? */ 296830f712c9SDave Chinner int convert, /* overwriting unwritten extent? */ 296930f712c9SDave Chinner xfs_fileoff_t *offp, /* in/out: aligned offset */ 297030f712c9SDave Chinner xfs_extlen_t *lenp) /* in/out: aligned length */ 297130f712c9SDave Chinner { 297230f712c9SDave Chinner xfs_fileoff_t orig_off; /* original offset */ 297330f712c9SDave Chinner xfs_extlen_t orig_alen; /* original length */ 297430f712c9SDave Chinner xfs_fileoff_t orig_end; /* original off+len */ 297530f712c9SDave Chinner xfs_fileoff_t nexto; /* next file offset */ 297630f712c9SDave Chinner xfs_fileoff_t prevo; /* previous file offset */ 297730f712c9SDave Chinner xfs_fileoff_t align_off; /* temp for offset */ 297830f712c9SDave Chinner xfs_extlen_t align_alen; /* temp for length */ 297930f712c9SDave Chinner xfs_extlen_t temp; /* temp for calculations */ 298030f712c9SDave Chinner 298130f712c9SDave Chinner if (convert) 298230f712c9SDave Chinner return 0; 298330f712c9SDave Chinner 298430f712c9SDave Chinner orig_off = align_off = *offp; 298530f712c9SDave Chinner orig_alen = align_alen = *lenp; 298630f712c9SDave Chinner orig_end = orig_off + orig_alen; 298730f712c9SDave Chinner 298830f712c9SDave Chinner /* 298930f712c9SDave Chinner * If this request overlaps an existing extent, then don't 299030f712c9SDave Chinner * attempt to perform any additional alignment. 299130f712c9SDave Chinner */ 299230f712c9SDave Chinner if (!delay && !eof && 299330f712c9SDave Chinner (orig_off >= gotp->br_startoff) && 299430f712c9SDave Chinner (orig_end <= gotp->br_startoff + gotp->br_blockcount)) { 299530f712c9SDave Chinner return 0; 299630f712c9SDave Chinner } 299730f712c9SDave Chinner 299830f712c9SDave Chinner /* 299930f712c9SDave Chinner * If the file offset is unaligned vs. the extent size 300030f712c9SDave Chinner * we need to align it. This will be possible unless 300130f712c9SDave Chinner * the file was previously written with a kernel that didn't 300230f712c9SDave Chinner * perform this alignment, or if a truncate shot us in the 300330f712c9SDave Chinner * foot. 300430f712c9SDave Chinner */ 300530f712c9SDave Chinner temp = do_mod(orig_off, extsz); 300630f712c9SDave Chinner if (temp) { 300730f712c9SDave Chinner align_alen += temp; 300830f712c9SDave Chinner align_off -= temp; 300930f712c9SDave Chinner } 30106dea405eSDave Chinner 30116dea405eSDave Chinner /* Same adjustment for the end of the requested area. */ 30126dea405eSDave Chinner temp = (align_alen % extsz); 30136dea405eSDave Chinner if (temp) 301430f712c9SDave Chinner align_alen += extsz - temp; 30156dea405eSDave Chinner 30166dea405eSDave Chinner /* 30176dea405eSDave Chinner * For large extent hint sizes, the aligned extent might be larger than 30186dea405eSDave Chinner * MAXEXTLEN. In that case, reduce the size by an extsz so that it pulls 30196dea405eSDave Chinner * the length back under MAXEXTLEN. The outer allocation loops handle 30206dea405eSDave Chinner * short allocation just fine, so it is safe to do this. We only want to 30216dea405eSDave Chinner * do it when we are forced to, though, because it means more allocation 30226dea405eSDave Chinner * operations are required. 30236dea405eSDave Chinner */ 30246dea405eSDave Chinner while (align_alen > MAXEXTLEN) 30256dea405eSDave Chinner align_alen -= extsz; 30266dea405eSDave Chinner ASSERT(align_alen <= MAXEXTLEN); 30276dea405eSDave Chinner 302830f712c9SDave Chinner /* 302930f712c9SDave Chinner * If the previous block overlaps with this proposed allocation 303030f712c9SDave Chinner * then move the start forward without adjusting the length. 303130f712c9SDave Chinner */ 303230f712c9SDave Chinner if (prevp->br_startoff != NULLFILEOFF) { 303330f712c9SDave Chinner if (prevp->br_startblock == HOLESTARTBLOCK) 303430f712c9SDave Chinner prevo = prevp->br_startoff; 303530f712c9SDave Chinner else 303630f712c9SDave Chinner prevo = prevp->br_startoff + prevp->br_blockcount; 303730f712c9SDave Chinner } else 303830f712c9SDave Chinner prevo = 0; 303930f712c9SDave Chinner if (align_off != orig_off && align_off < prevo) 304030f712c9SDave Chinner align_off = prevo; 304130f712c9SDave Chinner /* 304230f712c9SDave Chinner * If the next block overlaps with this proposed allocation 304330f712c9SDave Chinner * then move the start back without adjusting the length, 304430f712c9SDave Chinner * but not before offset 0. 304530f712c9SDave Chinner * This may of course make the start overlap previous block, 304630f712c9SDave Chinner * and if we hit the offset 0 limit then the next block 304730f712c9SDave Chinner * can still overlap too. 304830f712c9SDave Chinner */ 304930f712c9SDave Chinner if (!eof && gotp->br_startoff != NULLFILEOFF) { 305030f712c9SDave Chinner if ((delay && gotp->br_startblock == HOLESTARTBLOCK) || 305130f712c9SDave Chinner (!delay && gotp->br_startblock == DELAYSTARTBLOCK)) 305230f712c9SDave Chinner nexto = gotp->br_startoff + gotp->br_blockcount; 305330f712c9SDave Chinner else 305430f712c9SDave Chinner nexto = gotp->br_startoff; 305530f712c9SDave Chinner } else 305630f712c9SDave Chinner nexto = NULLFILEOFF; 305730f712c9SDave Chinner if (!eof && 305830f712c9SDave Chinner align_off + align_alen != orig_end && 305930f712c9SDave Chinner align_off + align_alen > nexto) 306030f712c9SDave Chinner align_off = nexto > align_alen ? nexto - align_alen : 0; 306130f712c9SDave Chinner /* 306230f712c9SDave Chinner * If we're now overlapping the next or previous extent that 306330f712c9SDave Chinner * means we can't fit an extsz piece in this hole. Just move 306430f712c9SDave Chinner * the start forward to the first valid spot and set 306530f712c9SDave Chinner * the length so we hit the end. 306630f712c9SDave Chinner */ 306730f712c9SDave Chinner if (align_off != orig_off && align_off < prevo) 306830f712c9SDave Chinner align_off = prevo; 306930f712c9SDave Chinner if (align_off + align_alen != orig_end && 307030f712c9SDave Chinner align_off + align_alen > nexto && 307130f712c9SDave Chinner nexto != NULLFILEOFF) { 307230f712c9SDave Chinner ASSERT(nexto > prevo); 307330f712c9SDave Chinner align_alen = nexto - align_off; 307430f712c9SDave Chinner } 307530f712c9SDave Chinner 307630f712c9SDave Chinner /* 307730f712c9SDave Chinner * If realtime, and the result isn't a multiple of the realtime 307830f712c9SDave Chinner * extent size we need to remove blocks until it is. 307930f712c9SDave Chinner */ 308030f712c9SDave Chinner if (rt && (temp = (align_alen % mp->m_sb.sb_rextsize))) { 308130f712c9SDave Chinner /* 308230f712c9SDave Chinner * We're not covering the original request, or 308330f712c9SDave Chinner * we won't be able to once we fix the length. 308430f712c9SDave Chinner */ 308530f712c9SDave Chinner if (orig_off < align_off || 308630f712c9SDave Chinner orig_end > align_off + align_alen || 308730f712c9SDave Chinner align_alen - temp < orig_alen) 30882451337dSDave Chinner return -EINVAL; 308930f712c9SDave Chinner /* 309030f712c9SDave Chinner * Try to fix it by moving the start up. 309130f712c9SDave Chinner */ 309230f712c9SDave Chinner if (align_off + temp <= orig_off) { 309330f712c9SDave Chinner align_alen -= temp; 309430f712c9SDave Chinner align_off += temp; 309530f712c9SDave Chinner } 309630f712c9SDave Chinner /* 309730f712c9SDave Chinner * Try to fix it by moving the end in. 309830f712c9SDave Chinner */ 309930f712c9SDave Chinner else if (align_off + align_alen - temp >= orig_end) 310030f712c9SDave Chinner align_alen -= temp; 310130f712c9SDave Chinner /* 310230f712c9SDave Chinner * Set the start to the minimum then trim the length. 310330f712c9SDave Chinner */ 310430f712c9SDave Chinner else { 310530f712c9SDave Chinner align_alen -= orig_off - align_off; 310630f712c9SDave Chinner align_off = orig_off; 310730f712c9SDave Chinner align_alen -= align_alen % mp->m_sb.sb_rextsize; 310830f712c9SDave Chinner } 310930f712c9SDave Chinner /* 311030f712c9SDave Chinner * Result doesn't cover the request, fail it. 311130f712c9SDave Chinner */ 311230f712c9SDave Chinner if (orig_off < align_off || orig_end > align_off + align_alen) 31132451337dSDave Chinner return -EINVAL; 311430f712c9SDave Chinner } else { 311530f712c9SDave Chinner ASSERT(orig_off >= align_off); 31166dea405eSDave Chinner /* see MAXEXTLEN handling above */ 31176dea405eSDave Chinner ASSERT(orig_end <= align_off + align_alen || 31186dea405eSDave Chinner align_alen + extsz > MAXEXTLEN); 311930f712c9SDave Chinner } 312030f712c9SDave Chinner 312130f712c9SDave Chinner #ifdef DEBUG 312230f712c9SDave Chinner if (!eof && gotp->br_startoff != NULLFILEOFF) 312330f712c9SDave Chinner ASSERT(align_off + align_alen <= gotp->br_startoff); 312430f712c9SDave Chinner if (prevp->br_startoff != NULLFILEOFF) 312530f712c9SDave Chinner ASSERT(align_off >= prevp->br_startoff + prevp->br_blockcount); 312630f712c9SDave Chinner #endif 312730f712c9SDave Chinner 312830f712c9SDave Chinner *lenp = align_alen; 312930f712c9SDave Chinner *offp = align_off; 313030f712c9SDave Chinner return 0; 313130f712c9SDave Chinner } 313230f712c9SDave Chinner 313330f712c9SDave Chinner #define XFS_ALLOC_GAP_UNITS 4 313430f712c9SDave Chinner 313530f712c9SDave Chinner void 313630f712c9SDave Chinner xfs_bmap_adjacent( 313730f712c9SDave Chinner struct xfs_bmalloca *ap) /* bmap alloc argument struct */ 313830f712c9SDave Chinner { 313930f712c9SDave Chinner xfs_fsblock_t adjust; /* adjustment to block numbers */ 314030f712c9SDave Chinner xfs_agnumber_t fb_agno; /* ag number of ap->firstblock */ 314130f712c9SDave Chinner xfs_mount_t *mp; /* mount point structure */ 314230f712c9SDave Chinner int nullfb; /* true if ap->firstblock isn't set */ 314330f712c9SDave Chinner int rt; /* true if inode is realtime */ 314430f712c9SDave Chinner 314530f712c9SDave Chinner #define ISVALID(x,y) \ 314630f712c9SDave Chinner (rt ? \ 314730f712c9SDave Chinner (x) < mp->m_sb.sb_rblocks : \ 314830f712c9SDave Chinner XFS_FSB_TO_AGNO(mp, x) == XFS_FSB_TO_AGNO(mp, y) && \ 314930f712c9SDave Chinner XFS_FSB_TO_AGNO(mp, x) < mp->m_sb.sb_agcount && \ 315030f712c9SDave Chinner XFS_FSB_TO_AGBNO(mp, x) < mp->m_sb.sb_agblocks) 315130f712c9SDave Chinner 315230f712c9SDave Chinner mp = ap->ip->i_mount; 315330f712c9SDave Chinner nullfb = *ap->firstblock == NULLFSBLOCK; 3154292378edSDave Chinner rt = XFS_IS_REALTIME_INODE(ap->ip) && 3155292378edSDave Chinner xfs_alloc_is_userdata(ap->datatype); 315630f712c9SDave Chinner fb_agno = nullfb ? NULLAGNUMBER : XFS_FSB_TO_AGNO(mp, *ap->firstblock); 315730f712c9SDave Chinner /* 315830f712c9SDave Chinner * If allocating at eof, and there's a previous real block, 315930f712c9SDave Chinner * try to use its last block as our starting point. 316030f712c9SDave Chinner */ 316130f712c9SDave Chinner if (ap->eof && ap->prev.br_startoff != NULLFILEOFF && 316230f712c9SDave Chinner !isnullstartblock(ap->prev.br_startblock) && 316330f712c9SDave Chinner ISVALID(ap->prev.br_startblock + ap->prev.br_blockcount, 316430f712c9SDave Chinner ap->prev.br_startblock)) { 316530f712c9SDave Chinner ap->blkno = ap->prev.br_startblock + ap->prev.br_blockcount; 316630f712c9SDave Chinner /* 316730f712c9SDave Chinner * Adjust for the gap between prevp and us. 316830f712c9SDave Chinner */ 316930f712c9SDave Chinner adjust = ap->offset - 317030f712c9SDave Chinner (ap->prev.br_startoff + ap->prev.br_blockcount); 317130f712c9SDave Chinner if (adjust && 317230f712c9SDave Chinner ISVALID(ap->blkno + adjust, ap->prev.br_startblock)) 317330f712c9SDave Chinner ap->blkno += adjust; 317430f712c9SDave Chinner } 317530f712c9SDave Chinner /* 317630f712c9SDave Chinner * If not at eof, then compare the two neighbor blocks. 317730f712c9SDave Chinner * Figure out whether either one gives us a good starting point, 317830f712c9SDave Chinner * and pick the better one. 317930f712c9SDave Chinner */ 318030f712c9SDave Chinner else if (!ap->eof) { 318130f712c9SDave Chinner xfs_fsblock_t gotbno; /* right side block number */ 318230f712c9SDave Chinner xfs_fsblock_t gotdiff=0; /* right side difference */ 318330f712c9SDave Chinner xfs_fsblock_t prevbno; /* left side block number */ 318430f712c9SDave Chinner xfs_fsblock_t prevdiff=0; /* left side difference */ 318530f712c9SDave Chinner 318630f712c9SDave Chinner /* 318730f712c9SDave Chinner * If there's a previous (left) block, select a requested 318830f712c9SDave Chinner * start block based on it. 318930f712c9SDave Chinner */ 319030f712c9SDave Chinner if (ap->prev.br_startoff != NULLFILEOFF && 319130f712c9SDave Chinner !isnullstartblock(ap->prev.br_startblock) && 319230f712c9SDave Chinner (prevbno = ap->prev.br_startblock + 319330f712c9SDave Chinner ap->prev.br_blockcount) && 319430f712c9SDave Chinner ISVALID(prevbno, ap->prev.br_startblock)) { 319530f712c9SDave Chinner /* 319630f712c9SDave Chinner * Calculate gap to end of previous block. 319730f712c9SDave Chinner */ 319830f712c9SDave Chinner adjust = prevdiff = ap->offset - 319930f712c9SDave Chinner (ap->prev.br_startoff + 320030f712c9SDave Chinner ap->prev.br_blockcount); 320130f712c9SDave Chinner /* 320230f712c9SDave Chinner * Figure the startblock based on the previous block's 320330f712c9SDave Chinner * end and the gap size. 320430f712c9SDave Chinner * Heuristic! 320530f712c9SDave Chinner * If the gap is large relative to the piece we're 320630f712c9SDave Chinner * allocating, or using it gives us an invalid block 320730f712c9SDave Chinner * number, then just use the end of the previous block. 320830f712c9SDave Chinner */ 320930f712c9SDave Chinner if (prevdiff <= XFS_ALLOC_GAP_UNITS * ap->length && 321030f712c9SDave Chinner ISVALID(prevbno + prevdiff, 321130f712c9SDave Chinner ap->prev.br_startblock)) 321230f712c9SDave Chinner prevbno += adjust; 321330f712c9SDave Chinner else 321430f712c9SDave Chinner prevdiff += adjust; 321530f712c9SDave Chinner /* 321630f712c9SDave Chinner * If the firstblock forbids it, can't use it, 321730f712c9SDave Chinner * must use default. 321830f712c9SDave Chinner */ 321930f712c9SDave Chinner if (!rt && !nullfb && 322030f712c9SDave Chinner XFS_FSB_TO_AGNO(mp, prevbno) != fb_agno) 322130f712c9SDave Chinner prevbno = NULLFSBLOCK; 322230f712c9SDave Chinner } 322330f712c9SDave Chinner /* 322430f712c9SDave Chinner * No previous block or can't follow it, just default. 322530f712c9SDave Chinner */ 322630f712c9SDave Chinner else 322730f712c9SDave Chinner prevbno = NULLFSBLOCK; 322830f712c9SDave Chinner /* 322930f712c9SDave Chinner * If there's a following (right) block, select a requested 323030f712c9SDave Chinner * start block based on it. 323130f712c9SDave Chinner */ 323230f712c9SDave Chinner if (!isnullstartblock(ap->got.br_startblock)) { 323330f712c9SDave Chinner /* 323430f712c9SDave Chinner * Calculate gap to start of next block. 323530f712c9SDave Chinner */ 323630f712c9SDave Chinner adjust = gotdiff = ap->got.br_startoff - ap->offset; 323730f712c9SDave Chinner /* 323830f712c9SDave Chinner * Figure the startblock based on the next block's 323930f712c9SDave Chinner * start and the gap size. 324030f712c9SDave Chinner */ 324130f712c9SDave Chinner gotbno = ap->got.br_startblock; 324230f712c9SDave Chinner /* 324330f712c9SDave Chinner * Heuristic! 324430f712c9SDave Chinner * If the gap is large relative to the piece we're 324530f712c9SDave Chinner * allocating, or using it gives us an invalid block 324630f712c9SDave Chinner * number, then just use the start of the next block 324730f712c9SDave Chinner * offset by our length. 324830f712c9SDave Chinner */ 324930f712c9SDave Chinner if (gotdiff <= XFS_ALLOC_GAP_UNITS * ap->length && 325030f712c9SDave Chinner ISVALID(gotbno - gotdiff, gotbno)) 325130f712c9SDave Chinner gotbno -= adjust; 325230f712c9SDave Chinner else if (ISVALID(gotbno - ap->length, gotbno)) { 325330f712c9SDave Chinner gotbno -= ap->length; 325430f712c9SDave Chinner gotdiff += adjust - ap->length; 325530f712c9SDave Chinner } else 325630f712c9SDave Chinner gotdiff += adjust; 325730f712c9SDave Chinner /* 325830f712c9SDave Chinner * If the firstblock forbids it, can't use it, 325930f712c9SDave Chinner * must use default. 326030f712c9SDave Chinner */ 326130f712c9SDave Chinner if (!rt && !nullfb && 326230f712c9SDave Chinner XFS_FSB_TO_AGNO(mp, gotbno) != fb_agno) 326330f712c9SDave Chinner gotbno = NULLFSBLOCK; 326430f712c9SDave Chinner } 326530f712c9SDave Chinner /* 326630f712c9SDave Chinner * No next block, just default. 326730f712c9SDave Chinner */ 326830f712c9SDave Chinner else 326930f712c9SDave Chinner gotbno = NULLFSBLOCK; 327030f712c9SDave Chinner /* 327130f712c9SDave Chinner * If both valid, pick the better one, else the only good 327230f712c9SDave Chinner * one, else ap->blkno is already set (to 0 or the inode block). 327330f712c9SDave Chinner */ 327430f712c9SDave Chinner if (prevbno != NULLFSBLOCK && gotbno != NULLFSBLOCK) 327530f712c9SDave Chinner ap->blkno = prevdiff <= gotdiff ? prevbno : gotbno; 327630f712c9SDave Chinner else if (prevbno != NULLFSBLOCK) 327730f712c9SDave Chinner ap->blkno = prevbno; 327830f712c9SDave Chinner else if (gotbno != NULLFSBLOCK) 327930f712c9SDave Chinner ap->blkno = gotbno; 328030f712c9SDave Chinner } 328130f712c9SDave Chinner #undef ISVALID 328230f712c9SDave Chinner } 328330f712c9SDave Chinner 328430f712c9SDave Chinner static int 328530f712c9SDave Chinner xfs_bmap_longest_free_extent( 328630f712c9SDave Chinner struct xfs_trans *tp, 328730f712c9SDave Chinner xfs_agnumber_t ag, 328830f712c9SDave Chinner xfs_extlen_t *blen, 328930f712c9SDave Chinner int *notinit) 329030f712c9SDave Chinner { 329130f712c9SDave Chinner struct xfs_mount *mp = tp->t_mountp; 329230f712c9SDave Chinner struct xfs_perag *pag; 329330f712c9SDave Chinner xfs_extlen_t longest; 329430f712c9SDave Chinner int error = 0; 329530f712c9SDave Chinner 329630f712c9SDave Chinner pag = xfs_perag_get(mp, ag); 329730f712c9SDave Chinner if (!pag->pagf_init) { 329830f712c9SDave Chinner error = xfs_alloc_pagf_init(mp, tp, ag, XFS_ALLOC_FLAG_TRYLOCK); 329930f712c9SDave Chinner if (error) 330030f712c9SDave Chinner goto out; 330130f712c9SDave Chinner 330230f712c9SDave Chinner if (!pag->pagf_init) { 330330f712c9SDave Chinner *notinit = 1; 330430f712c9SDave Chinner goto out; 330530f712c9SDave Chinner } 330630f712c9SDave Chinner } 330730f712c9SDave Chinner 330850adbcb4SDave Chinner longest = xfs_alloc_longest_free_extent(mp, pag, 33093fd129b6SDarrick J. Wong xfs_alloc_min_freelist(mp, pag), 33103fd129b6SDarrick J. Wong xfs_ag_resv_needed(pag, XFS_AG_RESV_NONE)); 331130f712c9SDave Chinner if (*blen < longest) 331230f712c9SDave Chinner *blen = longest; 331330f712c9SDave Chinner 331430f712c9SDave Chinner out: 331530f712c9SDave Chinner xfs_perag_put(pag); 331630f712c9SDave Chinner return error; 331730f712c9SDave Chinner } 331830f712c9SDave Chinner 331930f712c9SDave Chinner static void 332030f712c9SDave Chinner xfs_bmap_select_minlen( 332130f712c9SDave Chinner struct xfs_bmalloca *ap, 332230f712c9SDave Chinner struct xfs_alloc_arg *args, 332330f712c9SDave Chinner xfs_extlen_t *blen, 332430f712c9SDave Chinner int notinit) 332530f712c9SDave Chinner { 332630f712c9SDave Chinner if (notinit || *blen < ap->minlen) { 332730f712c9SDave Chinner /* 332830f712c9SDave Chinner * Since we did a BUF_TRYLOCK above, it is possible that 332930f712c9SDave Chinner * there is space for this request. 333030f712c9SDave Chinner */ 333130f712c9SDave Chinner args->minlen = ap->minlen; 333230f712c9SDave Chinner } else if (*blen < args->maxlen) { 333330f712c9SDave Chinner /* 333430f712c9SDave Chinner * If the best seen length is less than the request length, 333530f712c9SDave Chinner * use the best as the minimum. 333630f712c9SDave Chinner */ 333730f712c9SDave Chinner args->minlen = *blen; 333830f712c9SDave Chinner } else { 333930f712c9SDave Chinner /* 334030f712c9SDave Chinner * Otherwise we've seen an extent as big as maxlen, use that 334130f712c9SDave Chinner * as the minimum. 334230f712c9SDave Chinner */ 334330f712c9SDave Chinner args->minlen = args->maxlen; 334430f712c9SDave Chinner } 334530f712c9SDave Chinner } 334630f712c9SDave Chinner 334730f712c9SDave Chinner STATIC int 334830f712c9SDave Chinner xfs_bmap_btalloc_nullfb( 334930f712c9SDave Chinner struct xfs_bmalloca *ap, 335030f712c9SDave Chinner struct xfs_alloc_arg *args, 335130f712c9SDave Chinner xfs_extlen_t *blen) 335230f712c9SDave Chinner { 335330f712c9SDave Chinner struct xfs_mount *mp = ap->ip->i_mount; 335430f712c9SDave Chinner xfs_agnumber_t ag, startag; 335530f712c9SDave Chinner int notinit = 0; 335630f712c9SDave Chinner int error; 335730f712c9SDave Chinner 335830f712c9SDave Chinner args->type = XFS_ALLOCTYPE_START_BNO; 335930f712c9SDave Chinner args->total = ap->total; 336030f712c9SDave Chinner 336130f712c9SDave Chinner startag = ag = XFS_FSB_TO_AGNO(mp, args->fsbno); 336230f712c9SDave Chinner if (startag == NULLAGNUMBER) 336330f712c9SDave Chinner startag = ag = 0; 336430f712c9SDave Chinner 336530f712c9SDave Chinner while (*blen < args->maxlen) { 336630f712c9SDave Chinner error = xfs_bmap_longest_free_extent(args->tp, ag, blen, 336730f712c9SDave Chinner ¬init); 336830f712c9SDave Chinner if (error) 336930f712c9SDave Chinner return error; 337030f712c9SDave Chinner 337130f712c9SDave Chinner if (++ag == mp->m_sb.sb_agcount) 337230f712c9SDave Chinner ag = 0; 337330f712c9SDave Chinner if (ag == startag) 337430f712c9SDave Chinner break; 337530f712c9SDave Chinner } 337630f712c9SDave Chinner 337730f712c9SDave Chinner xfs_bmap_select_minlen(ap, args, blen, notinit); 337830f712c9SDave Chinner return 0; 337930f712c9SDave Chinner } 338030f712c9SDave Chinner 338130f712c9SDave Chinner STATIC int 338230f712c9SDave Chinner xfs_bmap_btalloc_filestreams( 338330f712c9SDave Chinner struct xfs_bmalloca *ap, 338430f712c9SDave Chinner struct xfs_alloc_arg *args, 338530f712c9SDave Chinner xfs_extlen_t *blen) 338630f712c9SDave Chinner { 338730f712c9SDave Chinner struct xfs_mount *mp = ap->ip->i_mount; 338830f712c9SDave Chinner xfs_agnumber_t ag; 338930f712c9SDave Chinner int notinit = 0; 339030f712c9SDave Chinner int error; 339130f712c9SDave Chinner 339230f712c9SDave Chinner args->type = XFS_ALLOCTYPE_NEAR_BNO; 339330f712c9SDave Chinner args->total = ap->total; 339430f712c9SDave Chinner 339530f712c9SDave Chinner ag = XFS_FSB_TO_AGNO(mp, args->fsbno); 339630f712c9SDave Chinner if (ag == NULLAGNUMBER) 339730f712c9SDave Chinner ag = 0; 339830f712c9SDave Chinner 339930f712c9SDave Chinner error = xfs_bmap_longest_free_extent(args->tp, ag, blen, ¬init); 340030f712c9SDave Chinner if (error) 340130f712c9SDave Chinner return error; 340230f712c9SDave Chinner 340330f712c9SDave Chinner if (*blen < args->maxlen) { 340430f712c9SDave Chinner error = xfs_filestream_new_ag(ap, &ag); 340530f712c9SDave Chinner if (error) 340630f712c9SDave Chinner return error; 340730f712c9SDave Chinner 340830f712c9SDave Chinner error = xfs_bmap_longest_free_extent(args->tp, ag, blen, 340930f712c9SDave Chinner ¬init); 341030f712c9SDave Chinner if (error) 341130f712c9SDave Chinner return error; 341230f712c9SDave Chinner 341330f712c9SDave Chinner } 341430f712c9SDave Chinner 341530f712c9SDave Chinner xfs_bmap_select_minlen(ap, args, blen, notinit); 341630f712c9SDave Chinner 341730f712c9SDave Chinner /* 341830f712c9SDave Chinner * Set the failure fallback case to look in the selected AG as stream 341930f712c9SDave Chinner * may have moved. 342030f712c9SDave Chinner */ 342130f712c9SDave Chinner ap->blkno = args->fsbno = XFS_AGB_TO_FSB(mp, ag, 0); 342230f712c9SDave Chinner return 0; 342330f712c9SDave Chinner } 342430f712c9SDave Chinner 342530f712c9SDave Chinner STATIC int 342630f712c9SDave Chinner xfs_bmap_btalloc( 342730f712c9SDave Chinner struct xfs_bmalloca *ap) /* bmap alloc argument struct */ 342830f712c9SDave Chinner { 342930f712c9SDave Chinner xfs_mount_t *mp; /* mount point structure */ 343030f712c9SDave Chinner xfs_alloctype_t atype = 0; /* type for allocation routines */ 3431292378edSDave Chinner xfs_extlen_t align = 0; /* minimum allocation alignment */ 343230f712c9SDave Chinner xfs_agnumber_t fb_agno; /* ag number of ap->firstblock */ 343330f712c9SDave Chinner xfs_agnumber_t ag; 343430f712c9SDave Chinner xfs_alloc_arg_t args; 343530f712c9SDave Chinner xfs_extlen_t blen; 343630f712c9SDave Chinner xfs_extlen_t nextminlen = 0; 343730f712c9SDave Chinner int nullfb; /* true if ap->firstblock isn't set */ 343830f712c9SDave Chinner int isaligned; 343930f712c9SDave Chinner int tryagain; 344030f712c9SDave Chinner int error; 344130f712c9SDave Chinner int stripe_align; 344230f712c9SDave Chinner 344330f712c9SDave Chinner ASSERT(ap->length); 344430f712c9SDave Chinner 344530f712c9SDave Chinner mp = ap->ip->i_mount; 344630f712c9SDave Chinner 344730f712c9SDave Chinner /* stripe alignment for allocation is determined by mount parameters */ 344830f712c9SDave Chinner stripe_align = 0; 344930f712c9SDave Chinner if (mp->m_swidth && (mp->m_flags & XFS_MOUNT_SWALLOC)) 345030f712c9SDave Chinner stripe_align = mp->m_swidth; 345130f712c9SDave Chinner else if (mp->m_dalign) 345230f712c9SDave Chinner stripe_align = mp->m_dalign; 345330f712c9SDave Chinner 3454f7ca3522SDarrick J. Wong if (ap->flags & XFS_BMAPI_COWFORK) 3455f7ca3522SDarrick J. Wong align = xfs_get_cowextsz_hint(ap->ip); 3456f7ca3522SDarrick J. Wong else if (xfs_alloc_is_userdata(ap->datatype)) 3457292378edSDave Chinner align = xfs_get_extsz_hint(ap->ip); 3458493611ebSChristoph Hellwig if (align) { 345930f712c9SDave Chinner error = xfs_bmap_extsize_align(mp, &ap->got, &ap->prev, 346030f712c9SDave Chinner align, 0, ap->eof, 0, ap->conv, 346130f712c9SDave Chinner &ap->offset, &ap->length); 346230f712c9SDave Chinner ASSERT(!error); 346330f712c9SDave Chinner ASSERT(ap->length); 346430f712c9SDave Chinner } 346530f712c9SDave Chinner 346630f712c9SDave Chinner 346730f712c9SDave Chinner nullfb = *ap->firstblock == NULLFSBLOCK; 346830f712c9SDave Chinner fb_agno = nullfb ? NULLAGNUMBER : XFS_FSB_TO_AGNO(mp, *ap->firstblock); 346930f712c9SDave Chinner if (nullfb) { 3470292378edSDave Chinner if (xfs_alloc_is_userdata(ap->datatype) && 3471292378edSDave Chinner xfs_inode_is_filestream(ap->ip)) { 347230f712c9SDave Chinner ag = xfs_filestream_lookup_ag(ap->ip); 347330f712c9SDave Chinner ag = (ag != NULLAGNUMBER) ? ag : 0; 347430f712c9SDave Chinner ap->blkno = XFS_AGB_TO_FSB(mp, ag, 0); 347530f712c9SDave Chinner } else { 347630f712c9SDave Chinner ap->blkno = XFS_INO_TO_FSB(mp, ap->ip->i_ino); 347730f712c9SDave Chinner } 347830f712c9SDave Chinner } else 347930f712c9SDave Chinner ap->blkno = *ap->firstblock; 348030f712c9SDave Chinner 348130f712c9SDave Chinner xfs_bmap_adjacent(ap); 348230f712c9SDave Chinner 348330f712c9SDave Chinner /* 348430f712c9SDave Chinner * If allowed, use ap->blkno; otherwise must use firstblock since 348530f712c9SDave Chinner * it's in the right allocation group. 348630f712c9SDave Chinner */ 348730f712c9SDave Chinner if (nullfb || XFS_FSB_TO_AGNO(mp, ap->blkno) == fb_agno) 348830f712c9SDave Chinner ; 348930f712c9SDave Chinner else 349030f712c9SDave Chinner ap->blkno = *ap->firstblock; 349130f712c9SDave Chinner /* 349230f712c9SDave Chinner * Normal allocation, done through xfs_alloc_vextent. 349330f712c9SDave Chinner */ 349430f712c9SDave Chinner tryagain = isaligned = 0; 349530f712c9SDave Chinner memset(&args, 0, sizeof(args)); 349630f712c9SDave Chinner args.tp = ap->tp; 349730f712c9SDave Chinner args.mp = mp; 349830f712c9SDave Chinner args.fsbno = ap->blkno; 3499340785ccSDarrick J. Wong xfs_rmap_skip_owner_update(&args.oinfo); 350030f712c9SDave Chinner 350130f712c9SDave Chinner /* Trim the allocation back to the maximum an AG can fit. */ 350252548852SDarrick J. Wong args.maxlen = MIN(ap->length, mp->m_ag_max_usable); 350330f712c9SDave Chinner args.firstblock = *ap->firstblock; 350430f712c9SDave Chinner blen = 0; 350530f712c9SDave Chinner if (nullfb) { 350630f712c9SDave Chinner /* 350730f712c9SDave Chinner * Search for an allocation group with a single extent large 350830f712c9SDave Chinner * enough for the request. If one isn't found, then adjust 350930f712c9SDave Chinner * the minimum allocation size to the largest space found. 351030f712c9SDave Chinner */ 3511292378edSDave Chinner if (xfs_alloc_is_userdata(ap->datatype) && 3512292378edSDave Chinner xfs_inode_is_filestream(ap->ip)) 351330f712c9SDave Chinner error = xfs_bmap_btalloc_filestreams(ap, &args, &blen); 351430f712c9SDave Chinner else 351530f712c9SDave Chinner error = xfs_bmap_btalloc_nullfb(ap, &args, &blen); 351630f712c9SDave Chinner if (error) 351730f712c9SDave Chinner return error; 35182c3234d1SDarrick J. Wong } else if (ap->dfops->dop_low) { 351930f712c9SDave Chinner if (xfs_inode_is_filestream(ap->ip)) 352030f712c9SDave Chinner args.type = XFS_ALLOCTYPE_FIRST_AG; 352130f712c9SDave Chinner else 352230f712c9SDave Chinner args.type = XFS_ALLOCTYPE_START_BNO; 352330f712c9SDave Chinner args.total = args.minlen = ap->minlen; 352430f712c9SDave Chinner } else { 352530f712c9SDave Chinner args.type = XFS_ALLOCTYPE_NEAR_BNO; 352630f712c9SDave Chinner args.total = ap->total; 352730f712c9SDave Chinner args.minlen = ap->minlen; 352830f712c9SDave Chinner } 352930f712c9SDave Chinner /* apply extent size hints if obtained earlier */ 3530493611ebSChristoph Hellwig if (align) { 353130f712c9SDave Chinner args.prod = align; 353230f712c9SDave Chinner if ((args.mod = (xfs_extlen_t)do_mod(ap->offset, args.prod))) 353330f712c9SDave Chinner args.mod = (xfs_extlen_t)(args.prod - args.mod); 353409cbfeafSKirill A. Shutemov } else if (mp->m_sb.sb_blocksize >= PAGE_SIZE) { 353530f712c9SDave Chinner args.prod = 1; 353630f712c9SDave Chinner args.mod = 0; 353730f712c9SDave Chinner } else { 353809cbfeafSKirill A. Shutemov args.prod = PAGE_SIZE >> mp->m_sb.sb_blocklog; 353930f712c9SDave Chinner if ((args.mod = (xfs_extlen_t)(do_mod(ap->offset, args.prod)))) 354030f712c9SDave Chinner args.mod = (xfs_extlen_t)(args.prod - args.mod); 354130f712c9SDave Chinner } 354230f712c9SDave Chinner /* 354330f712c9SDave Chinner * If we are not low on available data blocks, and the 354430f712c9SDave Chinner * underlying logical volume manager is a stripe, and 354530f712c9SDave Chinner * the file offset is zero then try to allocate data 354630f712c9SDave Chinner * blocks on stripe unit boundary. 354730f712c9SDave Chinner * NOTE: ap->aeof is only set if the allocation length 354830f712c9SDave Chinner * is >= the stripe unit and the allocation offset is 354930f712c9SDave Chinner * at the end of file. 355030f712c9SDave Chinner */ 35512c3234d1SDarrick J. Wong if (!ap->dfops->dop_low && ap->aeof) { 355230f712c9SDave Chinner if (!ap->offset) { 355330f712c9SDave Chinner args.alignment = stripe_align; 355430f712c9SDave Chinner atype = args.type; 355530f712c9SDave Chinner isaligned = 1; 355630f712c9SDave Chinner /* 355730f712c9SDave Chinner * Adjust for alignment 355830f712c9SDave Chinner */ 355930f712c9SDave Chinner if (blen > args.alignment && blen <= args.maxlen) 356030f712c9SDave Chinner args.minlen = blen - args.alignment; 356130f712c9SDave Chinner args.minalignslop = 0; 356230f712c9SDave Chinner } else { 356330f712c9SDave Chinner /* 356430f712c9SDave Chinner * First try an exact bno allocation. 356530f712c9SDave Chinner * If it fails then do a near or start bno 356630f712c9SDave Chinner * allocation with alignment turned on. 356730f712c9SDave Chinner */ 356830f712c9SDave Chinner atype = args.type; 356930f712c9SDave Chinner tryagain = 1; 357030f712c9SDave Chinner args.type = XFS_ALLOCTYPE_THIS_BNO; 357130f712c9SDave Chinner args.alignment = 1; 357230f712c9SDave Chinner /* 357330f712c9SDave Chinner * Compute the minlen+alignment for the 357430f712c9SDave Chinner * next case. Set slop so that the value 357530f712c9SDave Chinner * of minlen+alignment+slop doesn't go up 357630f712c9SDave Chinner * between the calls. 357730f712c9SDave Chinner */ 357830f712c9SDave Chinner if (blen > stripe_align && blen <= args.maxlen) 357930f712c9SDave Chinner nextminlen = blen - stripe_align; 358030f712c9SDave Chinner else 358130f712c9SDave Chinner nextminlen = args.minlen; 358230f712c9SDave Chinner if (nextminlen + stripe_align > args.minlen + 1) 358330f712c9SDave Chinner args.minalignslop = 358430f712c9SDave Chinner nextminlen + stripe_align - 358530f712c9SDave Chinner args.minlen - 1; 358630f712c9SDave Chinner else 358730f712c9SDave Chinner args.minalignslop = 0; 358830f712c9SDave Chinner } 358930f712c9SDave Chinner } else { 359030f712c9SDave Chinner args.alignment = 1; 359130f712c9SDave Chinner args.minalignslop = 0; 359230f712c9SDave Chinner } 359330f712c9SDave Chinner args.minleft = ap->minleft; 359430f712c9SDave Chinner args.wasdel = ap->wasdel; 35953fd129b6SDarrick J. Wong args.resv = XFS_AG_RESV_NONE; 3596292378edSDave Chinner args.datatype = ap->datatype; 3597292378edSDave Chinner if (ap->datatype & XFS_ALLOC_USERDATA_ZERO) 35983fbbbea3SDave Chinner args.ip = ap->ip; 35993fbbbea3SDave Chinner 36003fbbbea3SDave Chinner error = xfs_alloc_vextent(&args); 36013fbbbea3SDave Chinner if (error) 360230f712c9SDave Chinner return error; 36033fbbbea3SDave Chinner 360430f712c9SDave Chinner if (tryagain && args.fsbno == NULLFSBLOCK) { 360530f712c9SDave Chinner /* 360630f712c9SDave Chinner * Exact allocation failed. Now try with alignment 360730f712c9SDave Chinner * turned on. 360830f712c9SDave Chinner */ 360930f712c9SDave Chinner args.type = atype; 361030f712c9SDave Chinner args.fsbno = ap->blkno; 361130f712c9SDave Chinner args.alignment = stripe_align; 361230f712c9SDave Chinner args.minlen = nextminlen; 361330f712c9SDave Chinner args.minalignslop = 0; 361430f712c9SDave Chinner isaligned = 1; 361530f712c9SDave Chinner if ((error = xfs_alloc_vextent(&args))) 361630f712c9SDave Chinner return error; 361730f712c9SDave Chinner } 361830f712c9SDave Chinner if (isaligned && args.fsbno == NULLFSBLOCK) { 361930f712c9SDave Chinner /* 362030f712c9SDave Chinner * allocation failed, so turn off alignment and 362130f712c9SDave Chinner * try again. 362230f712c9SDave Chinner */ 362330f712c9SDave Chinner args.type = atype; 362430f712c9SDave Chinner args.fsbno = ap->blkno; 362530f712c9SDave Chinner args.alignment = 0; 362630f712c9SDave Chinner if ((error = xfs_alloc_vextent(&args))) 362730f712c9SDave Chinner return error; 362830f712c9SDave Chinner } 362930f712c9SDave Chinner if (args.fsbno == NULLFSBLOCK && nullfb && 363030f712c9SDave Chinner args.minlen > ap->minlen) { 363130f712c9SDave Chinner args.minlen = ap->minlen; 363230f712c9SDave Chinner args.type = XFS_ALLOCTYPE_START_BNO; 363330f712c9SDave Chinner args.fsbno = ap->blkno; 363430f712c9SDave Chinner if ((error = xfs_alloc_vextent(&args))) 363530f712c9SDave Chinner return error; 363630f712c9SDave Chinner } 363730f712c9SDave Chinner if (args.fsbno == NULLFSBLOCK && nullfb) { 363830f712c9SDave Chinner args.fsbno = 0; 363930f712c9SDave Chinner args.type = XFS_ALLOCTYPE_FIRST_AG; 364030f712c9SDave Chinner args.total = ap->minlen; 364130f712c9SDave Chinner if ((error = xfs_alloc_vextent(&args))) 364230f712c9SDave Chinner return error; 36432c3234d1SDarrick J. Wong ap->dfops->dop_low = true; 364430f712c9SDave Chinner } 364530f712c9SDave Chinner if (args.fsbno != NULLFSBLOCK) { 364630f712c9SDave Chinner /* 364730f712c9SDave Chinner * check the allocation happened at the same or higher AG than 364830f712c9SDave Chinner * the first block that was allocated. 364930f712c9SDave Chinner */ 365030f712c9SDave Chinner ASSERT(*ap->firstblock == NULLFSBLOCK || 3651410d17f6SChristoph Hellwig XFS_FSB_TO_AGNO(mp, *ap->firstblock) <= 3652410d17f6SChristoph Hellwig XFS_FSB_TO_AGNO(mp, args.fsbno)); 365330f712c9SDave Chinner 365430f712c9SDave Chinner ap->blkno = args.fsbno; 365530f712c9SDave Chinner if (*ap->firstblock == NULLFSBLOCK) 365630f712c9SDave Chinner *ap->firstblock = args.fsbno; 3657410d17f6SChristoph Hellwig ASSERT(nullfb || fb_agno <= args.agno); 365830f712c9SDave Chinner ap->length = args.len; 365960b4984fSDarrick J. Wong if (!(ap->flags & XFS_BMAPI_COWFORK)) 366030f712c9SDave Chinner ap->ip->i_d.di_nblocks += args.len; 366130f712c9SDave Chinner xfs_trans_log_inode(ap->tp, ap->ip, XFS_ILOG_CORE); 366230f712c9SDave Chinner if (ap->wasdel) 366330f712c9SDave Chinner ap->ip->i_delayed_blks -= args.len; 366430f712c9SDave Chinner /* 366530f712c9SDave Chinner * Adjust the disk quota also. This was reserved 366630f712c9SDave Chinner * earlier. 366730f712c9SDave Chinner */ 366830f712c9SDave Chinner xfs_trans_mod_dquot_byino(ap->tp, ap->ip, 366930f712c9SDave Chinner ap->wasdel ? XFS_TRANS_DQ_DELBCOUNT : 367030f712c9SDave Chinner XFS_TRANS_DQ_BCOUNT, 367130f712c9SDave Chinner (long) args.len); 367230f712c9SDave Chinner } else { 367330f712c9SDave Chinner ap->blkno = NULLFSBLOCK; 367430f712c9SDave Chinner ap->length = 0; 367530f712c9SDave Chinner } 367630f712c9SDave Chinner return 0; 367730f712c9SDave Chinner } 367830f712c9SDave Chinner 367930f712c9SDave Chinner /* 368030f712c9SDave Chinner * xfs_bmap_alloc is called by xfs_bmapi to allocate an extent for a file. 368130f712c9SDave Chinner * It figures out where to ask the underlying allocator to put the new extent. 368230f712c9SDave Chinner */ 368330f712c9SDave Chinner STATIC int 368430f712c9SDave Chinner xfs_bmap_alloc( 368530f712c9SDave Chinner struct xfs_bmalloca *ap) /* bmap alloc argument struct */ 368630f712c9SDave Chinner { 3687292378edSDave Chinner if (XFS_IS_REALTIME_INODE(ap->ip) && 3688292378edSDave Chinner xfs_alloc_is_userdata(ap->datatype)) 368930f712c9SDave Chinner return xfs_bmap_rtalloc(ap); 369030f712c9SDave Chinner return xfs_bmap_btalloc(ap); 369130f712c9SDave Chinner } 369230f712c9SDave Chinner 36930a0af28cSDarrick J. Wong /* Trim extent to fit a logical block range. */ 36940a0af28cSDarrick J. Wong void 36950a0af28cSDarrick J. Wong xfs_trim_extent( 36960a0af28cSDarrick J. Wong struct xfs_bmbt_irec *irec, 36970a0af28cSDarrick J. Wong xfs_fileoff_t bno, 36980a0af28cSDarrick J. Wong xfs_filblks_t len) 36990a0af28cSDarrick J. Wong { 37000a0af28cSDarrick J. Wong xfs_fileoff_t distance; 37010a0af28cSDarrick J. Wong xfs_fileoff_t end = bno + len; 37020a0af28cSDarrick J. Wong 37030a0af28cSDarrick J. Wong if (irec->br_startoff + irec->br_blockcount <= bno || 37040a0af28cSDarrick J. Wong irec->br_startoff >= end) { 37050a0af28cSDarrick J. Wong irec->br_blockcount = 0; 37060a0af28cSDarrick J. Wong return; 37070a0af28cSDarrick J. Wong } 37080a0af28cSDarrick J. Wong 37090a0af28cSDarrick J. Wong if (irec->br_startoff < bno) { 37100a0af28cSDarrick J. Wong distance = bno - irec->br_startoff; 37110a0af28cSDarrick J. Wong if (isnullstartblock(irec->br_startblock)) 37120a0af28cSDarrick J. Wong irec->br_startblock = DELAYSTARTBLOCK; 37130a0af28cSDarrick J. Wong if (irec->br_startblock != DELAYSTARTBLOCK && 37140a0af28cSDarrick J. Wong irec->br_startblock != HOLESTARTBLOCK) 37150a0af28cSDarrick J. Wong irec->br_startblock += distance; 37160a0af28cSDarrick J. Wong irec->br_startoff += distance; 37170a0af28cSDarrick J. Wong irec->br_blockcount -= distance; 37180a0af28cSDarrick J. Wong } 37190a0af28cSDarrick J. Wong 37200a0af28cSDarrick J. Wong if (end < irec->br_startoff + irec->br_blockcount) { 37210a0af28cSDarrick J. Wong distance = irec->br_startoff + irec->br_blockcount - end; 37220a0af28cSDarrick J. Wong irec->br_blockcount -= distance; 37230a0af28cSDarrick J. Wong } 37240a0af28cSDarrick J. Wong } 37250a0af28cSDarrick J. Wong 372640214d12SBrian Foster /* trim extent to within eof */ 372740214d12SBrian Foster void 372840214d12SBrian Foster xfs_trim_extent_eof( 372940214d12SBrian Foster struct xfs_bmbt_irec *irec, 373040214d12SBrian Foster struct xfs_inode *ip) 373140214d12SBrian Foster 373240214d12SBrian Foster { 373340214d12SBrian Foster xfs_trim_extent(irec, 0, XFS_B_TO_FSB(ip->i_mount, 373440214d12SBrian Foster i_size_read(VFS_I(ip)))); 373540214d12SBrian Foster } 373640214d12SBrian Foster 373730f712c9SDave Chinner /* 373830f712c9SDave Chinner * Trim the returned map to the required bounds 373930f712c9SDave Chinner */ 374030f712c9SDave Chinner STATIC void 374130f712c9SDave Chinner xfs_bmapi_trim_map( 374230f712c9SDave Chinner struct xfs_bmbt_irec *mval, 374330f712c9SDave Chinner struct xfs_bmbt_irec *got, 374430f712c9SDave Chinner xfs_fileoff_t *bno, 374530f712c9SDave Chinner xfs_filblks_t len, 374630f712c9SDave Chinner xfs_fileoff_t obno, 374730f712c9SDave Chinner xfs_fileoff_t end, 374830f712c9SDave Chinner int n, 374930f712c9SDave Chinner int flags) 375030f712c9SDave Chinner { 375130f712c9SDave Chinner if ((flags & XFS_BMAPI_ENTIRE) || 375230f712c9SDave Chinner got->br_startoff + got->br_blockcount <= obno) { 375330f712c9SDave Chinner *mval = *got; 375430f712c9SDave Chinner if (isnullstartblock(got->br_startblock)) 375530f712c9SDave Chinner mval->br_startblock = DELAYSTARTBLOCK; 375630f712c9SDave Chinner return; 375730f712c9SDave Chinner } 375830f712c9SDave Chinner 375930f712c9SDave Chinner if (obno > *bno) 376030f712c9SDave Chinner *bno = obno; 376130f712c9SDave Chinner ASSERT((*bno >= obno) || (n == 0)); 376230f712c9SDave Chinner ASSERT(*bno < end); 376330f712c9SDave Chinner mval->br_startoff = *bno; 376430f712c9SDave Chinner if (isnullstartblock(got->br_startblock)) 376530f712c9SDave Chinner mval->br_startblock = DELAYSTARTBLOCK; 376630f712c9SDave Chinner else 376730f712c9SDave Chinner mval->br_startblock = got->br_startblock + 376830f712c9SDave Chinner (*bno - got->br_startoff); 376930f712c9SDave Chinner /* 377030f712c9SDave Chinner * Return the minimum of what we got and what we asked for for 377130f712c9SDave Chinner * the length. We can use the len variable here because it is 377230f712c9SDave Chinner * modified below and we could have been there before coming 377330f712c9SDave Chinner * here if the first part of the allocation didn't overlap what 377430f712c9SDave Chinner * was asked for. 377530f712c9SDave Chinner */ 377630f712c9SDave Chinner mval->br_blockcount = XFS_FILBLKS_MIN(end - *bno, 377730f712c9SDave Chinner got->br_blockcount - (*bno - got->br_startoff)); 377830f712c9SDave Chinner mval->br_state = got->br_state; 377930f712c9SDave Chinner ASSERT(mval->br_blockcount <= len); 378030f712c9SDave Chinner return; 378130f712c9SDave Chinner } 378230f712c9SDave Chinner 378330f712c9SDave Chinner /* 378430f712c9SDave Chinner * Update and validate the extent map to return 378530f712c9SDave Chinner */ 378630f712c9SDave Chinner STATIC void 378730f712c9SDave Chinner xfs_bmapi_update_map( 378830f712c9SDave Chinner struct xfs_bmbt_irec **map, 378930f712c9SDave Chinner xfs_fileoff_t *bno, 379030f712c9SDave Chinner xfs_filblks_t *len, 379130f712c9SDave Chinner xfs_fileoff_t obno, 379230f712c9SDave Chinner xfs_fileoff_t end, 379330f712c9SDave Chinner int *n, 379430f712c9SDave Chinner int flags) 379530f712c9SDave Chinner { 379630f712c9SDave Chinner xfs_bmbt_irec_t *mval = *map; 379730f712c9SDave Chinner 379830f712c9SDave Chinner ASSERT((flags & XFS_BMAPI_ENTIRE) || 379930f712c9SDave Chinner ((mval->br_startoff + mval->br_blockcount) <= end)); 380030f712c9SDave Chinner ASSERT((flags & XFS_BMAPI_ENTIRE) || (mval->br_blockcount <= *len) || 380130f712c9SDave Chinner (mval->br_startoff < obno)); 380230f712c9SDave Chinner 380330f712c9SDave Chinner *bno = mval->br_startoff + mval->br_blockcount; 380430f712c9SDave Chinner *len = end - *bno; 380530f712c9SDave Chinner if (*n > 0 && mval->br_startoff == mval[-1].br_startoff) { 380630f712c9SDave Chinner /* update previous map with new information */ 380730f712c9SDave Chinner ASSERT(mval->br_startblock == mval[-1].br_startblock); 380830f712c9SDave Chinner ASSERT(mval->br_blockcount > mval[-1].br_blockcount); 380930f712c9SDave Chinner ASSERT(mval->br_state == mval[-1].br_state); 381030f712c9SDave Chinner mval[-1].br_blockcount = mval->br_blockcount; 381130f712c9SDave Chinner mval[-1].br_state = mval->br_state; 381230f712c9SDave Chinner } else if (*n > 0 && mval->br_startblock != DELAYSTARTBLOCK && 381330f712c9SDave Chinner mval[-1].br_startblock != DELAYSTARTBLOCK && 381430f712c9SDave Chinner mval[-1].br_startblock != HOLESTARTBLOCK && 381530f712c9SDave Chinner mval->br_startblock == mval[-1].br_startblock + 381630f712c9SDave Chinner mval[-1].br_blockcount && 381730f712c9SDave Chinner ((flags & XFS_BMAPI_IGSTATE) || 381830f712c9SDave Chinner mval[-1].br_state == mval->br_state)) { 381930f712c9SDave Chinner ASSERT(mval->br_startoff == 382030f712c9SDave Chinner mval[-1].br_startoff + mval[-1].br_blockcount); 382130f712c9SDave Chinner mval[-1].br_blockcount += mval->br_blockcount; 382230f712c9SDave Chinner } else if (*n > 0 && 382330f712c9SDave Chinner mval->br_startblock == DELAYSTARTBLOCK && 382430f712c9SDave Chinner mval[-1].br_startblock == DELAYSTARTBLOCK && 382530f712c9SDave Chinner mval->br_startoff == 382630f712c9SDave Chinner mval[-1].br_startoff + mval[-1].br_blockcount) { 382730f712c9SDave Chinner mval[-1].br_blockcount += mval->br_blockcount; 382830f712c9SDave Chinner mval[-1].br_state = mval->br_state; 382930f712c9SDave Chinner } else if (!((*n == 0) && 383030f712c9SDave Chinner ((mval->br_startoff + mval->br_blockcount) <= 383130f712c9SDave Chinner obno))) { 383230f712c9SDave Chinner mval++; 383330f712c9SDave Chinner (*n)++; 383430f712c9SDave Chinner } 383530f712c9SDave Chinner *map = mval; 383630f712c9SDave Chinner } 383730f712c9SDave Chinner 383830f712c9SDave Chinner /* 383930f712c9SDave Chinner * Map file blocks to filesystem blocks without allocation. 384030f712c9SDave Chinner */ 384130f712c9SDave Chinner int 384230f712c9SDave Chinner xfs_bmapi_read( 384330f712c9SDave Chinner struct xfs_inode *ip, 384430f712c9SDave Chinner xfs_fileoff_t bno, 384530f712c9SDave Chinner xfs_filblks_t len, 384630f712c9SDave Chinner struct xfs_bmbt_irec *mval, 384730f712c9SDave Chinner int *nmap, 384830f712c9SDave Chinner int flags) 384930f712c9SDave Chinner { 385030f712c9SDave Chinner struct xfs_mount *mp = ip->i_mount; 385130f712c9SDave Chinner struct xfs_ifork *ifp; 385230f712c9SDave Chinner struct xfs_bmbt_irec got; 385330f712c9SDave Chinner xfs_fileoff_t obno; 385430f712c9SDave Chinner xfs_fileoff_t end; 3855334f3423SChristoph Hellwig xfs_extnum_t idx; 385630f712c9SDave Chinner int error; 3857334f3423SChristoph Hellwig bool eof = false; 385830f712c9SDave Chinner int n = 0; 38593993baebSDarrick J. Wong int whichfork = xfs_bmapi_whichfork(flags); 386030f712c9SDave Chinner 386130f712c9SDave Chinner ASSERT(*nmap >= 1); 386230f712c9SDave Chinner ASSERT(!(flags & ~(XFS_BMAPI_ATTRFORK|XFS_BMAPI_ENTIRE| 38633993baebSDarrick J. Wong XFS_BMAPI_IGSTATE|XFS_BMAPI_COWFORK))); 386430f712c9SDave Chinner ASSERT(xfs_isilocked(ip, XFS_ILOCK_SHARED|XFS_ILOCK_EXCL)); 386530f712c9SDave Chinner 386630f712c9SDave Chinner if (unlikely(XFS_TEST_ERROR( 386730f712c9SDave Chinner (XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS && 386830f712c9SDave Chinner XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE), 38699e24cfd0SDarrick J. Wong mp, XFS_ERRTAG_BMAPIFORMAT))) { 387030f712c9SDave Chinner XFS_ERROR_REPORT("xfs_bmapi_read", XFS_ERRLEVEL_LOW, mp); 38712451337dSDave Chinner return -EFSCORRUPTED; 387230f712c9SDave Chinner } 387330f712c9SDave Chinner 387430f712c9SDave Chinner if (XFS_FORCED_SHUTDOWN(mp)) 38752451337dSDave Chinner return -EIO; 387630f712c9SDave Chinner 3877ff6d6af2SBill O'Donnell XFS_STATS_INC(mp, xs_blk_mapr); 387830f712c9SDave Chinner 387930f712c9SDave Chinner ifp = XFS_IFORK_PTR(ip, whichfork); 388030f712c9SDave Chinner 38813993baebSDarrick J. Wong /* No CoW fork? Return a hole. */ 38823993baebSDarrick J. Wong if (whichfork == XFS_COW_FORK && !ifp) { 38833993baebSDarrick J. Wong mval->br_startoff = bno; 38843993baebSDarrick J. Wong mval->br_startblock = HOLESTARTBLOCK; 38853993baebSDarrick J. Wong mval->br_blockcount = len; 38863993baebSDarrick J. Wong mval->br_state = XFS_EXT_NORM; 38873993baebSDarrick J. Wong *nmap = 1; 38883993baebSDarrick J. Wong return 0; 38893993baebSDarrick J. Wong } 38903993baebSDarrick J. Wong 389130f712c9SDave Chinner if (!(ifp->if_flags & XFS_IFEXTENTS)) { 389230f712c9SDave Chinner error = xfs_iread_extents(NULL, ip, whichfork); 389330f712c9SDave Chinner if (error) 389430f712c9SDave Chinner return error; 389530f712c9SDave Chinner } 389630f712c9SDave Chinner 3897334f3423SChristoph Hellwig if (!xfs_iext_lookup_extent(ip, ifp, bno, &idx, &got)) 3898334f3423SChristoph Hellwig eof = true; 389930f712c9SDave Chinner end = bno + len; 390030f712c9SDave Chinner obno = bno; 390130f712c9SDave Chinner 390230f712c9SDave Chinner while (bno < end && n < *nmap) { 390330f712c9SDave Chinner /* Reading past eof, act as though there's a hole up to end. */ 390430f712c9SDave Chinner if (eof) 390530f712c9SDave Chinner got.br_startoff = end; 390630f712c9SDave Chinner if (got.br_startoff > bno) { 390730f712c9SDave Chinner /* Reading in a hole. */ 390830f712c9SDave Chinner mval->br_startoff = bno; 390930f712c9SDave Chinner mval->br_startblock = HOLESTARTBLOCK; 391030f712c9SDave Chinner mval->br_blockcount = 391130f712c9SDave Chinner XFS_FILBLKS_MIN(len, got.br_startoff - bno); 391230f712c9SDave Chinner mval->br_state = XFS_EXT_NORM; 391330f712c9SDave Chinner bno += mval->br_blockcount; 391430f712c9SDave Chinner len -= mval->br_blockcount; 391530f712c9SDave Chinner mval++; 391630f712c9SDave Chinner n++; 391730f712c9SDave Chinner continue; 391830f712c9SDave Chinner } 391930f712c9SDave Chinner 392030f712c9SDave Chinner /* set up the extent map to return. */ 392130f712c9SDave Chinner xfs_bmapi_trim_map(mval, &got, &bno, len, obno, end, n, flags); 392230f712c9SDave Chinner xfs_bmapi_update_map(&mval, &bno, &len, obno, end, &n, flags); 392330f712c9SDave Chinner 392430f712c9SDave Chinner /* If we're done, stop now. */ 392530f712c9SDave Chinner if (bno >= end || n >= *nmap) 392630f712c9SDave Chinner break; 392730f712c9SDave Chinner 392830f712c9SDave Chinner /* Else go on to the next record. */ 3929334f3423SChristoph Hellwig if (!xfs_iext_get_extent(ifp, ++idx, &got)) 3930334f3423SChristoph Hellwig eof = true; 393130f712c9SDave Chinner } 393230f712c9SDave Chinner *nmap = n; 393330f712c9SDave Chinner return 0; 393430f712c9SDave Chinner } 393530f712c9SDave Chinner 3936f65e6fadSBrian Foster /* 3937f65e6fadSBrian Foster * Add a delayed allocation extent to an inode. Blocks are reserved from the 3938f65e6fadSBrian Foster * global pool and the extent inserted into the inode in-core extent tree. 3939f65e6fadSBrian Foster * 3940f65e6fadSBrian Foster * On entry, got refers to the first extent beyond the offset of the extent to 3941f65e6fadSBrian Foster * allocate or eof is specified if no such extent exists. On return, got refers 3942f65e6fadSBrian Foster * to the extent record that was inserted to the inode fork. 3943f65e6fadSBrian Foster * 3944f65e6fadSBrian Foster * Note that the allocated extent may have been merged with contiguous extents 3945f65e6fadSBrian Foster * during insertion into the inode fork. Thus, got does not reflect the current 3946f65e6fadSBrian Foster * state of the inode fork on return. If necessary, the caller can use lastx to 3947f65e6fadSBrian Foster * look up the updated record in the inode fork. 3948f65e6fadSBrian Foster */ 394951446f5bSChristoph Hellwig int 395030f712c9SDave Chinner xfs_bmapi_reserve_delalloc( 395130f712c9SDave Chinner struct xfs_inode *ip, 3952be51f811SDarrick J. Wong int whichfork, 3953974ae922SBrian Foster xfs_fileoff_t off, 395430f712c9SDave Chinner xfs_filblks_t len, 3955974ae922SBrian Foster xfs_filblks_t prealloc, 395630f712c9SDave Chinner struct xfs_bmbt_irec *got, 395730f712c9SDave Chinner xfs_extnum_t *lastx, 395830f712c9SDave Chinner int eof) 395930f712c9SDave Chinner { 396030f712c9SDave Chinner struct xfs_mount *mp = ip->i_mount; 3961be51f811SDarrick J. Wong struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, whichfork); 396230f712c9SDave Chinner xfs_extlen_t alen; 396330f712c9SDave Chinner xfs_extlen_t indlen; 396430f712c9SDave Chinner char rt = XFS_IS_REALTIME_INODE(ip); 396530f712c9SDave Chinner xfs_extlen_t extsz; 396630f712c9SDave Chinner int error; 3967974ae922SBrian Foster xfs_fileoff_t aoff = off; 396830f712c9SDave Chinner 3969974ae922SBrian Foster /* 3970974ae922SBrian Foster * Cap the alloc length. Keep track of prealloc so we know whether to 3971974ae922SBrian Foster * tag the inode before we return. 3972974ae922SBrian Foster */ 3973974ae922SBrian Foster alen = XFS_FILBLKS_MIN(len + prealloc, MAXEXTLEN); 397430f712c9SDave Chinner if (!eof) 397530f712c9SDave Chinner alen = XFS_FILBLKS_MIN(alen, got->br_startoff - aoff); 3976974ae922SBrian Foster if (prealloc && alen >= len) 3977974ae922SBrian Foster prealloc = alen - len; 397830f712c9SDave Chinner 397930f712c9SDave Chinner /* Figure out the extent size, adjust alen */ 3980f7ca3522SDarrick J. Wong if (whichfork == XFS_COW_FORK) 3981f7ca3522SDarrick J. Wong extsz = xfs_get_cowextsz_hint(ip); 3982f7ca3522SDarrick J. Wong else 398330f712c9SDave Chinner extsz = xfs_get_extsz_hint(ip); 398430f712c9SDave Chinner if (extsz) { 398565c5f419SChristoph Hellwig struct xfs_bmbt_irec prev; 398665c5f419SChristoph Hellwig 398765c5f419SChristoph Hellwig if (!xfs_iext_get_extent(ifp, *lastx - 1, &prev)) 398865c5f419SChristoph Hellwig prev.br_startoff = NULLFILEOFF; 398965c5f419SChristoph Hellwig 399065c5f419SChristoph Hellwig error = xfs_bmap_extsize_align(mp, got, &prev, extsz, rt, eof, 399130f712c9SDave Chinner 1, 0, &aoff, &alen); 399230f712c9SDave Chinner ASSERT(!error); 399330f712c9SDave Chinner } 399430f712c9SDave Chinner 399530f712c9SDave Chinner if (rt) 399630f712c9SDave Chinner extsz = alen / mp->m_sb.sb_rextsize; 399730f712c9SDave Chinner 399830f712c9SDave Chinner /* 399930f712c9SDave Chinner * Make a transaction-less quota reservation for delayed allocation 400030f712c9SDave Chinner * blocks. This number gets adjusted later. We return if we haven't 400130f712c9SDave Chinner * allocated blocks already inside this loop. 400230f712c9SDave Chinner */ 400330f712c9SDave Chinner error = xfs_trans_reserve_quota_nblks(NULL, ip, (long)alen, 0, 400430f712c9SDave Chinner rt ? XFS_QMOPT_RES_RTBLKS : XFS_QMOPT_RES_REGBLKS); 400530f712c9SDave Chinner if (error) 400630f712c9SDave Chinner return error; 400730f712c9SDave Chinner 400830f712c9SDave Chinner /* 400930f712c9SDave Chinner * Split changing sb for alen and indlen since they could be coming 401030f712c9SDave Chinner * from different places. 401130f712c9SDave Chinner */ 401230f712c9SDave Chinner indlen = (xfs_extlen_t)xfs_bmap_worst_indlen(ip, alen); 401330f712c9SDave Chinner ASSERT(indlen > 0); 401430f712c9SDave Chinner 401530f712c9SDave Chinner if (rt) { 4016bab98bbeSDave Chinner error = xfs_mod_frextents(mp, -((int64_t)extsz)); 401730f712c9SDave Chinner } else { 40180d485adaSDave Chinner error = xfs_mod_fdblocks(mp, -((int64_t)alen), false); 401930f712c9SDave Chinner } 402030f712c9SDave Chinner 402130f712c9SDave Chinner if (error) 402230f712c9SDave Chinner goto out_unreserve_quota; 402330f712c9SDave Chinner 40240d485adaSDave Chinner error = xfs_mod_fdblocks(mp, -((int64_t)indlen), false); 402530f712c9SDave Chinner if (error) 402630f712c9SDave Chinner goto out_unreserve_blocks; 402730f712c9SDave Chinner 402830f712c9SDave Chinner 402930f712c9SDave Chinner ip->i_delayed_blks += alen; 403030f712c9SDave Chinner 403130f712c9SDave Chinner got->br_startoff = aoff; 403230f712c9SDave Chinner got->br_startblock = nullstartblock(indlen); 403330f712c9SDave Chinner got->br_blockcount = alen; 403430f712c9SDave Chinner got->br_state = XFS_EXT_NORM; 403530f712c9SDave Chinner 4036f65e6fadSBrian Foster xfs_bmap_add_extent_hole_delay(ip, whichfork, lastx, got); 403730f712c9SDave Chinner 4038974ae922SBrian Foster /* 4039974ae922SBrian Foster * Tag the inode if blocks were preallocated. Note that COW fork 4040974ae922SBrian Foster * preallocation can occur at the start or end of the extent, even when 4041974ae922SBrian Foster * prealloc == 0, so we must also check the aligned offset and length. 4042974ae922SBrian Foster */ 4043974ae922SBrian Foster if (whichfork == XFS_DATA_FORK && prealloc) 4044974ae922SBrian Foster xfs_inode_set_eofblocks_tag(ip); 4045974ae922SBrian Foster if (whichfork == XFS_COW_FORK && (prealloc || aoff < off || alen > len)) 4046974ae922SBrian Foster xfs_inode_set_cowblocks_tag(ip); 4047974ae922SBrian Foster 404830f712c9SDave Chinner return 0; 404930f712c9SDave Chinner 405030f712c9SDave Chinner out_unreserve_blocks: 405130f712c9SDave Chinner if (rt) 4052bab98bbeSDave Chinner xfs_mod_frextents(mp, extsz); 405330f712c9SDave Chinner else 40540d485adaSDave Chinner xfs_mod_fdblocks(mp, alen, false); 405530f712c9SDave Chinner out_unreserve_quota: 405630f712c9SDave Chinner if (XFS_IS_QUOTA_ON(mp)) 405730f712c9SDave Chinner xfs_trans_unreserve_quota_nblks(NULL, ip, (long)alen, 0, rt ? 405830f712c9SDave Chinner XFS_QMOPT_RES_RTBLKS : XFS_QMOPT_RES_REGBLKS); 405930f712c9SDave Chinner return error; 406030f712c9SDave Chinner } 406130f712c9SDave Chinner 40627f8a058fSDave Chinner static int 40637f8a058fSDave Chinner xfs_bmapi_allocate( 406430f712c9SDave Chinner struct xfs_bmalloca *bma) 406530f712c9SDave Chinner { 406630f712c9SDave Chinner struct xfs_mount *mp = bma->ip->i_mount; 406760b4984fSDarrick J. Wong int whichfork = xfs_bmapi_whichfork(bma->flags); 406830f712c9SDave Chinner struct xfs_ifork *ifp = XFS_IFORK_PTR(bma->ip, whichfork); 406930f712c9SDave Chinner int tmp_logflags = 0; 407030f712c9SDave Chinner int error; 407130f712c9SDave Chinner 407230f712c9SDave Chinner ASSERT(bma->length > 0); 407330f712c9SDave Chinner 407430f712c9SDave Chinner /* 407530f712c9SDave Chinner * For the wasdelay case, we could also just allocate the stuff asked 407630f712c9SDave Chinner * for in this bmap call but that wouldn't be as good. 407730f712c9SDave Chinner */ 407830f712c9SDave Chinner if (bma->wasdel) { 407930f712c9SDave Chinner bma->length = (xfs_extlen_t)bma->got.br_blockcount; 408030f712c9SDave Chinner bma->offset = bma->got.br_startoff; 4081e3f0f756SChristoph Hellwig if (bma->idx) 4082e3f0f756SChristoph Hellwig xfs_iext_get_extent(ifp, bma->idx - 1, &bma->prev); 408330f712c9SDave Chinner } else { 408430f712c9SDave Chinner bma->length = XFS_FILBLKS_MIN(bma->length, MAXEXTLEN); 408530f712c9SDave Chinner if (!bma->eof) 408630f712c9SDave Chinner bma->length = XFS_FILBLKS_MIN(bma->length, 408730f712c9SDave Chinner bma->got.br_startoff - bma->offset); 408830f712c9SDave Chinner } 408930f712c9SDave Chinner 409030f712c9SDave Chinner /* 4091292378edSDave Chinner * Set the data type being allocated. For the data fork, the first data 4092292378edSDave Chinner * in the file is treated differently to all other allocations. For the 4093292378edSDave Chinner * attribute fork, we only need to ensure the allocated range is not on 4094292378edSDave Chinner * the busy list. 409530f712c9SDave Chinner */ 409630f712c9SDave Chinner if (!(bma->flags & XFS_BMAPI_METADATA)) { 4097292378edSDave Chinner bma->datatype = XFS_ALLOC_NOBUSY; 4098292378edSDave Chinner if (whichfork == XFS_DATA_FORK) { 4099292378edSDave Chinner if (bma->offset == 0) 4100292378edSDave Chinner bma->datatype |= XFS_ALLOC_INITIAL_USER_DATA; 4101292378edSDave Chinner else 4102292378edSDave Chinner bma->datatype |= XFS_ALLOC_USERDATA; 4103292378edSDave Chinner } 41043fbbbea3SDave Chinner if (bma->flags & XFS_BMAPI_ZERO) 4105292378edSDave Chinner bma->datatype |= XFS_ALLOC_USERDATA_ZERO; 410630f712c9SDave Chinner } 410730f712c9SDave Chinner 410830f712c9SDave Chinner bma->minlen = (bma->flags & XFS_BMAPI_CONTIG) ? bma->length : 1; 410930f712c9SDave Chinner 411030f712c9SDave Chinner /* 411130f712c9SDave Chinner * Only want to do the alignment at the eof if it is userdata and 411230f712c9SDave Chinner * allocation length is larger than a stripe unit. 411330f712c9SDave Chinner */ 411430f712c9SDave Chinner if (mp->m_dalign && bma->length >= mp->m_dalign && 411530f712c9SDave Chinner !(bma->flags & XFS_BMAPI_METADATA) && whichfork == XFS_DATA_FORK) { 411630f712c9SDave Chinner error = xfs_bmap_isaeof(bma, whichfork); 411730f712c9SDave Chinner if (error) 411830f712c9SDave Chinner return error; 411930f712c9SDave Chinner } 412030f712c9SDave Chinner 412130f712c9SDave Chinner error = xfs_bmap_alloc(bma); 412230f712c9SDave Chinner if (error) 412330f712c9SDave Chinner return error; 412430f712c9SDave Chinner 412530f712c9SDave Chinner if (bma->cur) 412630f712c9SDave Chinner bma->cur->bc_private.b.firstblock = *bma->firstblock; 412730f712c9SDave Chinner if (bma->blkno == NULLFSBLOCK) 412830f712c9SDave Chinner return 0; 412930f712c9SDave Chinner if ((ifp->if_flags & XFS_IFBROOT) && !bma->cur) { 413030f712c9SDave Chinner bma->cur = xfs_bmbt_init_cursor(mp, bma->tp, bma->ip, whichfork); 413130f712c9SDave Chinner bma->cur->bc_private.b.firstblock = *bma->firstblock; 41322c3234d1SDarrick J. Wong bma->cur->bc_private.b.dfops = bma->dfops; 413330f712c9SDave Chinner } 413430f712c9SDave Chinner /* 413530f712c9SDave Chinner * Bump the number of extents we've allocated 413630f712c9SDave Chinner * in this call. 413730f712c9SDave Chinner */ 413830f712c9SDave Chinner bma->nallocs++; 413930f712c9SDave Chinner 414030f712c9SDave Chinner if (bma->cur) 414130f712c9SDave Chinner bma->cur->bc_private.b.flags = 414230f712c9SDave Chinner bma->wasdel ? XFS_BTCUR_BPRV_WASDEL : 0; 414330f712c9SDave Chinner 414430f712c9SDave Chinner bma->got.br_startoff = bma->offset; 414530f712c9SDave Chinner bma->got.br_startblock = bma->blkno; 414630f712c9SDave Chinner bma->got.br_blockcount = bma->length; 414730f712c9SDave Chinner bma->got.br_state = XFS_EXT_NORM; 414830f712c9SDave Chinner 414930f712c9SDave Chinner /* 415005a630d7SDarrick J. Wong * In the data fork, a wasdelay extent has been initialized, so 415105a630d7SDarrick J. Wong * shouldn't be flagged as unwritten. 415205a630d7SDarrick J. Wong * 415305a630d7SDarrick J. Wong * For the cow fork, however, we convert delalloc reservations 415405a630d7SDarrick J. Wong * (extents allocated for speculative preallocation) to 415505a630d7SDarrick J. Wong * allocated unwritten extents, and only convert the unwritten 415605a630d7SDarrick J. Wong * extents to real extents when we're about to write the data. 415730f712c9SDave Chinner */ 415805a630d7SDarrick J. Wong if ((!bma->wasdel || (bma->flags & XFS_BMAPI_COWFORK)) && 415905a630d7SDarrick J. Wong (bma->flags & XFS_BMAPI_PREALLOC) && 416030f712c9SDave Chinner xfs_sb_version_hasextflgbit(&mp->m_sb)) 416130f712c9SDave Chinner bma->got.br_state = XFS_EXT_UNWRITTEN; 416230f712c9SDave Chinner 416330f712c9SDave Chinner if (bma->wasdel) 416460b4984fSDarrick J. Wong error = xfs_bmap_add_extent_delay_real(bma, whichfork); 416530f712c9SDave Chinner else 41666d04558fSChristoph Hellwig error = xfs_bmap_add_extent_hole_real(bma->tp, bma->ip, 41676d04558fSChristoph Hellwig whichfork, &bma->idx, &bma->cur, &bma->got, 41686d04558fSChristoph Hellwig bma->firstblock, bma->dfops, &bma->logflags); 416930f712c9SDave Chinner 417030f712c9SDave Chinner bma->logflags |= tmp_logflags; 417130f712c9SDave Chinner if (error) 417230f712c9SDave Chinner return error; 417330f712c9SDave Chinner 417430f712c9SDave Chinner /* 417530f712c9SDave Chinner * Update our extent pointer, given that xfs_bmap_add_extent_delay_real 417630f712c9SDave Chinner * or xfs_bmap_add_extent_hole_real might have merged it into one of 417730f712c9SDave Chinner * the neighbouring ones. 417830f712c9SDave Chinner */ 4179e3f0f756SChristoph Hellwig xfs_iext_get_extent(ifp, bma->idx, &bma->got); 418030f712c9SDave Chinner 418130f712c9SDave Chinner ASSERT(bma->got.br_startoff <= bma->offset); 418230f712c9SDave Chinner ASSERT(bma->got.br_startoff + bma->got.br_blockcount >= 418330f712c9SDave Chinner bma->offset + bma->length); 418430f712c9SDave Chinner ASSERT(bma->got.br_state == XFS_EXT_NORM || 418530f712c9SDave Chinner bma->got.br_state == XFS_EXT_UNWRITTEN); 418630f712c9SDave Chinner return 0; 418730f712c9SDave Chinner } 418830f712c9SDave Chinner 418930f712c9SDave Chinner STATIC int 419030f712c9SDave Chinner xfs_bmapi_convert_unwritten( 419130f712c9SDave Chinner struct xfs_bmalloca *bma, 419230f712c9SDave Chinner struct xfs_bmbt_irec *mval, 419330f712c9SDave Chinner xfs_filblks_t len, 419430f712c9SDave Chinner int flags) 419530f712c9SDave Chinner { 41963993baebSDarrick J. Wong int whichfork = xfs_bmapi_whichfork(flags); 419730f712c9SDave Chinner struct xfs_ifork *ifp = XFS_IFORK_PTR(bma->ip, whichfork); 419830f712c9SDave Chinner int tmp_logflags = 0; 419930f712c9SDave Chinner int error; 420030f712c9SDave Chinner 420130f712c9SDave Chinner /* check if we need to do unwritten->real conversion */ 420230f712c9SDave Chinner if (mval->br_state == XFS_EXT_UNWRITTEN && 420330f712c9SDave Chinner (flags & XFS_BMAPI_PREALLOC)) 420430f712c9SDave Chinner return 0; 420530f712c9SDave Chinner 420630f712c9SDave Chinner /* check if we need to do real->unwritten conversion */ 420730f712c9SDave Chinner if (mval->br_state == XFS_EXT_NORM && 420830f712c9SDave Chinner (flags & (XFS_BMAPI_PREALLOC | XFS_BMAPI_CONVERT)) != 420930f712c9SDave Chinner (XFS_BMAPI_PREALLOC | XFS_BMAPI_CONVERT)) 421030f712c9SDave Chinner return 0; 421130f712c9SDave Chinner 421230f712c9SDave Chinner /* 421330f712c9SDave Chinner * Modify (by adding) the state flag, if writing. 421430f712c9SDave Chinner */ 421530f712c9SDave Chinner ASSERT(mval->br_blockcount <= len); 421630f712c9SDave Chinner if ((ifp->if_flags & XFS_IFBROOT) && !bma->cur) { 421730f712c9SDave Chinner bma->cur = xfs_bmbt_init_cursor(bma->ip->i_mount, bma->tp, 421830f712c9SDave Chinner bma->ip, whichfork); 421930f712c9SDave Chinner bma->cur->bc_private.b.firstblock = *bma->firstblock; 42202c3234d1SDarrick J. Wong bma->cur->bc_private.b.dfops = bma->dfops; 422130f712c9SDave Chinner } 422230f712c9SDave Chinner mval->br_state = (mval->br_state == XFS_EXT_UNWRITTEN) 422330f712c9SDave Chinner ? XFS_EXT_NORM : XFS_EXT_UNWRITTEN; 422430f712c9SDave Chinner 42253fbbbea3SDave Chinner /* 42263fbbbea3SDave Chinner * Before insertion into the bmbt, zero the range being converted 42273fbbbea3SDave Chinner * if required. 42283fbbbea3SDave Chinner */ 42293fbbbea3SDave Chinner if (flags & XFS_BMAPI_ZERO) { 42303fbbbea3SDave Chinner error = xfs_zero_extent(bma->ip, mval->br_startblock, 42313fbbbea3SDave Chinner mval->br_blockcount); 42323fbbbea3SDave Chinner if (error) 42333fbbbea3SDave Chinner return error; 42343fbbbea3SDave Chinner } 42353fbbbea3SDave Chinner 423605a630d7SDarrick J. Wong error = xfs_bmap_add_extent_unwritten_real(bma->tp, bma->ip, whichfork, 423705a630d7SDarrick J. Wong &bma->idx, &bma->cur, mval, bma->firstblock, bma->dfops, 423830f712c9SDave Chinner &tmp_logflags); 42392e588a46SBrian Foster /* 42402e588a46SBrian Foster * Log the inode core unconditionally in the unwritten extent conversion 42412e588a46SBrian Foster * path because the conversion might not have done so (e.g., if the 42422e588a46SBrian Foster * extent count hasn't changed). We need to make sure the inode is dirty 42432e588a46SBrian Foster * in the transaction for the sake of fsync(), even if nothing has 42442e588a46SBrian Foster * changed, because fsync() will not force the log for this transaction 42452e588a46SBrian Foster * unless it sees the inode pinned. 424605a630d7SDarrick J. Wong * 424705a630d7SDarrick J. Wong * Note: If we're only converting cow fork extents, there aren't 424805a630d7SDarrick J. Wong * any on-disk updates to make, so we don't need to log anything. 42492e588a46SBrian Foster */ 425005a630d7SDarrick J. Wong if (whichfork != XFS_COW_FORK) 42512e588a46SBrian Foster bma->logflags |= tmp_logflags | XFS_ILOG_CORE; 425230f712c9SDave Chinner if (error) 425330f712c9SDave Chinner return error; 425430f712c9SDave Chinner 425530f712c9SDave Chinner /* 425630f712c9SDave Chinner * Update our extent pointer, given that 425730f712c9SDave Chinner * xfs_bmap_add_extent_unwritten_real might have merged it into one 425830f712c9SDave Chinner * of the neighbouring ones. 425930f712c9SDave Chinner */ 4260e3f0f756SChristoph Hellwig xfs_iext_get_extent(ifp, bma->idx, &bma->got); 426130f712c9SDave Chinner 426230f712c9SDave Chinner /* 426330f712c9SDave Chinner * We may have combined previously unwritten space with written space, 426430f712c9SDave Chinner * so generate another request. 426530f712c9SDave Chinner */ 426630f712c9SDave Chinner if (mval->br_blockcount < len) 42672451337dSDave Chinner return -EAGAIN; 426830f712c9SDave Chinner return 0; 426930f712c9SDave Chinner } 427030f712c9SDave Chinner 427130f712c9SDave Chinner /* 427230f712c9SDave Chinner * Map file blocks to filesystem blocks, and allocate blocks or convert the 427330f712c9SDave Chinner * extent state if necessary. Details behaviour is controlled by the flags 427430f712c9SDave Chinner * parameter. Only allocates blocks from a single allocation group, to avoid 427530f712c9SDave Chinner * locking problems. 427630f712c9SDave Chinner * 427730f712c9SDave Chinner * The returned value in "firstblock" from the first call in a transaction 427830f712c9SDave Chinner * must be remembered and presented to subsequent calls in "firstblock". 427930f712c9SDave Chinner * An upper bound for the number of blocks to be allocated is supplied to 428030f712c9SDave Chinner * the first call in "total"; if no allocation group has that many free 428130f712c9SDave Chinner * blocks then the call will fail (return NULLFSBLOCK in "firstblock"). 428230f712c9SDave Chinner */ 428330f712c9SDave Chinner int 428430f712c9SDave Chinner xfs_bmapi_write( 428530f712c9SDave Chinner struct xfs_trans *tp, /* transaction pointer */ 428630f712c9SDave Chinner struct xfs_inode *ip, /* incore inode */ 428730f712c9SDave Chinner xfs_fileoff_t bno, /* starting file offs. mapped */ 428830f712c9SDave Chinner xfs_filblks_t len, /* length to map in file */ 428930f712c9SDave Chinner int flags, /* XFS_BMAPI_... */ 429030f712c9SDave Chinner xfs_fsblock_t *firstblock, /* first allocated block 429130f712c9SDave Chinner controls a.g. for allocs */ 429230f712c9SDave Chinner xfs_extlen_t total, /* total blocks needed */ 429330f712c9SDave Chinner struct xfs_bmbt_irec *mval, /* output: map values */ 429430f712c9SDave Chinner int *nmap, /* i/o: mval size/count */ 42952c3234d1SDarrick J. Wong struct xfs_defer_ops *dfops) /* i/o: list extents to free */ 429630f712c9SDave Chinner { 429730f712c9SDave Chinner struct xfs_mount *mp = ip->i_mount; 429830f712c9SDave Chinner struct xfs_ifork *ifp; 429930f712c9SDave Chinner struct xfs_bmalloca bma = { NULL }; /* args for xfs_bmap_alloc */ 430030f712c9SDave Chinner xfs_fileoff_t end; /* end of mapped file region */ 43012d58f6efSChristoph Hellwig bool eof = false; /* after the end of extents */ 430230f712c9SDave Chinner int error; /* error return */ 430330f712c9SDave Chinner int n; /* current extent index */ 430430f712c9SDave Chinner xfs_fileoff_t obno; /* old block number (offset) */ 430530f712c9SDave Chinner int whichfork; /* data or attr fork */ 430630f712c9SDave Chinner 430730f712c9SDave Chinner #ifdef DEBUG 430830f712c9SDave Chinner xfs_fileoff_t orig_bno; /* original block number value */ 430930f712c9SDave Chinner int orig_flags; /* original flags arg value */ 431030f712c9SDave Chinner xfs_filblks_t orig_len; /* original value of len arg */ 431130f712c9SDave Chinner struct xfs_bmbt_irec *orig_mval; /* original value of mval */ 431230f712c9SDave Chinner int orig_nmap; /* original value of *nmap */ 431330f712c9SDave Chinner 431430f712c9SDave Chinner orig_bno = bno; 431530f712c9SDave Chinner orig_len = len; 431630f712c9SDave Chinner orig_flags = flags; 431730f712c9SDave Chinner orig_mval = mval; 431830f712c9SDave Chinner orig_nmap = *nmap; 431930f712c9SDave Chinner #endif 432060b4984fSDarrick J. Wong whichfork = xfs_bmapi_whichfork(flags); 432130f712c9SDave Chinner 432230f712c9SDave Chinner ASSERT(*nmap >= 1); 432330f712c9SDave Chinner ASSERT(*nmap <= XFS_BMAP_MAX_NMAP); 432430f712c9SDave Chinner ASSERT(!(flags & XFS_BMAPI_IGSTATE)); 432505a630d7SDarrick J. Wong ASSERT(tp != NULL || 432605a630d7SDarrick J. Wong (flags & (XFS_BMAPI_CONVERT | XFS_BMAPI_COWFORK)) == 432705a630d7SDarrick J. Wong (XFS_BMAPI_CONVERT | XFS_BMAPI_COWFORK)); 432830f712c9SDave Chinner ASSERT(len > 0); 432930f712c9SDave Chinner ASSERT(XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_LOCAL); 433030f712c9SDave Chinner ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL)); 43316ebd5a44SChristoph Hellwig ASSERT(!(flags & XFS_BMAPI_REMAP)); 433230f712c9SDave Chinner 43333fbbbea3SDave Chinner /* zeroing is for currently only for data extents, not metadata */ 43343fbbbea3SDave Chinner ASSERT((flags & (XFS_BMAPI_METADATA | XFS_BMAPI_ZERO)) != 43353fbbbea3SDave Chinner (XFS_BMAPI_METADATA | XFS_BMAPI_ZERO)); 43363fbbbea3SDave Chinner /* 43373fbbbea3SDave Chinner * we can allocate unwritten extents or pre-zero allocated blocks, 43383fbbbea3SDave Chinner * but it makes no sense to do both at once. This would result in 43393fbbbea3SDave Chinner * zeroing the unwritten extent twice, but it still being an 43403fbbbea3SDave Chinner * unwritten extent.... 43413fbbbea3SDave Chinner */ 43423fbbbea3SDave Chinner ASSERT((flags & (XFS_BMAPI_PREALLOC | XFS_BMAPI_ZERO)) != 43433fbbbea3SDave Chinner (XFS_BMAPI_PREALLOC | XFS_BMAPI_ZERO)); 43443fbbbea3SDave Chinner 434530f712c9SDave Chinner if (unlikely(XFS_TEST_ERROR( 434630f712c9SDave Chinner (XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS && 434730f712c9SDave Chinner XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE), 43489e24cfd0SDarrick J. Wong mp, XFS_ERRTAG_BMAPIFORMAT))) { 434930f712c9SDave Chinner XFS_ERROR_REPORT("xfs_bmapi_write", XFS_ERRLEVEL_LOW, mp); 43502451337dSDave Chinner return -EFSCORRUPTED; 435130f712c9SDave Chinner } 435230f712c9SDave Chinner 435330f712c9SDave Chinner if (XFS_FORCED_SHUTDOWN(mp)) 43542451337dSDave Chinner return -EIO; 435530f712c9SDave Chinner 435630f712c9SDave Chinner ifp = XFS_IFORK_PTR(ip, whichfork); 435730f712c9SDave Chinner 4358ff6d6af2SBill O'Donnell XFS_STATS_INC(mp, xs_blk_mapw); 435930f712c9SDave Chinner 436030f712c9SDave Chinner if (*firstblock == NULLFSBLOCK) { 436130f712c9SDave Chinner if (XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_BTREE) 436230f712c9SDave Chinner bma.minleft = be16_to_cpu(ifp->if_broot->bb_level) + 1; 436330f712c9SDave Chinner else 436430f712c9SDave Chinner bma.minleft = 1; 436530f712c9SDave Chinner } else { 436630f712c9SDave Chinner bma.minleft = 0; 436730f712c9SDave Chinner } 436830f712c9SDave Chinner 436930f712c9SDave Chinner if (!(ifp->if_flags & XFS_IFEXTENTS)) { 437030f712c9SDave Chinner error = xfs_iread_extents(tp, ip, whichfork); 437130f712c9SDave Chinner if (error) 437230f712c9SDave Chinner goto error0; 437330f712c9SDave Chinner } 437430f712c9SDave Chinner 437530f712c9SDave Chinner n = 0; 437630f712c9SDave Chinner end = bno + len; 437730f712c9SDave Chinner obno = bno; 437830f712c9SDave Chinner 43792d58f6efSChristoph Hellwig if (!xfs_iext_lookup_extent(ip, ifp, bno, &bma.idx, &bma.got)) 43802d58f6efSChristoph Hellwig eof = true; 43812d58f6efSChristoph Hellwig if (!xfs_iext_get_extent(ifp, bma.idx - 1, &bma.prev)) 43822d58f6efSChristoph Hellwig bma.prev.br_startoff = NULLFILEOFF; 438330f712c9SDave Chinner bma.tp = tp; 438430f712c9SDave Chinner bma.ip = ip; 438530f712c9SDave Chinner bma.total = total; 4386292378edSDave Chinner bma.datatype = 0; 43872c3234d1SDarrick J. Wong bma.dfops = dfops; 438830f712c9SDave Chinner bma.firstblock = firstblock; 438930f712c9SDave Chinner 439030f712c9SDave Chinner while (bno < end && n < *nmap) { 4391d2b3964aSChristoph Hellwig bool need_alloc = false, wasdelay = false; 439230f712c9SDave Chinner 4393d2b3964aSChristoph Hellwig /* in hole or beyoned EOF? */ 4394d2b3964aSChristoph Hellwig if (eof || bma.got.br_startoff > bno) { 4395d2b3964aSChristoph Hellwig if (flags & XFS_BMAPI_DELALLOC) { 4396d2b3964aSChristoph Hellwig /* 4397d2b3964aSChristoph Hellwig * For the COW fork we can reasonably get a 4398d2b3964aSChristoph Hellwig * request for converting an extent that races 4399d2b3964aSChristoph Hellwig * with other threads already having converted 4400d2b3964aSChristoph Hellwig * part of it, as there converting COW to 4401d2b3964aSChristoph Hellwig * regular blocks is not protected using the 4402d2b3964aSChristoph Hellwig * IOLOCK. 4403d2b3964aSChristoph Hellwig */ 4404d2b3964aSChristoph Hellwig ASSERT(flags & XFS_BMAPI_COWFORK); 4405d2b3964aSChristoph Hellwig if (!(flags & XFS_BMAPI_COWFORK)) { 4406d2b3964aSChristoph Hellwig error = -EIO; 4407d2b3964aSChristoph Hellwig goto error0; 4408d2b3964aSChristoph Hellwig } 4409d2b3964aSChristoph Hellwig 4410d2b3964aSChristoph Hellwig if (eof || bno >= end) 4411d2b3964aSChristoph Hellwig break; 4412d2b3964aSChristoph Hellwig } else { 4413d2b3964aSChristoph Hellwig need_alloc = true; 4414d2b3964aSChristoph Hellwig } 44156ebd5a44SChristoph Hellwig } else if (isnullstartblock(bma.got.br_startblock)) { 4416d2b3964aSChristoph Hellwig wasdelay = true; 4417d2b3964aSChristoph Hellwig } 4418f65306eaSDarrick J. Wong 4419f65306eaSDarrick J. Wong /* 442030f712c9SDave Chinner * First, deal with the hole before the allocated space 442130f712c9SDave Chinner * that we found, if any. 442230f712c9SDave Chinner */ 4423d2b3964aSChristoph Hellwig if (need_alloc || wasdelay) { 442430f712c9SDave Chinner bma.eof = eof; 442530f712c9SDave Chinner bma.conv = !!(flags & XFS_BMAPI_CONVERT); 442630f712c9SDave Chinner bma.wasdel = wasdelay; 442730f712c9SDave Chinner bma.offset = bno; 442830f712c9SDave Chinner bma.flags = flags; 442930f712c9SDave Chinner 443030f712c9SDave Chinner /* 443130f712c9SDave Chinner * There's a 32/64 bit type mismatch between the 443230f712c9SDave Chinner * allocation length request (which can be 64 bits in 443330f712c9SDave Chinner * length) and the bma length request, which is 443430f712c9SDave Chinner * xfs_extlen_t and therefore 32 bits. Hence we have to 443530f712c9SDave Chinner * check for 32-bit overflows and handle them here. 443630f712c9SDave Chinner */ 443730f712c9SDave Chinner if (len > (xfs_filblks_t)MAXEXTLEN) 443830f712c9SDave Chinner bma.length = MAXEXTLEN; 443930f712c9SDave Chinner else 444030f712c9SDave Chinner bma.length = len; 444130f712c9SDave Chinner 444230f712c9SDave Chinner ASSERT(len > 0); 444330f712c9SDave Chinner ASSERT(bma.length > 0); 444430f712c9SDave Chinner error = xfs_bmapi_allocate(&bma); 444530f712c9SDave Chinner if (error) 444630f712c9SDave Chinner goto error0; 444730f712c9SDave Chinner if (bma.blkno == NULLFSBLOCK) 444830f712c9SDave Chinner break; 4449174edb0eSDarrick J. Wong 4450174edb0eSDarrick J. Wong /* 4451174edb0eSDarrick J. Wong * If this is a CoW allocation, record the data in 4452174edb0eSDarrick J. Wong * the refcount btree for orphan recovery. 4453174edb0eSDarrick J. Wong */ 4454174edb0eSDarrick J. Wong if (whichfork == XFS_COW_FORK) { 4455174edb0eSDarrick J. Wong error = xfs_refcount_alloc_cow_extent(mp, dfops, 4456174edb0eSDarrick J. Wong bma.blkno, bma.length); 4457174edb0eSDarrick J. Wong if (error) 4458174edb0eSDarrick J. Wong goto error0; 4459174edb0eSDarrick J. Wong } 446030f712c9SDave Chinner } 446130f712c9SDave Chinner 446230f712c9SDave Chinner /* Deal with the allocated space we found. */ 446330f712c9SDave Chinner xfs_bmapi_trim_map(mval, &bma.got, &bno, len, obno, 446430f712c9SDave Chinner end, n, flags); 446530f712c9SDave Chinner 446630f712c9SDave Chinner /* Execute unwritten extent conversion if necessary */ 446730f712c9SDave Chinner error = xfs_bmapi_convert_unwritten(&bma, mval, len, flags); 44682451337dSDave Chinner if (error == -EAGAIN) 446930f712c9SDave Chinner continue; 447030f712c9SDave Chinner if (error) 447130f712c9SDave Chinner goto error0; 447230f712c9SDave Chinner 447330f712c9SDave Chinner /* update the extent map to return */ 447430f712c9SDave Chinner xfs_bmapi_update_map(&mval, &bno, &len, obno, end, &n, flags); 447530f712c9SDave Chinner 447630f712c9SDave Chinner /* 447730f712c9SDave Chinner * If we're done, stop now. Stop when we've allocated 447830f712c9SDave Chinner * XFS_BMAP_MAX_NMAP extents no matter what. Otherwise 447930f712c9SDave Chinner * the transaction may get too big. 448030f712c9SDave Chinner */ 448130f712c9SDave Chinner if (bno >= end || n >= *nmap || bma.nallocs >= *nmap) 448230f712c9SDave Chinner break; 448330f712c9SDave Chinner 448430f712c9SDave Chinner /* Else go on to the next record. */ 448530f712c9SDave Chinner bma.prev = bma.got; 44862d58f6efSChristoph Hellwig if (!xfs_iext_get_extent(ifp, ++bma.idx, &bma.got)) 44872d58f6efSChristoph Hellwig eof = true; 448830f712c9SDave Chinner } 448930f712c9SDave Chinner *nmap = n; 449030f712c9SDave Chinner 449130f712c9SDave Chinner /* 449230f712c9SDave Chinner * Transform from btree to extents, give it cur. 449330f712c9SDave Chinner */ 449430f712c9SDave Chinner if (xfs_bmap_wants_extents(ip, whichfork)) { 449530f712c9SDave Chinner int tmp_logflags = 0; 449630f712c9SDave Chinner 449730f712c9SDave Chinner ASSERT(bma.cur); 449830f712c9SDave Chinner error = xfs_bmap_btree_to_extents(tp, ip, bma.cur, 449930f712c9SDave Chinner &tmp_logflags, whichfork); 450030f712c9SDave Chinner bma.logflags |= tmp_logflags; 450130f712c9SDave Chinner if (error) 450230f712c9SDave Chinner goto error0; 450330f712c9SDave Chinner } 450430f712c9SDave Chinner 450530f712c9SDave Chinner ASSERT(XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE || 450630f712c9SDave Chinner XFS_IFORK_NEXTENTS(ip, whichfork) > 450730f712c9SDave Chinner XFS_IFORK_MAXEXT(ip, whichfork)); 450830f712c9SDave Chinner error = 0; 450930f712c9SDave Chinner error0: 451030f712c9SDave Chinner /* 451130f712c9SDave Chinner * Log everything. Do this after conversion, there's no point in 451230f712c9SDave Chinner * logging the extent records if we've converted to btree format. 451330f712c9SDave Chinner */ 451430f712c9SDave Chinner if ((bma.logflags & xfs_ilog_fext(whichfork)) && 451530f712c9SDave Chinner XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS) 451630f712c9SDave Chinner bma.logflags &= ~xfs_ilog_fext(whichfork); 451730f712c9SDave Chinner else if ((bma.logflags & xfs_ilog_fbroot(whichfork)) && 451830f712c9SDave Chinner XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE) 451930f712c9SDave Chinner bma.logflags &= ~xfs_ilog_fbroot(whichfork); 452030f712c9SDave Chinner /* 452130f712c9SDave Chinner * Log whatever the flags say, even if error. Otherwise we might miss 452230f712c9SDave Chinner * detecting a case where the data is changed, there's an error, 452330f712c9SDave Chinner * and it's not logged so we don't shutdown when we should. 452430f712c9SDave Chinner */ 452530f712c9SDave Chinner if (bma.logflags) 452630f712c9SDave Chinner xfs_trans_log_inode(tp, ip, bma.logflags); 452730f712c9SDave Chinner 452830f712c9SDave Chinner if (bma.cur) { 452930f712c9SDave Chinner if (!error) { 453030f712c9SDave Chinner ASSERT(*firstblock == NULLFSBLOCK || 4531410d17f6SChristoph Hellwig XFS_FSB_TO_AGNO(mp, *firstblock) <= 453230f712c9SDave Chinner XFS_FSB_TO_AGNO(mp, 4533410d17f6SChristoph Hellwig bma.cur->bc_private.b.firstblock)); 453430f712c9SDave Chinner *firstblock = bma.cur->bc_private.b.firstblock; 453530f712c9SDave Chinner } 453630f712c9SDave Chinner xfs_btree_del_cursor(bma.cur, 453730f712c9SDave Chinner error ? XFS_BTREE_ERROR : XFS_BTREE_NOERROR); 453830f712c9SDave Chinner } 453930f712c9SDave Chinner if (!error) 454030f712c9SDave Chinner xfs_bmap_validate_ret(orig_bno, orig_len, orig_flags, orig_mval, 454130f712c9SDave Chinner orig_nmap, *nmap); 454230f712c9SDave Chinner return error; 454330f712c9SDave Chinner } 454430f712c9SDave Chinner 45456ebd5a44SChristoph Hellwig static int 45466ebd5a44SChristoph Hellwig xfs_bmapi_remap( 45476ebd5a44SChristoph Hellwig struct xfs_trans *tp, 45486ebd5a44SChristoph Hellwig struct xfs_inode *ip, 45496ebd5a44SChristoph Hellwig xfs_fileoff_t bno, 45506ebd5a44SChristoph Hellwig xfs_filblks_t len, 45516ebd5a44SChristoph Hellwig xfs_fsblock_t startblock, 45526ebd5a44SChristoph Hellwig struct xfs_defer_ops *dfops) 45536ebd5a44SChristoph Hellwig { 45546ebd5a44SChristoph Hellwig struct xfs_mount *mp = ip->i_mount; 45556ebd5a44SChristoph Hellwig struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, XFS_DATA_FORK); 45566ebd5a44SChristoph Hellwig struct xfs_btree_cur *cur = NULL; 45576ebd5a44SChristoph Hellwig xfs_fsblock_t firstblock = NULLFSBLOCK; 45586ebd5a44SChristoph Hellwig struct xfs_bmbt_irec got; 45596ebd5a44SChristoph Hellwig xfs_extnum_t idx; 45606ebd5a44SChristoph Hellwig int logflags = 0, error; 45616ebd5a44SChristoph Hellwig 45626ebd5a44SChristoph Hellwig ASSERT(len > 0); 45636ebd5a44SChristoph Hellwig ASSERT(len <= (xfs_filblks_t)MAXEXTLEN); 45646ebd5a44SChristoph Hellwig ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL)); 45656ebd5a44SChristoph Hellwig 45666ebd5a44SChristoph Hellwig if (unlikely(XFS_TEST_ERROR( 45676ebd5a44SChristoph Hellwig (XFS_IFORK_FORMAT(ip, XFS_DATA_FORK) != XFS_DINODE_FMT_EXTENTS && 45686ebd5a44SChristoph Hellwig XFS_IFORK_FORMAT(ip, XFS_DATA_FORK) != XFS_DINODE_FMT_BTREE), 45699e24cfd0SDarrick J. Wong mp, XFS_ERRTAG_BMAPIFORMAT))) { 45706ebd5a44SChristoph Hellwig XFS_ERROR_REPORT("xfs_bmapi_remap", XFS_ERRLEVEL_LOW, mp); 45716ebd5a44SChristoph Hellwig return -EFSCORRUPTED; 45726ebd5a44SChristoph Hellwig } 45736ebd5a44SChristoph Hellwig 45746ebd5a44SChristoph Hellwig if (XFS_FORCED_SHUTDOWN(mp)) 45756ebd5a44SChristoph Hellwig return -EIO; 45766ebd5a44SChristoph Hellwig 45776ebd5a44SChristoph Hellwig if (!(ifp->if_flags & XFS_IFEXTENTS)) { 45786ebd5a44SChristoph Hellwig error = xfs_iread_extents(NULL, ip, XFS_DATA_FORK); 45796ebd5a44SChristoph Hellwig if (error) 45806ebd5a44SChristoph Hellwig return error; 45816ebd5a44SChristoph Hellwig } 45826ebd5a44SChristoph Hellwig 45836ebd5a44SChristoph Hellwig if (xfs_iext_lookup_extent(ip, ifp, bno, &idx, &got)) { 45846ebd5a44SChristoph Hellwig /* make sure we only reflink into a hole. */ 45856ebd5a44SChristoph Hellwig ASSERT(got.br_startoff > bno); 45866ebd5a44SChristoph Hellwig ASSERT(got.br_startoff - bno >= len); 45876ebd5a44SChristoph Hellwig } 45886ebd5a44SChristoph Hellwig 4589bf8eadbaSChristoph Hellwig ip->i_d.di_nblocks += len; 4590bf8eadbaSChristoph Hellwig xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE); 45916ebd5a44SChristoph Hellwig 45926ebd5a44SChristoph Hellwig if (ifp->if_flags & XFS_IFBROOT) { 45936ebd5a44SChristoph Hellwig cur = xfs_bmbt_init_cursor(mp, tp, ip, XFS_DATA_FORK); 45946ebd5a44SChristoph Hellwig cur->bc_private.b.firstblock = firstblock; 45956ebd5a44SChristoph Hellwig cur->bc_private.b.dfops = dfops; 45966ebd5a44SChristoph Hellwig cur->bc_private.b.flags = 0; 45976ebd5a44SChristoph Hellwig } 45986ebd5a44SChristoph Hellwig 45996ebd5a44SChristoph Hellwig got.br_startoff = bno; 46006ebd5a44SChristoph Hellwig got.br_startblock = startblock; 46016ebd5a44SChristoph Hellwig got.br_blockcount = len; 46026ebd5a44SChristoph Hellwig got.br_state = XFS_EXT_NORM; 46036ebd5a44SChristoph Hellwig 46046ebd5a44SChristoph Hellwig error = xfs_bmap_add_extent_hole_real(tp, ip, XFS_DATA_FORK, &idx, &cur, 46056ebd5a44SChristoph Hellwig &got, &firstblock, dfops, &logflags); 46066ebd5a44SChristoph Hellwig if (error) 46076ebd5a44SChristoph Hellwig goto error0; 46086ebd5a44SChristoph Hellwig 46096ebd5a44SChristoph Hellwig if (xfs_bmap_wants_extents(ip, XFS_DATA_FORK)) { 46106ebd5a44SChristoph Hellwig int tmp_logflags = 0; 46116ebd5a44SChristoph Hellwig 46126ebd5a44SChristoph Hellwig error = xfs_bmap_btree_to_extents(tp, ip, cur, 46136ebd5a44SChristoph Hellwig &tmp_logflags, XFS_DATA_FORK); 46146ebd5a44SChristoph Hellwig logflags |= tmp_logflags; 46156ebd5a44SChristoph Hellwig } 46166ebd5a44SChristoph Hellwig 46176ebd5a44SChristoph Hellwig error0: 46186ebd5a44SChristoph Hellwig if (ip->i_d.di_format != XFS_DINODE_FMT_EXTENTS) 46196ebd5a44SChristoph Hellwig logflags &= ~XFS_ILOG_DEXT; 46206ebd5a44SChristoph Hellwig else if (ip->i_d.di_format != XFS_DINODE_FMT_BTREE) 46216ebd5a44SChristoph Hellwig logflags &= ~XFS_ILOG_DBROOT; 46226ebd5a44SChristoph Hellwig 46236ebd5a44SChristoph Hellwig if (logflags) 46246ebd5a44SChristoph Hellwig xfs_trans_log_inode(tp, ip, logflags); 46256ebd5a44SChristoph Hellwig if (cur) { 46266ebd5a44SChristoph Hellwig xfs_btree_del_cursor(cur, 46276ebd5a44SChristoph Hellwig error ? XFS_BTREE_ERROR : XFS_BTREE_NOERROR); 46286ebd5a44SChristoph Hellwig } 46296ebd5a44SChristoph Hellwig return error; 46306ebd5a44SChristoph Hellwig } 46316ebd5a44SChristoph Hellwig 463230f712c9SDave Chinner /* 4633a9bd24acSBrian Foster * When a delalloc extent is split (e.g., due to a hole punch), the original 4634a9bd24acSBrian Foster * indlen reservation must be shared across the two new extents that are left 4635a9bd24acSBrian Foster * behind. 4636a9bd24acSBrian Foster * 4637a9bd24acSBrian Foster * Given the original reservation and the worst case indlen for the two new 4638a9bd24acSBrian Foster * extents (as calculated by xfs_bmap_worst_indlen()), split the original 4639d34999c9SBrian Foster * reservation fairly across the two new extents. If necessary, steal available 4640d34999c9SBrian Foster * blocks from a deleted extent to make up a reservation deficiency (e.g., if 4641d34999c9SBrian Foster * ores == 1). The number of stolen blocks is returned. The availability and 4642d34999c9SBrian Foster * subsequent accounting of stolen blocks is the responsibility of the caller. 4643a9bd24acSBrian Foster */ 4644d34999c9SBrian Foster static xfs_filblks_t 4645a9bd24acSBrian Foster xfs_bmap_split_indlen( 4646a9bd24acSBrian Foster xfs_filblks_t ores, /* original res. */ 4647a9bd24acSBrian Foster xfs_filblks_t *indlen1, /* ext1 worst indlen */ 4648d34999c9SBrian Foster xfs_filblks_t *indlen2, /* ext2 worst indlen */ 4649d34999c9SBrian Foster xfs_filblks_t avail) /* stealable blocks */ 4650a9bd24acSBrian Foster { 4651a9bd24acSBrian Foster xfs_filblks_t len1 = *indlen1; 4652a9bd24acSBrian Foster xfs_filblks_t len2 = *indlen2; 4653a9bd24acSBrian Foster xfs_filblks_t nres = len1 + len2; /* new total res. */ 4654d34999c9SBrian Foster xfs_filblks_t stolen = 0; 465575d65361SBrian Foster xfs_filblks_t resfactor; 4656a9bd24acSBrian Foster 4657a9bd24acSBrian Foster /* 4658d34999c9SBrian Foster * Steal as many blocks as we can to try and satisfy the worst case 4659d34999c9SBrian Foster * indlen for both new extents. 4660d34999c9SBrian Foster */ 466175d65361SBrian Foster if (ores < nres && avail) 466275d65361SBrian Foster stolen = XFS_FILBLKS_MIN(nres - ores, avail); 466375d65361SBrian Foster ores += stolen; 466475d65361SBrian Foster 466575d65361SBrian Foster /* nothing else to do if we've satisfied the new reservation */ 466675d65361SBrian Foster if (ores >= nres) 466775d65361SBrian Foster return stolen; 4668d34999c9SBrian Foster 4669d34999c9SBrian Foster /* 467075d65361SBrian Foster * We can't meet the total required reservation for the two extents. 467175d65361SBrian Foster * Calculate the percent of the overall shortage between both extents 467275d65361SBrian Foster * and apply this percentage to each of the requested indlen values. 467375d65361SBrian Foster * This distributes the shortage fairly and reduces the chances that one 467475d65361SBrian Foster * of the two extents is left with nothing when extents are repeatedly 467575d65361SBrian Foster * split. 4676a9bd24acSBrian Foster */ 467775d65361SBrian Foster resfactor = (ores * 100); 467875d65361SBrian Foster do_div(resfactor, nres); 467975d65361SBrian Foster len1 *= resfactor; 468075d65361SBrian Foster do_div(len1, 100); 468175d65361SBrian Foster len2 *= resfactor; 468275d65361SBrian Foster do_div(len2, 100); 468375d65361SBrian Foster ASSERT(len1 + len2 <= ores); 468475d65361SBrian Foster ASSERT(len1 < *indlen1 && len2 < *indlen2); 468575d65361SBrian Foster 468675d65361SBrian Foster /* 468775d65361SBrian Foster * Hand out the remainder to each extent. If one of the two reservations 468875d65361SBrian Foster * is zero, we want to make sure that one gets a block first. The loop 468975d65361SBrian Foster * below starts with len1, so hand len2 a block right off the bat if it 469075d65361SBrian Foster * is zero. 469175d65361SBrian Foster */ 469275d65361SBrian Foster ores -= (len1 + len2); 469375d65361SBrian Foster ASSERT((*indlen1 - len1) + (*indlen2 - len2) >= ores); 469475d65361SBrian Foster if (ores && !len2 && *indlen2) { 469575d65361SBrian Foster len2++; 469675d65361SBrian Foster ores--; 4697a9bd24acSBrian Foster } 469875d65361SBrian Foster while (ores) { 469975d65361SBrian Foster if (len1 < *indlen1) { 470075d65361SBrian Foster len1++; 470175d65361SBrian Foster ores--; 470275d65361SBrian Foster } 470375d65361SBrian Foster if (!ores) 4704a9bd24acSBrian Foster break; 470575d65361SBrian Foster if (len2 < *indlen2) { 470675d65361SBrian Foster len2++; 470775d65361SBrian Foster ores--; 4708a9bd24acSBrian Foster } 4709a9bd24acSBrian Foster } 4710a9bd24acSBrian Foster 4711a9bd24acSBrian Foster *indlen1 = len1; 4712a9bd24acSBrian Foster *indlen2 = len2; 4713d34999c9SBrian Foster 4714d34999c9SBrian Foster return stolen; 4715a9bd24acSBrian Foster } 4716a9bd24acSBrian Foster 4717fa5c836cSChristoph Hellwig int 4718fa5c836cSChristoph Hellwig xfs_bmap_del_extent_delay( 4719fa5c836cSChristoph Hellwig struct xfs_inode *ip, 4720fa5c836cSChristoph Hellwig int whichfork, 4721fa5c836cSChristoph Hellwig xfs_extnum_t *idx, 4722fa5c836cSChristoph Hellwig struct xfs_bmbt_irec *got, 4723fa5c836cSChristoph Hellwig struct xfs_bmbt_irec *del) 4724fa5c836cSChristoph Hellwig { 4725fa5c836cSChristoph Hellwig struct xfs_mount *mp = ip->i_mount; 4726fa5c836cSChristoph Hellwig struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, whichfork); 4727fa5c836cSChristoph Hellwig struct xfs_bmbt_irec new; 4728fa5c836cSChristoph Hellwig int64_t da_old, da_new, da_diff = 0; 4729fa5c836cSChristoph Hellwig xfs_fileoff_t del_endoff, got_endoff; 4730fa5c836cSChristoph Hellwig xfs_filblks_t got_indlen, new_indlen, stolen; 4731060ea65bSChristoph Hellwig int state = xfs_bmap_fork_to_state(whichfork); 4732060ea65bSChristoph Hellwig int error = 0; 4733fa5c836cSChristoph Hellwig bool isrt; 4734fa5c836cSChristoph Hellwig 4735fa5c836cSChristoph Hellwig XFS_STATS_INC(mp, xs_del_exlist); 4736fa5c836cSChristoph Hellwig 4737fa5c836cSChristoph Hellwig isrt = (whichfork == XFS_DATA_FORK) && XFS_IS_REALTIME_INODE(ip); 4738fa5c836cSChristoph Hellwig del_endoff = del->br_startoff + del->br_blockcount; 4739fa5c836cSChristoph Hellwig got_endoff = got->br_startoff + got->br_blockcount; 4740fa5c836cSChristoph Hellwig da_old = startblockval(got->br_startblock); 4741fa5c836cSChristoph Hellwig da_new = 0; 4742fa5c836cSChristoph Hellwig 4743fa5c836cSChristoph Hellwig ASSERT(*idx >= 0); 47445d829300SEric Sandeen ASSERT(*idx <= xfs_iext_count(ifp)); 4745fa5c836cSChristoph Hellwig ASSERT(del->br_blockcount > 0); 4746fa5c836cSChristoph Hellwig ASSERT(got->br_startoff <= del->br_startoff); 4747fa5c836cSChristoph Hellwig ASSERT(got_endoff >= del_endoff); 4748fa5c836cSChristoph Hellwig 4749fa5c836cSChristoph Hellwig if (isrt) { 47504f1adf33SEric Sandeen uint64_t rtexts = XFS_FSB_TO_B(mp, del->br_blockcount); 4751fa5c836cSChristoph Hellwig 4752fa5c836cSChristoph Hellwig do_div(rtexts, mp->m_sb.sb_rextsize); 4753fa5c836cSChristoph Hellwig xfs_mod_frextents(mp, rtexts); 4754fa5c836cSChristoph Hellwig } 4755fa5c836cSChristoph Hellwig 4756fa5c836cSChristoph Hellwig /* 4757fa5c836cSChristoph Hellwig * Update the inode delalloc counter now and wait to update the 4758fa5c836cSChristoph Hellwig * sb counters as we might have to borrow some blocks for the 4759fa5c836cSChristoph Hellwig * indirect block accounting. 4760fa5c836cSChristoph Hellwig */ 47614fd29ec4SDarrick J. Wong error = xfs_trans_reserve_quota_nblks(NULL, ip, 47624fd29ec4SDarrick J. Wong -((long)del->br_blockcount), 0, 4763fa5c836cSChristoph Hellwig isrt ? XFS_QMOPT_RES_RTBLKS : XFS_QMOPT_RES_REGBLKS); 47644fd29ec4SDarrick J. Wong if (error) 47654fd29ec4SDarrick J. Wong return error; 4766fa5c836cSChristoph Hellwig ip->i_delayed_blks -= del->br_blockcount; 4767fa5c836cSChristoph Hellwig 4768fa5c836cSChristoph Hellwig if (got->br_startoff == del->br_startoff) 47690173c689SChristoph Hellwig state |= BMAP_LEFT_FILLING; 4770fa5c836cSChristoph Hellwig if (got_endoff == del_endoff) 47710173c689SChristoph Hellwig state |= BMAP_RIGHT_FILLING; 4772fa5c836cSChristoph Hellwig 47730173c689SChristoph Hellwig switch (state & (BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING)) { 47740173c689SChristoph Hellwig case BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING: 4775fa5c836cSChristoph Hellwig /* 4776fa5c836cSChristoph Hellwig * Matches the whole extent. Delete the entry. 4777fa5c836cSChristoph Hellwig */ 4778fa5c836cSChristoph Hellwig xfs_iext_remove(ip, *idx, 1, state); 4779fa5c836cSChristoph Hellwig --*idx; 4780fa5c836cSChristoph Hellwig break; 47810173c689SChristoph Hellwig case BMAP_LEFT_FILLING: 4782fa5c836cSChristoph Hellwig /* 4783fa5c836cSChristoph Hellwig * Deleting the first part of the extent. 4784fa5c836cSChristoph Hellwig */ 4785fa5c836cSChristoph Hellwig trace_xfs_bmap_pre_update(ip, *idx, state, _THIS_IP_); 4786fa5c836cSChristoph Hellwig got->br_startoff = del_endoff; 4787fa5c836cSChristoph Hellwig got->br_blockcount -= del->br_blockcount; 4788fa5c836cSChristoph Hellwig da_new = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(ip, 4789fa5c836cSChristoph Hellwig got->br_blockcount), da_old); 4790fa5c836cSChristoph Hellwig got->br_startblock = nullstartblock((int)da_new); 479167e4e69cSChristoph Hellwig xfs_iext_update_extent(ifp, *idx, got); 4792fa5c836cSChristoph Hellwig trace_xfs_bmap_post_update(ip, *idx, state, _THIS_IP_); 4793fa5c836cSChristoph Hellwig break; 47940173c689SChristoph Hellwig case BMAP_RIGHT_FILLING: 4795fa5c836cSChristoph Hellwig /* 4796fa5c836cSChristoph Hellwig * Deleting the last part of the extent. 4797fa5c836cSChristoph Hellwig */ 4798fa5c836cSChristoph Hellwig trace_xfs_bmap_pre_update(ip, *idx, state, _THIS_IP_); 4799fa5c836cSChristoph Hellwig got->br_blockcount = got->br_blockcount - del->br_blockcount; 4800fa5c836cSChristoph Hellwig da_new = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(ip, 4801fa5c836cSChristoph Hellwig got->br_blockcount), da_old); 4802fa5c836cSChristoph Hellwig got->br_startblock = nullstartblock((int)da_new); 480367e4e69cSChristoph Hellwig xfs_iext_update_extent(ifp, *idx, got); 4804fa5c836cSChristoph Hellwig trace_xfs_bmap_post_update(ip, *idx, state, _THIS_IP_); 4805fa5c836cSChristoph Hellwig break; 4806fa5c836cSChristoph Hellwig case 0: 4807fa5c836cSChristoph Hellwig /* 4808fa5c836cSChristoph Hellwig * Deleting the middle of the extent. 4809fa5c836cSChristoph Hellwig * 4810fa5c836cSChristoph Hellwig * Distribute the original indlen reservation across the two new 4811fa5c836cSChristoph Hellwig * extents. Steal blocks from the deleted extent if necessary. 4812fa5c836cSChristoph Hellwig * Stealing blocks simply fudges the fdblocks accounting below. 4813fa5c836cSChristoph Hellwig * Warn if either of the new indlen reservations is zero as this 4814fa5c836cSChristoph Hellwig * can lead to delalloc problems. 4815fa5c836cSChristoph Hellwig */ 4816fa5c836cSChristoph Hellwig trace_xfs_bmap_pre_update(ip, *idx, state, _THIS_IP_); 4817fa5c836cSChristoph Hellwig 4818fa5c836cSChristoph Hellwig got->br_blockcount = del->br_startoff - got->br_startoff; 4819fa5c836cSChristoph Hellwig got_indlen = xfs_bmap_worst_indlen(ip, got->br_blockcount); 4820fa5c836cSChristoph Hellwig 4821fa5c836cSChristoph Hellwig new.br_blockcount = got_endoff - del_endoff; 4822fa5c836cSChristoph Hellwig new_indlen = xfs_bmap_worst_indlen(ip, new.br_blockcount); 4823fa5c836cSChristoph Hellwig 4824fa5c836cSChristoph Hellwig WARN_ON_ONCE(!got_indlen || !new_indlen); 4825fa5c836cSChristoph Hellwig stolen = xfs_bmap_split_indlen(da_old, &got_indlen, &new_indlen, 4826fa5c836cSChristoph Hellwig del->br_blockcount); 4827fa5c836cSChristoph Hellwig 4828fa5c836cSChristoph Hellwig got->br_startblock = nullstartblock((int)got_indlen); 482967e4e69cSChristoph Hellwig xfs_iext_update_extent(ifp, *idx, got); 4830fa5c836cSChristoph Hellwig trace_xfs_bmap_post_update(ip, *idx, 0, _THIS_IP_); 4831fa5c836cSChristoph Hellwig 4832fa5c836cSChristoph Hellwig new.br_startoff = del_endoff; 4833fa5c836cSChristoph Hellwig new.br_state = got->br_state; 4834fa5c836cSChristoph Hellwig new.br_startblock = nullstartblock((int)new_indlen); 4835fa5c836cSChristoph Hellwig 4836fa5c836cSChristoph Hellwig ++*idx; 4837fa5c836cSChristoph Hellwig xfs_iext_insert(ip, *idx, 1, &new, state); 4838fa5c836cSChristoph Hellwig 4839fa5c836cSChristoph Hellwig da_new = got_indlen + new_indlen - stolen; 4840fa5c836cSChristoph Hellwig del->br_blockcount -= stolen; 4841fa5c836cSChristoph Hellwig break; 4842fa5c836cSChristoph Hellwig } 4843fa5c836cSChristoph Hellwig 4844fa5c836cSChristoph Hellwig ASSERT(da_old >= da_new); 4845fa5c836cSChristoph Hellwig da_diff = da_old - da_new; 4846fa5c836cSChristoph Hellwig if (!isrt) 4847fa5c836cSChristoph Hellwig da_diff += del->br_blockcount; 4848fa5c836cSChristoph Hellwig if (da_diff) 4849fa5c836cSChristoph Hellwig xfs_mod_fdblocks(mp, da_diff, false); 4850fa5c836cSChristoph Hellwig return error; 4851fa5c836cSChristoph Hellwig } 4852fa5c836cSChristoph Hellwig 4853fa5c836cSChristoph Hellwig void 4854fa5c836cSChristoph Hellwig xfs_bmap_del_extent_cow( 4855fa5c836cSChristoph Hellwig struct xfs_inode *ip, 4856fa5c836cSChristoph Hellwig xfs_extnum_t *idx, 4857fa5c836cSChristoph Hellwig struct xfs_bmbt_irec *got, 4858fa5c836cSChristoph Hellwig struct xfs_bmbt_irec *del) 4859fa5c836cSChristoph Hellwig { 4860fa5c836cSChristoph Hellwig struct xfs_mount *mp = ip->i_mount; 4861fa5c836cSChristoph Hellwig struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, XFS_COW_FORK); 4862fa5c836cSChristoph Hellwig struct xfs_bmbt_irec new; 4863fa5c836cSChristoph Hellwig xfs_fileoff_t del_endoff, got_endoff; 4864fa5c836cSChristoph Hellwig int state = BMAP_COWFORK; 4865fa5c836cSChristoph Hellwig 4866fa5c836cSChristoph Hellwig XFS_STATS_INC(mp, xs_del_exlist); 4867fa5c836cSChristoph Hellwig 4868fa5c836cSChristoph Hellwig del_endoff = del->br_startoff + del->br_blockcount; 4869fa5c836cSChristoph Hellwig got_endoff = got->br_startoff + got->br_blockcount; 4870fa5c836cSChristoph Hellwig 4871fa5c836cSChristoph Hellwig ASSERT(*idx >= 0); 48725d829300SEric Sandeen ASSERT(*idx <= xfs_iext_count(ifp)); 4873fa5c836cSChristoph Hellwig ASSERT(del->br_blockcount > 0); 4874fa5c836cSChristoph Hellwig ASSERT(got->br_startoff <= del->br_startoff); 4875fa5c836cSChristoph Hellwig ASSERT(got_endoff >= del_endoff); 4876fa5c836cSChristoph Hellwig ASSERT(!isnullstartblock(got->br_startblock)); 4877fa5c836cSChristoph Hellwig 4878fa5c836cSChristoph Hellwig if (got->br_startoff == del->br_startoff) 48790173c689SChristoph Hellwig state |= BMAP_LEFT_FILLING; 4880fa5c836cSChristoph Hellwig if (got_endoff == del_endoff) 48810173c689SChristoph Hellwig state |= BMAP_RIGHT_FILLING; 4882fa5c836cSChristoph Hellwig 48830173c689SChristoph Hellwig switch (state & (BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING)) { 48840173c689SChristoph Hellwig case BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING: 4885fa5c836cSChristoph Hellwig /* 4886fa5c836cSChristoph Hellwig * Matches the whole extent. Delete the entry. 4887fa5c836cSChristoph Hellwig */ 4888fa5c836cSChristoph Hellwig xfs_iext_remove(ip, *idx, 1, state); 4889fa5c836cSChristoph Hellwig --*idx; 4890fa5c836cSChristoph Hellwig break; 48910173c689SChristoph Hellwig case BMAP_LEFT_FILLING: 4892fa5c836cSChristoph Hellwig /* 4893fa5c836cSChristoph Hellwig * Deleting the first part of the extent. 4894fa5c836cSChristoph Hellwig */ 4895fa5c836cSChristoph Hellwig trace_xfs_bmap_pre_update(ip, *idx, state, _THIS_IP_); 4896fa5c836cSChristoph Hellwig got->br_startoff = del_endoff; 4897fa5c836cSChristoph Hellwig got->br_blockcount -= del->br_blockcount; 4898fa5c836cSChristoph Hellwig got->br_startblock = del->br_startblock + del->br_blockcount; 489967e4e69cSChristoph Hellwig xfs_iext_update_extent(ifp, *idx, got); 4900fa5c836cSChristoph Hellwig trace_xfs_bmap_post_update(ip, *idx, state, _THIS_IP_); 4901fa5c836cSChristoph Hellwig break; 49020173c689SChristoph Hellwig case BMAP_RIGHT_FILLING: 4903fa5c836cSChristoph Hellwig /* 4904fa5c836cSChristoph Hellwig * Deleting the last part of the extent. 4905fa5c836cSChristoph Hellwig */ 4906fa5c836cSChristoph Hellwig trace_xfs_bmap_pre_update(ip, *idx, state, _THIS_IP_); 4907fa5c836cSChristoph Hellwig got->br_blockcount -= del->br_blockcount; 490867e4e69cSChristoph Hellwig xfs_iext_update_extent(ifp, *idx, got); 4909fa5c836cSChristoph Hellwig trace_xfs_bmap_post_update(ip, *idx, state, _THIS_IP_); 4910fa5c836cSChristoph Hellwig break; 4911fa5c836cSChristoph Hellwig case 0: 4912fa5c836cSChristoph Hellwig /* 4913fa5c836cSChristoph Hellwig * Deleting the middle of the extent. 4914fa5c836cSChristoph Hellwig */ 4915fa5c836cSChristoph Hellwig trace_xfs_bmap_pre_update(ip, *idx, state, _THIS_IP_); 4916fa5c836cSChristoph Hellwig got->br_blockcount = del->br_startoff - got->br_startoff; 491767e4e69cSChristoph Hellwig xfs_iext_update_extent(ifp, *idx, got); 4918fa5c836cSChristoph Hellwig trace_xfs_bmap_post_update(ip, *idx, state, _THIS_IP_); 4919fa5c836cSChristoph Hellwig 4920fa5c836cSChristoph Hellwig new.br_startoff = del_endoff; 4921fa5c836cSChristoph Hellwig new.br_blockcount = got_endoff - del_endoff; 4922fa5c836cSChristoph Hellwig new.br_state = got->br_state; 4923fa5c836cSChristoph Hellwig new.br_startblock = del->br_startblock + del->br_blockcount; 4924fa5c836cSChristoph Hellwig 4925fa5c836cSChristoph Hellwig ++*idx; 4926fa5c836cSChristoph Hellwig xfs_iext_insert(ip, *idx, 1, &new, state); 4927fa5c836cSChristoph Hellwig break; 4928fa5c836cSChristoph Hellwig } 4929fa5c836cSChristoph Hellwig } 4930fa5c836cSChristoph Hellwig 4931a9bd24acSBrian Foster /* 493230f712c9SDave Chinner * Called by xfs_bmapi to update file extent records and the btree 4933e1d7553fSChristoph Hellwig * after removing space. 493430f712c9SDave Chinner */ 493530f712c9SDave Chinner STATIC int /* error */ 4936e1d7553fSChristoph Hellwig xfs_bmap_del_extent_real( 493730f712c9SDave Chinner xfs_inode_t *ip, /* incore inode pointer */ 493830f712c9SDave Chinner xfs_trans_t *tp, /* current transaction pointer */ 493930f712c9SDave Chinner xfs_extnum_t *idx, /* extent number to update/delete */ 49402c3234d1SDarrick J. Wong struct xfs_defer_ops *dfops, /* list of extents to be freed */ 494130f712c9SDave Chinner xfs_btree_cur_t *cur, /* if null, not a btree */ 494230f712c9SDave Chinner xfs_bmbt_irec_t *del, /* data to remove from extents */ 494330f712c9SDave Chinner int *logflagsp, /* inode logging flags */ 49444847acf8SDarrick J. Wong int whichfork, /* data or attr fork */ 49454847acf8SDarrick J. Wong int bflags) /* bmapi flags */ 494630f712c9SDave Chinner { 494730f712c9SDave Chinner xfs_fsblock_t del_endblock=0; /* first block past del */ 494830f712c9SDave Chinner xfs_fileoff_t del_endoff; /* first offset past del */ 494930f712c9SDave Chinner int do_fx; /* free extent at end of routine */ 495030f712c9SDave Chinner int error; /* error return value */ 49511b24b633SChristoph Hellwig int flags = 0;/* inode logging flags */ 495248fd52b1SChristoph Hellwig struct xfs_bmbt_irec got; /* current extent entry */ 495330f712c9SDave Chinner xfs_fileoff_t got_endoff; /* first offset past got */ 495430f712c9SDave Chinner int i; /* temp state */ 495530f712c9SDave Chinner xfs_ifork_t *ifp; /* inode fork pointer */ 495630f712c9SDave Chinner xfs_mount_t *mp; /* mount structure */ 495730f712c9SDave Chinner xfs_filblks_t nblks; /* quota/sb block count */ 495830f712c9SDave Chinner xfs_bmbt_irec_t new; /* new record to be inserted */ 495930f712c9SDave Chinner /* REFERENCED */ 496030f712c9SDave Chinner uint qfield; /* quota field to update */ 4961060ea65bSChristoph Hellwig int state = xfs_bmap_fork_to_state(whichfork); 496248fd52b1SChristoph Hellwig struct xfs_bmbt_irec old; 496330f712c9SDave Chinner 4964ff6d6af2SBill O'Donnell mp = ip->i_mount; 4965ff6d6af2SBill O'Donnell XFS_STATS_INC(mp, xs_del_exlist); 496630f712c9SDave Chinner 496730f712c9SDave Chinner ifp = XFS_IFORK_PTR(ip, whichfork); 49685d829300SEric Sandeen ASSERT((*idx >= 0) && (*idx < xfs_iext_count(ifp))); 496930f712c9SDave Chinner ASSERT(del->br_blockcount > 0); 497048fd52b1SChristoph Hellwig xfs_iext_get_extent(ifp, *idx, &got); 497130f712c9SDave Chinner ASSERT(got.br_startoff <= del->br_startoff); 497230f712c9SDave Chinner del_endoff = del->br_startoff + del->br_blockcount; 497330f712c9SDave Chinner got_endoff = got.br_startoff + got.br_blockcount; 497430f712c9SDave Chinner ASSERT(got_endoff >= del_endoff); 4975e1d7553fSChristoph Hellwig ASSERT(!isnullstartblock(got.br_startblock)); 497630f712c9SDave Chinner qfield = 0; 497730f712c9SDave Chinner error = 0; 4978e1d7553fSChristoph Hellwig 49791b24b633SChristoph Hellwig /* 49801b24b633SChristoph Hellwig * If it's the case where the directory code is running with no block 49811b24b633SChristoph Hellwig * reservation, and the deleted block is in the middle of its extent, 49821b24b633SChristoph Hellwig * and the resulting insert of an extent would cause transformation to 49831b24b633SChristoph Hellwig * btree format, then reject it. The calling code will then swap blocks 49841b24b633SChristoph Hellwig * around instead. We have to do this now, rather than waiting for the 49851b24b633SChristoph Hellwig * conversion to btree format, since the transaction will be dirty then. 49861b24b633SChristoph Hellwig */ 49871b24b633SChristoph Hellwig if (tp->t_blk_res == 0 && 49881b24b633SChristoph Hellwig XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_EXTENTS && 49891b24b633SChristoph Hellwig XFS_IFORK_NEXTENTS(ip, whichfork) >= 49901b24b633SChristoph Hellwig XFS_IFORK_MAXEXT(ip, whichfork) && 49911b24b633SChristoph Hellwig del->br_startoff > got.br_startoff && del_endoff < got_endoff) 49921b24b633SChristoph Hellwig return -ENOSPC; 49931b24b633SChristoph Hellwig 49941b24b633SChristoph Hellwig flags = XFS_ILOG_CORE; 499530f712c9SDave Chinner if (whichfork == XFS_DATA_FORK && XFS_IS_REALTIME_INODE(ip)) { 499630f712c9SDave Chinner xfs_fsblock_t bno; 499730f712c9SDave Chinner xfs_filblks_t len; 499830f712c9SDave Chinner 4999e1d7553fSChristoph Hellwig ASSERT(do_mod(del->br_blockcount, mp->m_sb.sb_rextsize) == 0); 5000e1d7553fSChristoph Hellwig ASSERT(do_mod(del->br_startblock, mp->m_sb.sb_rextsize) == 0); 500130f712c9SDave Chinner bno = del->br_startblock; 500230f712c9SDave Chinner len = del->br_blockcount; 500330f712c9SDave Chinner do_div(bno, mp->m_sb.sb_rextsize); 500430f712c9SDave Chinner do_div(len, mp->m_sb.sb_rextsize); 500530f712c9SDave Chinner error = xfs_rtfree_extent(tp, bno, (xfs_extlen_t)len); 500630f712c9SDave Chinner if (error) 500730f712c9SDave Chinner goto done; 500830f712c9SDave Chinner do_fx = 0; 500930f712c9SDave Chinner nblks = len * mp->m_sb.sb_rextsize; 501030f712c9SDave Chinner qfield = XFS_TRANS_DQ_RTBCOUNT; 5011e1d7553fSChristoph Hellwig } else { 501230f712c9SDave Chinner do_fx = 1; 501330f712c9SDave Chinner nblks = del->br_blockcount; 501430f712c9SDave Chinner qfield = XFS_TRANS_DQ_BCOUNT; 501530f712c9SDave Chinner } 5016e1d7553fSChristoph Hellwig 501730f712c9SDave Chinner del_endblock = del->br_startblock + del->br_blockcount; 501830f712c9SDave Chinner if (cur) { 5019e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(cur, &got, &i); 5020e1d7553fSChristoph Hellwig if (error) 502130f712c9SDave Chinner goto done; 5022c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 502330f712c9SDave Chinner } 5024340785ccSDarrick J. Wong 5025491f6f8aSChristoph Hellwig if (got.br_startoff == del->br_startoff) 5026491f6f8aSChristoph Hellwig state |= BMAP_LEFT_FILLING; 5027491f6f8aSChristoph Hellwig if (got_endoff == del_endoff) 5028491f6f8aSChristoph Hellwig state |= BMAP_RIGHT_FILLING; 5029491f6f8aSChristoph Hellwig 5030491f6f8aSChristoph Hellwig switch (state & (BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING)) { 5031491f6f8aSChristoph Hellwig case BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING: 503230f712c9SDave Chinner /* 503330f712c9SDave Chinner * Matches the whole extent. Delete the entry. 503430f712c9SDave Chinner */ 50354862cfe8SDarrick J. Wong trace_xfs_bmap_pre_update(ip, *idx, state, _THIS_IP_); 503635e62da5SChristoph Hellwig xfs_iext_remove(ip, *idx, 1, state); 503730f712c9SDave Chinner --*idx; 503830f712c9SDave Chinner 503930f712c9SDave Chinner XFS_IFORK_NEXT_SET(ip, whichfork, 504030f712c9SDave Chinner XFS_IFORK_NEXTENTS(ip, whichfork) - 1); 504130f712c9SDave Chinner flags |= XFS_ILOG_CORE; 504230f712c9SDave Chinner if (!cur) { 504330f712c9SDave Chinner flags |= xfs_ilog_fext(whichfork); 504430f712c9SDave Chinner break; 504530f712c9SDave Chinner } 504630f712c9SDave Chinner if ((error = xfs_btree_delete(cur, &i))) 504730f712c9SDave Chinner goto done; 5048c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 504930f712c9SDave Chinner break; 5050491f6f8aSChristoph Hellwig case BMAP_LEFT_FILLING: 505130f712c9SDave Chinner /* 505230f712c9SDave Chinner * Deleting the first part of the extent. 505330f712c9SDave Chinner */ 505430f712c9SDave Chinner trace_xfs_bmap_pre_update(ip, *idx, state, _THIS_IP_); 505548fd52b1SChristoph Hellwig got.br_startoff = del_endoff; 505648fd52b1SChristoph Hellwig got.br_startblock = del_endblock; 505748fd52b1SChristoph Hellwig got.br_blockcount -= del->br_blockcount; 505848fd52b1SChristoph Hellwig xfs_iext_update_extent(ifp, *idx, &got); 505930f712c9SDave Chinner trace_xfs_bmap_post_update(ip, *idx, state, _THIS_IP_); 506030f712c9SDave Chinner if (!cur) { 506130f712c9SDave Chinner flags |= xfs_ilog_fext(whichfork); 506230f712c9SDave Chinner break; 506330f712c9SDave Chinner } 5064a67d00a5SChristoph Hellwig error = xfs_bmbt_update(cur, &got); 506548fd52b1SChristoph Hellwig if (error) 506630f712c9SDave Chinner goto done; 506730f712c9SDave Chinner break; 5068491f6f8aSChristoph Hellwig case BMAP_RIGHT_FILLING: 506930f712c9SDave Chinner /* 507030f712c9SDave Chinner * Deleting the last part of the extent. 507130f712c9SDave Chinner */ 507230f712c9SDave Chinner trace_xfs_bmap_pre_update(ip, *idx, state, _THIS_IP_); 507348fd52b1SChristoph Hellwig got.br_blockcount -= del->br_blockcount; 507448fd52b1SChristoph Hellwig xfs_iext_update_extent(ifp, *idx, &got); 507530f712c9SDave Chinner trace_xfs_bmap_post_update(ip, *idx, state, _THIS_IP_); 507630f712c9SDave Chinner if (!cur) { 507730f712c9SDave Chinner flags |= xfs_ilog_fext(whichfork); 507830f712c9SDave Chinner break; 507930f712c9SDave Chinner } 5080a67d00a5SChristoph Hellwig error = xfs_bmbt_update(cur, &got); 508148fd52b1SChristoph Hellwig if (error) 508230f712c9SDave Chinner goto done; 508330f712c9SDave Chinner break; 508430f712c9SDave Chinner case 0: 508530f712c9SDave Chinner /* 508630f712c9SDave Chinner * Deleting the middle of the extent. 508730f712c9SDave Chinner */ 508830f712c9SDave Chinner trace_xfs_bmap_pre_update(ip, *idx, state, _THIS_IP_); 508948fd52b1SChristoph Hellwig 509048fd52b1SChristoph Hellwig old = got; 509148fd52b1SChristoph Hellwig got.br_blockcount = del->br_startoff - got.br_startoff; 509248fd52b1SChristoph Hellwig xfs_iext_update_extent(ifp, *idx, &got); 509348fd52b1SChristoph Hellwig 509430f712c9SDave Chinner new.br_startoff = del_endoff; 509548fd52b1SChristoph Hellwig new.br_blockcount = got_endoff - del_endoff; 509630f712c9SDave Chinner new.br_state = got.br_state; 509730f712c9SDave Chinner new.br_startblock = del_endblock; 509848fd52b1SChristoph Hellwig 509930f712c9SDave Chinner flags |= XFS_ILOG_CORE; 510030f712c9SDave Chinner if (cur) { 5101a67d00a5SChristoph Hellwig error = xfs_bmbt_update(cur, &got); 5102e1d7553fSChristoph Hellwig if (error) 510330f712c9SDave Chinner goto done; 5104e1d7553fSChristoph Hellwig error = xfs_btree_increment(cur, 0, &i); 5105e1d7553fSChristoph Hellwig if (error) 510630f712c9SDave Chinner goto done; 510730f712c9SDave Chinner cur->bc_rec.b = new; 510830f712c9SDave Chinner error = xfs_btree_insert(cur, &i); 51092451337dSDave Chinner if (error && error != -ENOSPC) 511030f712c9SDave Chinner goto done; 511130f712c9SDave Chinner /* 5112e1d7553fSChristoph Hellwig * If get no-space back from btree insert, it tried a 5113e1d7553fSChristoph Hellwig * split, and we have a zero block reservation. Fix up 5114e1d7553fSChristoph Hellwig * our state and return the error. 511530f712c9SDave Chinner */ 51162451337dSDave Chinner if (error == -ENOSPC) { 511730f712c9SDave Chinner /* 5118e1d7553fSChristoph Hellwig * Reset the cursor, don't trust it after any 5119e1d7553fSChristoph Hellwig * insert operation. 512030f712c9SDave Chinner */ 5121e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(cur, &got, &i); 5122e1d7553fSChristoph Hellwig if (error) 512330f712c9SDave Chinner goto done; 5124e1d7553fSChristoph Hellwig XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 512530f712c9SDave Chinner /* 512630f712c9SDave Chinner * Update the btree record back 512730f712c9SDave Chinner * to the original value. 512830f712c9SDave Chinner */ 5129a67d00a5SChristoph Hellwig error = xfs_bmbt_update(cur, &old); 5130e1d7553fSChristoph Hellwig if (error) 513130f712c9SDave Chinner goto done; 513230f712c9SDave Chinner /* 513330f712c9SDave Chinner * Reset the extent record back 513430f712c9SDave Chinner * to the original value. 513530f712c9SDave Chinner */ 513648fd52b1SChristoph Hellwig xfs_iext_update_extent(ifp, *idx, &old); 513730f712c9SDave Chinner flags = 0; 51382451337dSDave Chinner error = -ENOSPC; 513930f712c9SDave Chinner goto done; 514030f712c9SDave Chinner } 5141c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 514230f712c9SDave Chinner } else 514330f712c9SDave Chinner flags |= xfs_ilog_fext(whichfork); 514430f712c9SDave Chinner XFS_IFORK_NEXT_SET(ip, whichfork, 514530f712c9SDave Chinner XFS_IFORK_NEXTENTS(ip, whichfork) + 1); 514630f712c9SDave Chinner trace_xfs_bmap_post_update(ip, *idx, state, _THIS_IP_); 514730f712c9SDave Chinner xfs_iext_insert(ip, *idx + 1, 1, &new, state); 514830f712c9SDave Chinner ++*idx; 514930f712c9SDave Chinner break; 515030f712c9SDave Chinner } 51519c194644SDarrick J. Wong 51529c194644SDarrick J. Wong /* remove reverse mapping */ 51539c194644SDarrick J. Wong error = xfs_rmap_unmap_extent(mp, dfops, ip, whichfork, del); 51549c194644SDarrick J. Wong if (error) 51559c194644SDarrick J. Wong goto done; 51569c194644SDarrick J. Wong 515730f712c9SDave Chinner /* 515830f712c9SDave Chinner * If we need to, add to list of extents to delete. 515930f712c9SDave Chinner */ 51604847acf8SDarrick J. Wong if (do_fx && !(bflags & XFS_BMAPI_REMAP)) { 516162aab20fSDarrick J. Wong if (xfs_is_reflink_inode(ip) && whichfork == XFS_DATA_FORK) { 516262aab20fSDarrick J. Wong error = xfs_refcount_decrease_extent(mp, dfops, del); 516362aab20fSDarrick J. Wong if (error) 516462aab20fSDarrick J. Wong goto done; 516562aab20fSDarrick J. Wong } else 51662c3234d1SDarrick J. Wong xfs_bmap_add_free(mp, dfops, del->br_startblock, 5167340785ccSDarrick J. Wong del->br_blockcount, NULL); 516862aab20fSDarrick J. Wong } 516962aab20fSDarrick J. Wong 517030f712c9SDave Chinner /* 517130f712c9SDave Chinner * Adjust inode # blocks in the file. 517230f712c9SDave Chinner */ 517330f712c9SDave Chinner if (nblks) 517430f712c9SDave Chinner ip->i_d.di_nblocks -= nblks; 517530f712c9SDave Chinner /* 517630f712c9SDave Chinner * Adjust quota data. 517730f712c9SDave Chinner */ 51784847acf8SDarrick J. Wong if (qfield && !(bflags & XFS_BMAPI_REMAP)) 517930f712c9SDave Chinner xfs_trans_mod_dquot_byino(tp, ip, qfield, (long)-nblks); 518030f712c9SDave Chinner 518130f712c9SDave Chinner done: 518230f712c9SDave Chinner *logflagsp = flags; 518330f712c9SDave Chinner return error; 518430f712c9SDave Chinner } 518530f712c9SDave Chinner 518630f712c9SDave Chinner /* 518730f712c9SDave Chinner * Unmap (remove) blocks from a file. 518830f712c9SDave Chinner * If nexts is nonzero then the number of extents to remove is limited to 518930f712c9SDave Chinner * that value. If not all extents in the block range can be removed then 519030f712c9SDave Chinner * *done is set. 519130f712c9SDave Chinner */ 519230f712c9SDave Chinner int /* error */ 51934453593bSDarrick J. Wong __xfs_bunmapi( 519430f712c9SDave Chinner xfs_trans_t *tp, /* transaction pointer */ 519530f712c9SDave Chinner struct xfs_inode *ip, /* incore inode */ 51968280f6edSChristoph Hellwig xfs_fileoff_t start, /* first file offset deleted */ 51974453593bSDarrick J. Wong xfs_filblks_t *rlen, /* i/o: amount remaining */ 519830f712c9SDave Chinner int flags, /* misc flags */ 519930f712c9SDave Chinner xfs_extnum_t nexts, /* number of extents max */ 520030f712c9SDave Chinner xfs_fsblock_t *firstblock, /* first allocated block 520130f712c9SDave Chinner controls a.g. for allocs */ 52024453593bSDarrick J. Wong struct xfs_defer_ops *dfops) /* i/o: deferred updates */ 520330f712c9SDave Chinner { 520430f712c9SDave Chinner xfs_btree_cur_t *cur; /* bmap btree cursor */ 520530f712c9SDave Chinner xfs_bmbt_irec_t del; /* extent being deleted */ 520630f712c9SDave Chinner int error; /* error return value */ 520730f712c9SDave Chinner xfs_extnum_t extno; /* extent number in list */ 520830f712c9SDave Chinner xfs_bmbt_irec_t got; /* current extent record */ 520930f712c9SDave Chinner xfs_ifork_t *ifp; /* inode fork pointer */ 521030f712c9SDave Chinner int isrt; /* freeing in rt area */ 521130f712c9SDave Chinner xfs_extnum_t lastx; /* last extent index used */ 521230f712c9SDave Chinner int logflags; /* transaction logging flags */ 521330f712c9SDave Chinner xfs_extlen_t mod; /* rt extent offset */ 521430f712c9SDave Chinner xfs_mount_t *mp; /* mount structure */ 521530f712c9SDave Chinner int tmp_logflags; /* partial logging flags */ 521630f712c9SDave Chinner int wasdel; /* was a delayed alloc extent */ 521730f712c9SDave Chinner int whichfork; /* data or attribute fork */ 521830f712c9SDave Chinner xfs_fsblock_t sum; 52194453593bSDarrick J. Wong xfs_filblks_t len = *rlen; /* length to unmap in file */ 5220e1a4e37cSDarrick J. Wong xfs_fileoff_t max_len; 52215b094d6dSChristoph Hellwig xfs_agnumber_t prev_agno = NULLAGNUMBER, agno; 52228280f6edSChristoph Hellwig xfs_fileoff_t end; 522330f712c9SDave Chinner 52248280f6edSChristoph Hellwig trace_xfs_bunmap(ip, start, len, flags, _RET_IP_); 522530f712c9SDave Chinner 52263993baebSDarrick J. Wong whichfork = xfs_bmapi_whichfork(flags); 52273993baebSDarrick J. Wong ASSERT(whichfork != XFS_COW_FORK); 522830f712c9SDave Chinner ifp = XFS_IFORK_PTR(ip, whichfork); 522930f712c9SDave Chinner if (unlikely( 523030f712c9SDave Chinner XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS && 523130f712c9SDave Chinner XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE)) { 523230f712c9SDave Chinner XFS_ERROR_REPORT("xfs_bunmapi", XFS_ERRLEVEL_LOW, 523330f712c9SDave Chinner ip->i_mount); 52342451337dSDave Chinner return -EFSCORRUPTED; 523530f712c9SDave Chinner } 523630f712c9SDave Chinner mp = ip->i_mount; 523730f712c9SDave Chinner if (XFS_FORCED_SHUTDOWN(mp)) 52382451337dSDave Chinner return -EIO; 523930f712c9SDave Chinner 524030f712c9SDave Chinner ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL)); 524130f712c9SDave Chinner ASSERT(len > 0); 524230f712c9SDave Chinner ASSERT(nexts >= 0); 524330f712c9SDave Chinner 5244e1a4e37cSDarrick J. Wong /* 5245e1a4e37cSDarrick J. Wong * Guesstimate how many blocks we can unmap without running the risk of 5246e1a4e37cSDarrick J. Wong * blowing out the transaction with a mix of EFIs and reflink 5247e1a4e37cSDarrick J. Wong * adjustments. 5248e1a4e37cSDarrick J. Wong */ 5249e1a4e37cSDarrick J. Wong if (xfs_is_reflink_inode(ip) && whichfork == XFS_DATA_FORK) 5250e1a4e37cSDarrick J. Wong max_len = min(len, xfs_refcount_max_unmap(tp->t_log_res)); 5251e1a4e37cSDarrick J. Wong else 5252e1a4e37cSDarrick J. Wong max_len = len; 5253e1a4e37cSDarrick J. Wong 525430f712c9SDave Chinner if (!(ifp->if_flags & XFS_IFEXTENTS) && 525530f712c9SDave Chinner (error = xfs_iread_extents(tp, ip, whichfork))) 525630f712c9SDave Chinner return error; 52575d829300SEric Sandeen if (xfs_iext_count(ifp) == 0) { 52584453593bSDarrick J. Wong *rlen = 0; 525930f712c9SDave Chinner return 0; 526030f712c9SDave Chinner } 5261ff6d6af2SBill O'Donnell XFS_STATS_INC(mp, xs_blk_unmap); 526230f712c9SDave Chinner isrt = (whichfork == XFS_DATA_FORK) && XFS_IS_REALTIME_INODE(ip); 52638280f6edSChristoph Hellwig end = start + len - 1; 526430f712c9SDave Chinner 526530f712c9SDave Chinner /* 526630f712c9SDave Chinner * Check to see if the given block number is past the end of the 526730f712c9SDave Chinner * file, back up to the last block if so... 526830f712c9SDave Chinner */ 52698280f6edSChristoph Hellwig if (!xfs_iext_lookup_extent(ip, ifp, end, &lastx, &got)) { 52707efc7945SChristoph Hellwig ASSERT(lastx > 0); 52717efc7945SChristoph Hellwig xfs_iext_get_extent(ifp, --lastx, &got); 52728280f6edSChristoph Hellwig end = got.br_startoff + got.br_blockcount - 1; 527330f712c9SDave Chinner } 52747efc7945SChristoph Hellwig 527530f712c9SDave Chinner logflags = 0; 527630f712c9SDave Chinner if (ifp->if_flags & XFS_IFBROOT) { 527730f712c9SDave Chinner ASSERT(XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_BTREE); 527830f712c9SDave Chinner cur = xfs_bmbt_init_cursor(mp, tp, ip, whichfork); 527930f712c9SDave Chinner cur->bc_private.b.firstblock = *firstblock; 52802c3234d1SDarrick J. Wong cur->bc_private.b.dfops = dfops; 528130f712c9SDave Chinner cur->bc_private.b.flags = 0; 528230f712c9SDave Chinner } else 528330f712c9SDave Chinner cur = NULL; 528430f712c9SDave Chinner 528530f712c9SDave Chinner if (isrt) { 528630f712c9SDave Chinner /* 528730f712c9SDave Chinner * Synchronize by locking the bitmap inode. 528830f712c9SDave Chinner */ 5289f4a0660dSDarrick J. Wong xfs_ilock(mp->m_rbmip, XFS_ILOCK_EXCL|XFS_ILOCK_RTBITMAP); 529030f712c9SDave Chinner xfs_trans_ijoin(tp, mp->m_rbmip, XFS_ILOCK_EXCL); 5291f4a0660dSDarrick J. Wong xfs_ilock(mp->m_rsumip, XFS_ILOCK_EXCL|XFS_ILOCK_RTSUM); 5292f4a0660dSDarrick J. Wong xfs_trans_ijoin(tp, mp->m_rsumip, XFS_ILOCK_EXCL); 529330f712c9SDave Chinner } 529430f712c9SDave Chinner 529530f712c9SDave Chinner extno = 0; 52968280f6edSChristoph Hellwig while (end != (xfs_fileoff_t)-1 && end >= start && lastx >= 0 && 5297e1a4e37cSDarrick J. Wong (nexts == 0 || extno < nexts) && max_len > 0) { 529830f712c9SDave Chinner /* 52998280f6edSChristoph Hellwig * Is the found extent after a hole in which end lives? 530030f712c9SDave Chinner * Just back up to the previous extent, if so. 530130f712c9SDave Chinner */ 53028280f6edSChristoph Hellwig if (got.br_startoff > end) { 530330f712c9SDave Chinner if (--lastx < 0) 530430f712c9SDave Chinner break; 53057efc7945SChristoph Hellwig xfs_iext_get_extent(ifp, lastx, &got); 530630f712c9SDave Chinner } 530730f712c9SDave Chinner /* 530830f712c9SDave Chinner * Is the last block of this extent before the range 530930f712c9SDave Chinner * we're supposed to delete? If so, we're done. 531030f712c9SDave Chinner */ 53118280f6edSChristoph Hellwig end = XFS_FILEOFF_MIN(end, 531230f712c9SDave Chinner got.br_startoff + got.br_blockcount - 1); 53138280f6edSChristoph Hellwig if (end < start) 531430f712c9SDave Chinner break; 531530f712c9SDave Chinner /* 531630f712c9SDave Chinner * Then deal with the (possibly delayed) allocated space 531730f712c9SDave Chinner * we found. 531830f712c9SDave Chinner */ 531930f712c9SDave Chinner del = got; 532030f712c9SDave Chinner wasdel = isnullstartblock(del.br_startblock); 53215b094d6dSChristoph Hellwig 53225b094d6dSChristoph Hellwig /* 53235b094d6dSChristoph Hellwig * Make sure we don't touch multiple AGF headers out of order 53245b094d6dSChristoph Hellwig * in a single transaction, as that could cause AB-BA deadlocks. 53255b094d6dSChristoph Hellwig */ 53265b094d6dSChristoph Hellwig if (!wasdel) { 53275b094d6dSChristoph Hellwig agno = XFS_FSB_TO_AGNO(mp, del.br_startblock); 53285b094d6dSChristoph Hellwig if (prev_agno != NULLAGNUMBER && prev_agno > agno) 53295b094d6dSChristoph Hellwig break; 53305b094d6dSChristoph Hellwig prev_agno = agno; 53315b094d6dSChristoph Hellwig } 533230f712c9SDave Chinner if (got.br_startoff < start) { 533330f712c9SDave Chinner del.br_startoff = start; 533430f712c9SDave Chinner del.br_blockcount -= start - got.br_startoff; 533530f712c9SDave Chinner if (!wasdel) 533630f712c9SDave Chinner del.br_startblock += start - got.br_startoff; 533730f712c9SDave Chinner } 53388280f6edSChristoph Hellwig if (del.br_startoff + del.br_blockcount > end + 1) 53398280f6edSChristoph Hellwig del.br_blockcount = end + 1 - del.br_startoff; 5340e1a4e37cSDarrick J. Wong 5341e1a4e37cSDarrick J. Wong /* How much can we safely unmap? */ 5342e1a4e37cSDarrick J. Wong if (max_len < del.br_blockcount) { 5343e1a4e37cSDarrick J. Wong del.br_startoff += del.br_blockcount - max_len; 5344e1a4e37cSDarrick J. Wong if (!wasdel) 5345e1a4e37cSDarrick J. Wong del.br_startblock += del.br_blockcount - max_len; 5346e1a4e37cSDarrick J. Wong del.br_blockcount = max_len; 5347e1a4e37cSDarrick J. Wong } 5348e1a4e37cSDarrick J. Wong 534930f712c9SDave Chinner sum = del.br_startblock + del.br_blockcount; 535030f712c9SDave Chinner if (isrt && 535130f712c9SDave Chinner (mod = do_mod(sum, mp->m_sb.sb_rextsize))) { 535230f712c9SDave Chinner /* 535330f712c9SDave Chinner * Realtime extent not lined up at the end. 535430f712c9SDave Chinner * The extent could have been split into written 535530f712c9SDave Chinner * and unwritten pieces, or we could just be 535630f712c9SDave Chinner * unmapping part of it. But we can't really 535730f712c9SDave Chinner * get rid of part of a realtime extent. 535830f712c9SDave Chinner */ 535930f712c9SDave Chinner if (del.br_state == XFS_EXT_UNWRITTEN || 536030f712c9SDave Chinner !xfs_sb_version_hasextflgbit(&mp->m_sb)) { 536130f712c9SDave Chinner /* 536230f712c9SDave Chinner * This piece is unwritten, or we're not 536330f712c9SDave Chinner * using unwritten extents. Skip over it. 536430f712c9SDave Chinner */ 53658280f6edSChristoph Hellwig ASSERT(end >= mod); 53668280f6edSChristoph Hellwig end -= mod > del.br_blockcount ? 536730f712c9SDave Chinner del.br_blockcount : mod; 53688280f6edSChristoph Hellwig if (end < got.br_startoff) { 536930f712c9SDave Chinner if (--lastx >= 0) 5370e3f0f756SChristoph Hellwig xfs_iext_get_extent(ifp, lastx, 5371e3f0f756SChristoph Hellwig &got); 537230f712c9SDave Chinner } 537330f712c9SDave Chinner continue; 537430f712c9SDave Chinner } 537530f712c9SDave Chinner /* 537630f712c9SDave Chinner * It's written, turn it unwritten. 537730f712c9SDave Chinner * This is better than zeroing it. 537830f712c9SDave Chinner */ 537930f712c9SDave Chinner ASSERT(del.br_state == XFS_EXT_NORM); 5380a7e5d03bSChristoph Hellwig ASSERT(tp->t_blk_res > 0); 538130f712c9SDave Chinner /* 538230f712c9SDave Chinner * If this spans a realtime extent boundary, 538330f712c9SDave Chinner * chop it back to the start of the one we end at. 538430f712c9SDave Chinner */ 538530f712c9SDave Chinner if (del.br_blockcount > mod) { 538630f712c9SDave Chinner del.br_startoff += del.br_blockcount - mod; 538730f712c9SDave Chinner del.br_startblock += del.br_blockcount - mod; 538830f712c9SDave Chinner del.br_blockcount = mod; 538930f712c9SDave Chinner } 539030f712c9SDave Chinner del.br_state = XFS_EXT_UNWRITTEN; 539130f712c9SDave Chinner error = xfs_bmap_add_extent_unwritten_real(tp, ip, 539205a630d7SDarrick J. Wong whichfork, &lastx, &cur, &del, 539305a630d7SDarrick J. Wong firstblock, dfops, &logflags); 539430f712c9SDave Chinner if (error) 539530f712c9SDave Chinner goto error0; 539630f712c9SDave Chinner goto nodelete; 539730f712c9SDave Chinner } 539830f712c9SDave Chinner if (isrt && (mod = do_mod(del.br_startblock, mp->m_sb.sb_rextsize))) { 539930f712c9SDave Chinner /* 540030f712c9SDave Chinner * Realtime extent is lined up at the end but not 540130f712c9SDave Chinner * at the front. We'll get rid of full extents if 540230f712c9SDave Chinner * we can. 540330f712c9SDave Chinner */ 540430f712c9SDave Chinner mod = mp->m_sb.sb_rextsize - mod; 540530f712c9SDave Chinner if (del.br_blockcount > mod) { 540630f712c9SDave Chinner del.br_blockcount -= mod; 540730f712c9SDave Chinner del.br_startoff += mod; 540830f712c9SDave Chinner del.br_startblock += mod; 540930f712c9SDave Chinner } else if ((del.br_startoff == start && 541030f712c9SDave Chinner (del.br_state == XFS_EXT_UNWRITTEN || 5411a7e5d03bSChristoph Hellwig tp->t_blk_res == 0)) || 541230f712c9SDave Chinner !xfs_sb_version_hasextflgbit(&mp->m_sb)) { 541330f712c9SDave Chinner /* 541430f712c9SDave Chinner * Can't make it unwritten. There isn't 541530f712c9SDave Chinner * a full extent here so just skip it. 541630f712c9SDave Chinner */ 54178280f6edSChristoph Hellwig ASSERT(end >= del.br_blockcount); 54188280f6edSChristoph Hellwig end -= del.br_blockcount; 54198280f6edSChristoph Hellwig if (got.br_startoff > end && --lastx >= 0) 54207efc7945SChristoph Hellwig xfs_iext_get_extent(ifp, lastx, &got); 542130f712c9SDave Chinner continue; 542230f712c9SDave Chinner } else if (del.br_state == XFS_EXT_UNWRITTEN) { 54237efc7945SChristoph Hellwig struct xfs_bmbt_irec prev; 54247efc7945SChristoph Hellwig 542530f712c9SDave Chinner /* 542630f712c9SDave Chinner * This one is already unwritten. 542730f712c9SDave Chinner * It must have a written left neighbor. 542830f712c9SDave Chinner * Unwrite the killed part of that one and 542930f712c9SDave Chinner * try again. 543030f712c9SDave Chinner */ 543130f712c9SDave Chinner ASSERT(lastx > 0); 54327efc7945SChristoph Hellwig xfs_iext_get_extent(ifp, lastx - 1, &prev); 543330f712c9SDave Chinner ASSERT(prev.br_state == XFS_EXT_NORM); 543430f712c9SDave Chinner ASSERT(!isnullstartblock(prev.br_startblock)); 543530f712c9SDave Chinner ASSERT(del.br_startblock == 543630f712c9SDave Chinner prev.br_startblock + prev.br_blockcount); 543730f712c9SDave Chinner if (prev.br_startoff < start) { 543830f712c9SDave Chinner mod = start - prev.br_startoff; 543930f712c9SDave Chinner prev.br_blockcount -= mod; 544030f712c9SDave Chinner prev.br_startblock += mod; 544130f712c9SDave Chinner prev.br_startoff = start; 544230f712c9SDave Chinner } 544330f712c9SDave Chinner prev.br_state = XFS_EXT_UNWRITTEN; 544430f712c9SDave Chinner lastx--; 544530f712c9SDave Chinner error = xfs_bmap_add_extent_unwritten_real(tp, 544605a630d7SDarrick J. Wong ip, whichfork, &lastx, &cur, 544705a630d7SDarrick J. Wong &prev, firstblock, dfops, 544805a630d7SDarrick J. Wong &logflags); 544930f712c9SDave Chinner if (error) 545030f712c9SDave Chinner goto error0; 545130f712c9SDave Chinner goto nodelete; 545230f712c9SDave Chinner } else { 545330f712c9SDave Chinner ASSERT(del.br_state == XFS_EXT_NORM); 545430f712c9SDave Chinner del.br_state = XFS_EXT_UNWRITTEN; 545530f712c9SDave Chinner error = xfs_bmap_add_extent_unwritten_real(tp, 545605a630d7SDarrick J. Wong ip, whichfork, &lastx, &cur, 545705a630d7SDarrick J. Wong &del, firstblock, dfops, 545805a630d7SDarrick J. Wong &logflags); 545930f712c9SDave Chinner if (error) 546030f712c9SDave Chinner goto error0; 546130f712c9SDave Chinner goto nodelete; 546230f712c9SDave Chinner } 546330f712c9SDave Chinner } 546430f712c9SDave Chinner 5465e1d7553fSChristoph Hellwig if (wasdel) { 5466e1d7553fSChristoph Hellwig error = xfs_bmap_del_extent_delay(ip, whichfork, &lastx, 5467e1d7553fSChristoph Hellwig &got, &del); 5468e1d7553fSChristoph Hellwig } else { 5469e1d7553fSChristoph Hellwig error = xfs_bmap_del_extent_real(ip, tp, &lastx, dfops, 5470e1d7553fSChristoph Hellwig cur, &del, &tmp_logflags, whichfork, 5471e1d7553fSChristoph Hellwig flags); 547230f712c9SDave Chinner logflags |= tmp_logflags; 5473e1d7553fSChristoph Hellwig } 5474e1d7553fSChristoph Hellwig 547530f712c9SDave Chinner if (error) 547630f712c9SDave Chinner goto error0; 5477b2706a05SBrian Foster 5478e1a4e37cSDarrick J. Wong max_len -= del.br_blockcount; 54798280f6edSChristoph Hellwig end = del.br_startoff - 1; 548030f712c9SDave Chinner nodelete: 548130f712c9SDave Chinner /* 548230f712c9SDave Chinner * If not done go on to the next (previous) record. 548330f712c9SDave Chinner */ 54848280f6edSChristoph Hellwig if (end != (xfs_fileoff_t)-1 && end >= start) { 548530f712c9SDave Chinner if (lastx >= 0) { 54867efc7945SChristoph Hellwig xfs_iext_get_extent(ifp, lastx, &got); 54878280f6edSChristoph Hellwig if (got.br_startoff > end && --lastx >= 0) 54887efc7945SChristoph Hellwig xfs_iext_get_extent(ifp, lastx, &got); 548930f712c9SDave Chinner } 549030f712c9SDave Chinner extno++; 549130f712c9SDave Chinner } 549230f712c9SDave Chinner } 54938280f6edSChristoph Hellwig if (end == (xfs_fileoff_t)-1 || end < start || lastx < 0) 54944453593bSDarrick J. Wong *rlen = 0; 54954453593bSDarrick J. Wong else 54968280f6edSChristoph Hellwig *rlen = end - start + 1; 549730f712c9SDave Chinner 549830f712c9SDave Chinner /* 549930f712c9SDave Chinner * Convert to a btree if necessary. 550030f712c9SDave Chinner */ 550130f712c9SDave Chinner if (xfs_bmap_needs_btree(ip, whichfork)) { 550230f712c9SDave Chinner ASSERT(cur == NULL); 55032c3234d1SDarrick J. Wong error = xfs_bmap_extents_to_btree(tp, ip, firstblock, dfops, 550430f712c9SDave Chinner &cur, 0, &tmp_logflags, whichfork); 550530f712c9SDave Chinner logflags |= tmp_logflags; 550630f712c9SDave Chinner if (error) 550730f712c9SDave Chinner goto error0; 550830f712c9SDave Chinner } 550930f712c9SDave Chinner /* 551030f712c9SDave Chinner * transform from btree to extents, give it cur 551130f712c9SDave Chinner */ 551230f712c9SDave Chinner else if (xfs_bmap_wants_extents(ip, whichfork)) { 551330f712c9SDave Chinner ASSERT(cur != NULL); 551430f712c9SDave Chinner error = xfs_bmap_btree_to_extents(tp, ip, cur, &tmp_logflags, 551530f712c9SDave Chinner whichfork); 551630f712c9SDave Chinner logflags |= tmp_logflags; 551730f712c9SDave Chinner if (error) 551830f712c9SDave Chinner goto error0; 551930f712c9SDave Chinner } 552030f712c9SDave Chinner /* 552130f712c9SDave Chinner * transform from extents to local? 552230f712c9SDave Chinner */ 552330f712c9SDave Chinner error = 0; 552430f712c9SDave Chinner error0: 552530f712c9SDave Chinner /* 552630f712c9SDave Chinner * Log everything. Do this after conversion, there's no point in 552730f712c9SDave Chinner * logging the extent records if we've converted to btree format. 552830f712c9SDave Chinner */ 552930f712c9SDave Chinner if ((logflags & xfs_ilog_fext(whichfork)) && 553030f712c9SDave Chinner XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS) 553130f712c9SDave Chinner logflags &= ~xfs_ilog_fext(whichfork); 553230f712c9SDave Chinner else if ((logflags & xfs_ilog_fbroot(whichfork)) && 553330f712c9SDave Chinner XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE) 553430f712c9SDave Chinner logflags &= ~xfs_ilog_fbroot(whichfork); 553530f712c9SDave Chinner /* 553630f712c9SDave Chinner * Log inode even in the error case, if the transaction 553730f712c9SDave Chinner * is dirty we'll need to shut down the filesystem. 553830f712c9SDave Chinner */ 553930f712c9SDave Chinner if (logflags) 554030f712c9SDave Chinner xfs_trans_log_inode(tp, ip, logflags); 554130f712c9SDave Chinner if (cur) { 554230f712c9SDave Chinner if (!error) { 554330f712c9SDave Chinner *firstblock = cur->bc_private.b.firstblock; 554430f712c9SDave Chinner cur->bc_private.b.allocated = 0; 554530f712c9SDave Chinner } 554630f712c9SDave Chinner xfs_btree_del_cursor(cur, 554730f712c9SDave Chinner error ? XFS_BTREE_ERROR : XFS_BTREE_NOERROR); 554830f712c9SDave Chinner } 554930f712c9SDave Chinner return error; 555030f712c9SDave Chinner } 555130f712c9SDave Chinner 55524453593bSDarrick J. Wong /* Unmap a range of a file. */ 55534453593bSDarrick J. Wong int 55544453593bSDarrick J. Wong xfs_bunmapi( 55554453593bSDarrick J. Wong xfs_trans_t *tp, 55564453593bSDarrick J. Wong struct xfs_inode *ip, 55574453593bSDarrick J. Wong xfs_fileoff_t bno, 55584453593bSDarrick J. Wong xfs_filblks_t len, 55594453593bSDarrick J. Wong int flags, 55604453593bSDarrick J. Wong xfs_extnum_t nexts, 55614453593bSDarrick J. Wong xfs_fsblock_t *firstblock, 55624453593bSDarrick J. Wong struct xfs_defer_ops *dfops, 55634453593bSDarrick J. Wong int *done) 55644453593bSDarrick J. Wong { 55654453593bSDarrick J. Wong int error; 55664453593bSDarrick J. Wong 55674453593bSDarrick J. Wong error = __xfs_bunmapi(tp, ip, bno, &len, flags, nexts, firstblock, 55684453593bSDarrick J. Wong dfops); 55694453593bSDarrick J. Wong *done = (len == 0); 55704453593bSDarrick J. Wong return error; 55714453593bSDarrick J. Wong } 55724453593bSDarrick J. Wong 557330f712c9SDave Chinner /* 5574ddb19e31SBrian Foster * Determine whether an extent shift can be accomplished by a merge with the 5575ddb19e31SBrian Foster * extent that precedes the target hole of the shift. 5576ddb19e31SBrian Foster */ 5577ddb19e31SBrian Foster STATIC bool 5578ddb19e31SBrian Foster xfs_bmse_can_merge( 5579ddb19e31SBrian Foster struct xfs_bmbt_irec *left, /* preceding extent */ 5580ddb19e31SBrian Foster struct xfs_bmbt_irec *got, /* current extent to shift */ 5581ddb19e31SBrian Foster xfs_fileoff_t shift) /* shift fsb */ 5582ddb19e31SBrian Foster { 5583ddb19e31SBrian Foster xfs_fileoff_t startoff; 5584ddb19e31SBrian Foster 5585ddb19e31SBrian Foster startoff = got->br_startoff - shift; 5586ddb19e31SBrian Foster 5587ddb19e31SBrian Foster /* 5588ddb19e31SBrian Foster * The extent, once shifted, must be adjacent in-file and on-disk with 5589ddb19e31SBrian Foster * the preceding extent. 5590ddb19e31SBrian Foster */ 5591ddb19e31SBrian Foster if ((left->br_startoff + left->br_blockcount != startoff) || 5592ddb19e31SBrian Foster (left->br_startblock + left->br_blockcount != got->br_startblock) || 5593ddb19e31SBrian Foster (left->br_state != got->br_state) || 5594ddb19e31SBrian Foster (left->br_blockcount + got->br_blockcount > MAXEXTLEN)) 5595ddb19e31SBrian Foster return false; 5596ddb19e31SBrian Foster 5597ddb19e31SBrian Foster return true; 5598ddb19e31SBrian Foster } 5599ddb19e31SBrian Foster 5600ddb19e31SBrian Foster /* 5601ddb19e31SBrian Foster * A bmap extent shift adjusts the file offset of an extent to fill a preceding 5602ddb19e31SBrian Foster * hole in the file. If an extent shift would result in the extent being fully 5603ddb19e31SBrian Foster * adjacent to the extent that currently precedes the hole, we can merge with 5604ddb19e31SBrian Foster * the preceding extent rather than do the shift. 5605ddb19e31SBrian Foster * 5606ddb19e31SBrian Foster * This function assumes the caller has verified a shift-by-merge is possible 5607ddb19e31SBrian Foster * with the provided extents via xfs_bmse_can_merge(). 5608ddb19e31SBrian Foster */ 5609ddb19e31SBrian Foster STATIC int 5610ddb19e31SBrian Foster xfs_bmse_merge( 5611ddb19e31SBrian Foster struct xfs_inode *ip, 5612ddb19e31SBrian Foster int whichfork, 5613ddb19e31SBrian Foster xfs_fileoff_t shift, /* shift fsb */ 5614ddb19e31SBrian Foster int current_ext, /* idx of gotp */ 56154da6b514SChristoph Hellwig struct xfs_bmbt_irec *got, /* extent to shift */ 56164da6b514SChristoph Hellwig struct xfs_bmbt_irec *left, /* preceding extent */ 5617ddb19e31SBrian Foster struct xfs_btree_cur *cur, 56184da6b514SChristoph Hellwig int *logflags, /* output */ 56194da6b514SChristoph Hellwig struct xfs_defer_ops *dfops) 5620ddb19e31SBrian Foster { 56214da6b514SChristoph Hellwig struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, whichfork); 56224da6b514SChristoph Hellwig struct xfs_bmbt_irec new; 5623ddb19e31SBrian Foster xfs_filblks_t blockcount; 5624ddb19e31SBrian Foster int error, i; 56255fb5aeeeSEric Sandeen struct xfs_mount *mp = ip->i_mount; 5626ddb19e31SBrian Foster 56274da6b514SChristoph Hellwig blockcount = left->br_blockcount + got->br_blockcount; 5628ddb19e31SBrian Foster 5629ddb19e31SBrian Foster ASSERT(xfs_isilocked(ip, XFS_IOLOCK_EXCL)); 5630ddb19e31SBrian Foster ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL)); 56314da6b514SChristoph Hellwig ASSERT(xfs_bmse_can_merge(left, got, shift)); 5632ddb19e31SBrian Foster 56334da6b514SChristoph Hellwig new = *left; 56344da6b514SChristoph Hellwig new.br_blockcount = blockcount; 5635ddb19e31SBrian Foster 5636ddb19e31SBrian Foster /* 5637ddb19e31SBrian Foster * Update the on-disk extent count, the btree if necessary and log the 5638ddb19e31SBrian Foster * inode. 5639ddb19e31SBrian Foster */ 5640ddb19e31SBrian Foster XFS_IFORK_NEXT_SET(ip, whichfork, 5641ddb19e31SBrian Foster XFS_IFORK_NEXTENTS(ip, whichfork) - 1); 5642ddb19e31SBrian Foster *logflags |= XFS_ILOG_CORE; 5643ddb19e31SBrian Foster if (!cur) { 5644ddb19e31SBrian Foster *logflags |= XFS_ILOG_DEXT; 56454da6b514SChristoph Hellwig goto done; 5646ddb19e31SBrian Foster } 5647ddb19e31SBrian Foster 5648ddb19e31SBrian Foster /* lookup and remove the extent to merge */ 5649e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(cur, got, &i); 5650ddb19e31SBrian Foster if (error) 56514db431f5SDave Chinner return error; 56525fb5aeeeSEric Sandeen XFS_WANT_CORRUPTED_RETURN(mp, i == 1); 5653ddb19e31SBrian Foster 5654ddb19e31SBrian Foster error = xfs_btree_delete(cur, &i); 5655ddb19e31SBrian Foster if (error) 56564db431f5SDave Chinner return error; 56575fb5aeeeSEric Sandeen XFS_WANT_CORRUPTED_RETURN(mp, i == 1); 5658ddb19e31SBrian Foster 5659ddb19e31SBrian Foster /* lookup and update size of the previous extent */ 5660e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(cur, left, &i); 5661ddb19e31SBrian Foster if (error) 56624db431f5SDave Chinner return error; 56635fb5aeeeSEric Sandeen XFS_WANT_CORRUPTED_RETURN(mp, i == 1); 5664ddb19e31SBrian Foster 5665a67d00a5SChristoph Hellwig error = xfs_bmbt_update(cur, &new); 56664da6b514SChristoph Hellwig if (error) 56674da6b514SChristoph Hellwig return error; 5668ddb19e31SBrian Foster 56694da6b514SChristoph Hellwig done: 56704da6b514SChristoph Hellwig xfs_iext_update_extent(ifp, current_ext - 1, &new); 56714da6b514SChristoph Hellwig xfs_iext_remove(ip, current_ext, 1, 0); 56724da6b514SChristoph Hellwig 56734cc1ee5eSDarrick J. Wong /* update reverse mapping. rmap functions merge the rmaps for us */ 56744da6b514SChristoph Hellwig error = xfs_rmap_unmap_extent(mp, dfops, ip, whichfork, got); 56754da6b514SChristoph Hellwig if (error) 56764da6b514SChristoph Hellwig return error; 56774cc1ee5eSDarrick J. Wong memcpy(&new, got, sizeof(new)); 56784cc1ee5eSDarrick J. Wong new.br_startoff = left->br_startoff + left->br_blockcount; 56794da6b514SChristoph Hellwig return xfs_rmap_map_extent(mp, dfops, ip, whichfork, &new); 5680ddb19e31SBrian Foster } 5681ddb19e31SBrian Foster 5682ddb19e31SBrian Foster /* 5683a979bdfeSBrian Foster * Shift a single extent. 5684a979bdfeSBrian Foster */ 5685a979bdfeSBrian Foster STATIC int 5686a979bdfeSBrian Foster xfs_bmse_shift_one( 5687a979bdfeSBrian Foster struct xfs_inode *ip, 5688a979bdfeSBrian Foster int whichfork, 5689a979bdfeSBrian Foster xfs_fileoff_t offset_shift_fsb, 5690a979bdfeSBrian Foster int *current_ext, 56914da6b514SChristoph Hellwig struct xfs_bmbt_irec *got, 5692a979bdfeSBrian Foster struct xfs_btree_cur *cur, 5693a904b1caSNamjae Jeon int *logflags, 56949c194644SDarrick J. Wong enum shift_direction direction, 56959c194644SDarrick J. Wong struct xfs_defer_ops *dfops) 5696a979bdfeSBrian Foster { 5697a979bdfeSBrian Foster struct xfs_ifork *ifp; 56985fb5aeeeSEric Sandeen struct xfs_mount *mp; 5699a979bdfeSBrian Foster xfs_fileoff_t startoff; 57004da6b514SChristoph Hellwig struct xfs_bmbt_irec adj_irec, new; 5701a979bdfeSBrian Foster int error; 5702a979bdfeSBrian Foster int i; 5703a904b1caSNamjae Jeon int total_extents; 5704a979bdfeSBrian Foster 57055fb5aeeeSEric Sandeen mp = ip->i_mount; 5706a979bdfeSBrian Foster ifp = XFS_IFORK_PTR(ip, whichfork); 57075d829300SEric Sandeen total_extents = xfs_iext_count(ifp); 5708a979bdfeSBrian Foster 5709f71721d0SBrian Foster /* delalloc extents should be prevented by caller */ 57104da6b514SChristoph Hellwig XFS_WANT_CORRUPTED_RETURN(mp, !isnullstartblock(got->br_startblock)); 5711f71721d0SBrian Foster 5712a904b1caSNamjae Jeon if (direction == SHIFT_LEFT) { 57134da6b514SChristoph Hellwig startoff = got->br_startoff - offset_shift_fsb; 5714a979bdfeSBrian Foster 5715a904b1caSNamjae Jeon /* 5716a904b1caSNamjae Jeon * Check for merge if we've got an extent to the left, 5717a904b1caSNamjae Jeon * otherwise make sure there's enough room at the start 5718a904b1caSNamjae Jeon * of the file for the shift. 5719a904b1caSNamjae Jeon */ 5720a904b1caSNamjae Jeon if (!*current_ext) { 57214da6b514SChristoph Hellwig if (got->br_startoff < offset_shift_fsb) 5722a904b1caSNamjae Jeon return -EINVAL; 5723a904b1caSNamjae Jeon goto update_current_ext; 5724a904b1caSNamjae Jeon } 5725a904b1caSNamjae Jeon 57264da6b514SChristoph Hellwig /* 57274da6b514SChristoph Hellwig * grab the left extent and check for a large enough hole. 57284da6b514SChristoph Hellwig */ 57294da6b514SChristoph Hellwig xfs_iext_get_extent(ifp, *current_ext - 1, &adj_irec); 57304da6b514SChristoph Hellwig if (startoff < adj_irec.br_startoff + adj_irec.br_blockcount) 5731a979bdfeSBrian Foster return -EINVAL; 5732a979bdfeSBrian Foster 5733a979bdfeSBrian Foster /* check whether to merge the extent or shift it down */ 57344da6b514SChristoph Hellwig if (xfs_bmse_can_merge(&adj_irec, got, offset_shift_fsb)) { 57354da6b514SChristoph Hellwig return xfs_bmse_merge(ip, whichfork, offset_shift_fsb, 57364da6b514SChristoph Hellwig *current_ext, got, &adj_irec, 57374da6b514SChristoph Hellwig cur, logflags, dfops); 5738b11bd671SDave Chinner } 5739a904b1caSNamjae Jeon } else { 57404da6b514SChristoph Hellwig startoff = got->br_startoff + offset_shift_fsb; 5741a904b1caSNamjae Jeon /* nothing to move if this is the last extent */ 5742a904b1caSNamjae Jeon if (*current_ext >= (total_extents - 1)) 5743a904b1caSNamjae Jeon goto update_current_ext; 57444da6b514SChristoph Hellwig 5745a904b1caSNamjae Jeon /* 5746a904b1caSNamjae Jeon * If this is not the last extent in the file, make sure there 5747a904b1caSNamjae Jeon * is enough room between current extent and next extent for 5748a904b1caSNamjae Jeon * accommodating the shift. 5749a904b1caSNamjae Jeon */ 57504da6b514SChristoph Hellwig xfs_iext_get_extent(ifp, *current_ext + 1, &adj_irec); 57514da6b514SChristoph Hellwig if (startoff + got->br_blockcount > adj_irec.br_startoff) 5752b11bd671SDave Chinner return -EINVAL; 57534da6b514SChristoph Hellwig 5754a904b1caSNamjae Jeon /* 5755a904b1caSNamjae Jeon * Unlike a left shift (which involves a hole punch), 5756a904b1caSNamjae Jeon * a right shift does not modify extent neighbors 5757a904b1caSNamjae Jeon * in any way. We should never find mergeable extents 5758a904b1caSNamjae Jeon * in this scenario. Check anyways and warn if we 5759a904b1caSNamjae Jeon * encounter two extents that could be one. 5760a904b1caSNamjae Jeon */ 57614da6b514SChristoph Hellwig if (xfs_bmse_can_merge(got, &adj_irec, offset_shift_fsb)) 5762a904b1caSNamjae Jeon WARN_ON_ONCE(1); 5763a904b1caSNamjae Jeon } 57644da6b514SChristoph Hellwig 5765a979bdfeSBrian Foster /* 5766a979bdfeSBrian Foster * Increment the extent index for the next iteration, update the start 5767a979bdfeSBrian Foster * offset of the in-core extent and update the btree if applicable. 5768a979bdfeSBrian Foster */ 5769a904b1caSNamjae Jeon update_current_ext: 5770a979bdfeSBrian Foster *logflags |= XFS_ILOG_CORE; 5771a979bdfeSBrian Foster 57724da6b514SChristoph Hellwig new = *got; 57734da6b514SChristoph Hellwig new.br_startoff = startoff; 57744da6b514SChristoph Hellwig 57754da6b514SChristoph Hellwig if (cur) { 5776e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(cur, got, &i); 5777a979bdfeSBrian Foster if (error) 5778a979bdfeSBrian Foster return error; 57795fb5aeeeSEric Sandeen XFS_WANT_CORRUPTED_RETURN(mp, i == 1); 5780a979bdfeSBrian Foster 5781a67d00a5SChristoph Hellwig error = xfs_bmbt_update(cur, &new); 57829c194644SDarrick J. Wong if (error) 57839c194644SDarrick J. Wong return error; 57844da6b514SChristoph Hellwig } else { 57854da6b514SChristoph Hellwig *logflags |= XFS_ILOG_DEXT; 57864da6b514SChristoph Hellwig } 57879c194644SDarrick J. Wong 57884da6b514SChristoph Hellwig xfs_iext_update_extent(ifp, *current_ext, &new); 57894da6b514SChristoph Hellwig 57904da6b514SChristoph Hellwig if (direction == SHIFT_LEFT) 57914da6b514SChristoph Hellwig (*current_ext)++; 57924da6b514SChristoph Hellwig else 57934da6b514SChristoph Hellwig (*current_ext)--; 57944da6b514SChristoph Hellwig 57959c194644SDarrick J. Wong /* update reverse mapping */ 57964da6b514SChristoph Hellwig error = xfs_rmap_unmap_extent(mp, dfops, ip, whichfork, got); 57979c194644SDarrick J. Wong if (error) 57989c194644SDarrick J. Wong return error; 57994da6b514SChristoph Hellwig return xfs_rmap_map_extent(mp, dfops, ip, whichfork, &new); 5800a979bdfeSBrian Foster } 5801a979bdfeSBrian Foster 5802a979bdfeSBrian Foster /* 5803a904b1caSNamjae Jeon * Shift extent records to the left/right to cover/create a hole. 580430f712c9SDave Chinner * 58052c845f5aSBrian Foster * The maximum number of extents to be shifted in a single operation is 5806a904b1caSNamjae Jeon * @num_exts. @stop_fsb specifies the file offset at which to stop shift and the 58072c845f5aSBrian Foster * file offset where we've left off is returned in @next_fsb. @offset_shift_fsb 58082c845f5aSBrian Foster * is the length by which each extent is shifted. If there is no hole to shift 58092c845f5aSBrian Foster * the extents into, this will be considered invalid operation and we abort 58102c845f5aSBrian Foster * immediately. 581130f712c9SDave Chinner */ 581230f712c9SDave Chinner int 581330f712c9SDave Chinner xfs_bmap_shift_extents( 581430f712c9SDave Chinner struct xfs_trans *tp, 581530f712c9SDave Chinner struct xfs_inode *ip, 5816a904b1caSNamjae Jeon xfs_fileoff_t *next_fsb, 581730f712c9SDave Chinner xfs_fileoff_t offset_shift_fsb, 58182c845f5aSBrian Foster int *done, 5819a904b1caSNamjae Jeon xfs_fileoff_t stop_fsb, 582030f712c9SDave Chinner xfs_fsblock_t *firstblock, 58212c3234d1SDarrick J. Wong struct xfs_defer_ops *dfops, 5822a904b1caSNamjae Jeon enum shift_direction direction, 582330f712c9SDave Chinner int num_exts) 582430f712c9SDave Chinner { 5825ca446d88SBrian Foster struct xfs_btree_cur *cur = NULL; 582630f712c9SDave Chinner struct xfs_bmbt_irec got; 582730f712c9SDave Chinner struct xfs_mount *mp = ip->i_mount; 582830f712c9SDave Chinner struct xfs_ifork *ifp; 582930f712c9SDave Chinner xfs_extnum_t nexts = 0; 58302c845f5aSBrian Foster xfs_extnum_t current_ext; 5831a904b1caSNamjae Jeon xfs_extnum_t total_extents; 5832a904b1caSNamjae Jeon xfs_extnum_t stop_extent; 583330f712c9SDave Chinner int error = 0; 583430f712c9SDave Chinner int whichfork = XFS_DATA_FORK; 5835ca446d88SBrian Foster int logflags = 0; 583630f712c9SDave Chinner 583730f712c9SDave Chinner if (unlikely(XFS_TEST_ERROR( 583830f712c9SDave Chinner (XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS && 583930f712c9SDave Chinner XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE), 58409e24cfd0SDarrick J. Wong mp, XFS_ERRTAG_BMAPIFORMAT))) { 584130f712c9SDave Chinner XFS_ERROR_REPORT("xfs_bmap_shift_extents", 584230f712c9SDave Chinner XFS_ERRLEVEL_LOW, mp); 58432451337dSDave Chinner return -EFSCORRUPTED; 584430f712c9SDave Chinner } 584530f712c9SDave Chinner 584630f712c9SDave Chinner if (XFS_FORCED_SHUTDOWN(mp)) 58472451337dSDave Chinner return -EIO; 584830f712c9SDave Chinner 58492c845f5aSBrian Foster ASSERT(xfs_isilocked(ip, XFS_IOLOCK_EXCL)); 58502c845f5aSBrian Foster ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL)); 5851a904b1caSNamjae Jeon ASSERT(direction == SHIFT_LEFT || direction == SHIFT_RIGHT); 585230f712c9SDave Chinner 585330f712c9SDave Chinner ifp = XFS_IFORK_PTR(ip, whichfork); 585430f712c9SDave Chinner if (!(ifp->if_flags & XFS_IFEXTENTS)) { 585530f712c9SDave Chinner /* Read in all the extents */ 585630f712c9SDave Chinner error = xfs_iread_extents(tp, ip, whichfork); 585730f712c9SDave Chinner if (error) 585830f712c9SDave Chinner return error; 585930f712c9SDave Chinner } 586030f712c9SDave Chinner 5861ddb19e31SBrian Foster if (ifp->if_flags & XFS_IFBROOT) { 5862ddb19e31SBrian Foster cur = xfs_bmbt_init_cursor(mp, tp, ip, whichfork); 5863ddb19e31SBrian Foster cur->bc_private.b.firstblock = *firstblock; 58642c3234d1SDarrick J. Wong cur->bc_private.b.dfops = dfops; 5865ddb19e31SBrian Foster cur->bc_private.b.flags = 0; 5866ddb19e31SBrian Foster } 5867ddb19e31SBrian Foster 586830f712c9SDave Chinner /* 586930f712c9SDave Chinner * There may be delalloc extents in the data fork before the range we 58702c845f5aSBrian Foster * are collapsing out, so we cannot use the count of real extents here. 58712c845f5aSBrian Foster * Instead we have to calculate it from the incore fork. 587230f712c9SDave Chinner */ 58735d829300SEric Sandeen total_extents = xfs_iext_count(ifp); 5874a904b1caSNamjae Jeon if (total_extents == 0) { 5875a904b1caSNamjae Jeon *done = 1; 5876a904b1caSNamjae Jeon goto del_cursor; 5877a904b1caSNamjae Jeon } 5878a904b1caSNamjae Jeon 5879a904b1caSNamjae Jeon /* 5880a904b1caSNamjae Jeon * In case of first right shift, we need to initialize next_fsb 5881a904b1caSNamjae Jeon */ 5882a904b1caSNamjae Jeon if (*next_fsb == NULLFSBLOCK) { 588305b7c8abSChristoph Hellwig ASSERT(direction == SHIFT_RIGHT); 588405b7c8abSChristoph Hellwig 588505b7c8abSChristoph Hellwig current_ext = total_extents - 1; 58864da6b514SChristoph Hellwig xfs_iext_get_extent(ifp, current_ext, &got); 58874da6b514SChristoph Hellwig if (stop_fsb > got.br_startoff) { 5888a904b1caSNamjae Jeon *done = 1; 5889a904b1caSNamjae Jeon goto del_cursor; 5890a904b1caSNamjae Jeon } 58914da6b514SChristoph Hellwig *next_fsb = got.br_startoff; 589205b7c8abSChristoph Hellwig } else { 5893a904b1caSNamjae Jeon /* 5894a904b1caSNamjae Jeon * Look up the extent index for the fsb where we start shifting. We can 5895a904b1caSNamjae Jeon * henceforth iterate with current_ext as extent list changes are locked 5896a904b1caSNamjae Jeon * out via ilock. 5897a904b1caSNamjae Jeon * 58984da6b514SChristoph Hellwig * If next_fsb lies in a hole beyond which there are no extents we are 58994da6b514SChristoph Hellwig * done. 5900a904b1caSNamjae Jeon */ 59014da6b514SChristoph Hellwig if (!xfs_iext_lookup_extent(ip, ifp, *next_fsb, ¤t_ext, 59024da6b514SChristoph Hellwig &got)) { 5903a904b1caSNamjae Jeon *done = 1; 5904a904b1caSNamjae Jeon goto del_cursor; 5905a904b1caSNamjae Jeon } 590605b7c8abSChristoph Hellwig } 5907a904b1caSNamjae Jeon 590805b7c8abSChristoph Hellwig /* Lookup the extent index at which we have to stop */ 590905b7c8abSChristoph Hellwig if (direction == SHIFT_RIGHT) { 59104da6b514SChristoph Hellwig struct xfs_bmbt_irec s; 59114da6b514SChristoph Hellwig 59124da6b514SChristoph Hellwig xfs_iext_lookup_extent(ip, ifp, stop_fsb, &stop_extent, &s); 591305b7c8abSChristoph Hellwig /* Make stop_extent exclusive of shift range */ 591405b7c8abSChristoph Hellwig stop_extent--; 591505b7c8abSChristoph Hellwig if (current_ext <= stop_extent) { 5916a904b1caSNamjae Jeon error = -EIO; 5917a904b1caSNamjae Jeon goto del_cursor; 5918a904b1caSNamjae Jeon } 591905b7c8abSChristoph Hellwig } else { 592005b7c8abSChristoph Hellwig stop_extent = total_extents; 592105b7c8abSChristoph Hellwig if (current_ext >= stop_extent) { 592205b7c8abSChristoph Hellwig error = -EIO; 592305b7c8abSChristoph Hellwig goto del_cursor; 592405b7c8abSChristoph Hellwig } 592505b7c8abSChristoph Hellwig } 5926a904b1caSNamjae Jeon 5927a904b1caSNamjae Jeon while (nexts++ < num_exts) { 5928a979bdfeSBrian Foster error = xfs_bmse_shift_one(ip, whichfork, offset_shift_fsb, 59294da6b514SChristoph Hellwig ¤t_ext, &got, cur, &logflags, 59309c194644SDarrick J. Wong direction, dfops); 5931ddb19e31SBrian Foster if (error) 5932ddb19e31SBrian Foster goto del_cursor; 5933a904b1caSNamjae Jeon /* 5934a904b1caSNamjae Jeon * If there was an extent merge during the shift, the extent 5935a904b1caSNamjae Jeon * count can change. Update the total and grade the next record. 5936a904b1caSNamjae Jeon */ 5937a904b1caSNamjae Jeon if (direction == SHIFT_LEFT) { 59385d829300SEric Sandeen total_extents = xfs_iext_count(ifp); 5939a904b1caSNamjae Jeon stop_extent = total_extents; 5940a904b1caSNamjae Jeon } 5941a904b1caSNamjae Jeon 5942a904b1caSNamjae Jeon if (current_ext == stop_extent) { 5943a904b1caSNamjae Jeon *done = 1; 5944a904b1caSNamjae Jeon *next_fsb = NULLFSBLOCK; 5945ddb19e31SBrian Foster break; 5946a904b1caSNamjae Jeon } 59474da6b514SChristoph Hellwig xfs_iext_get_extent(ifp, current_ext, &got); 594830f712c9SDave Chinner } 594930f712c9SDave Chinner 59504da6b514SChristoph Hellwig if (!*done) 59512c845f5aSBrian Foster *next_fsb = got.br_startoff; 595230f712c9SDave Chinner 595330f712c9SDave Chinner del_cursor: 595430f712c9SDave Chinner if (cur) 595530f712c9SDave Chinner xfs_btree_del_cursor(cur, 595630f712c9SDave Chinner error ? XFS_BTREE_ERROR : XFS_BTREE_NOERROR); 595730f712c9SDave Chinner 5958ca446d88SBrian Foster if (logflags) 595930f712c9SDave Chinner xfs_trans_log_inode(tp, ip, logflags); 59602c845f5aSBrian Foster 596130f712c9SDave Chinner return error; 596230f712c9SDave Chinner } 5963a904b1caSNamjae Jeon 5964a904b1caSNamjae Jeon /* 5965a904b1caSNamjae Jeon * Splits an extent into two extents at split_fsb block such that it is 5966a904b1caSNamjae Jeon * the first block of the current_ext. @current_ext is a target extent 5967a904b1caSNamjae Jeon * to be split. @split_fsb is a block where the extents is split. 5968a904b1caSNamjae Jeon * If split_fsb lies in a hole or the first block of extents, just return 0. 5969a904b1caSNamjae Jeon */ 5970a904b1caSNamjae Jeon STATIC int 5971a904b1caSNamjae Jeon xfs_bmap_split_extent_at( 5972a904b1caSNamjae Jeon struct xfs_trans *tp, 5973a904b1caSNamjae Jeon struct xfs_inode *ip, 5974a904b1caSNamjae Jeon xfs_fileoff_t split_fsb, 5975a904b1caSNamjae Jeon xfs_fsblock_t *firstfsb, 59762c3234d1SDarrick J. Wong struct xfs_defer_ops *dfops) 5977a904b1caSNamjae Jeon { 5978a904b1caSNamjae Jeon int whichfork = XFS_DATA_FORK; 5979a904b1caSNamjae Jeon struct xfs_btree_cur *cur = NULL; 5980a904b1caSNamjae Jeon struct xfs_bmbt_irec got; 5981a904b1caSNamjae Jeon struct xfs_bmbt_irec new; /* split extent */ 5982a904b1caSNamjae Jeon struct xfs_mount *mp = ip->i_mount; 5983a904b1caSNamjae Jeon struct xfs_ifork *ifp; 5984a904b1caSNamjae Jeon xfs_fsblock_t gotblkcnt; /* new block count for got */ 5985a904b1caSNamjae Jeon xfs_extnum_t current_ext; 5986a904b1caSNamjae Jeon int error = 0; 5987a904b1caSNamjae Jeon int logflags = 0; 5988a904b1caSNamjae Jeon int i = 0; 5989a904b1caSNamjae Jeon 5990a904b1caSNamjae Jeon if (unlikely(XFS_TEST_ERROR( 5991a904b1caSNamjae Jeon (XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS && 5992a904b1caSNamjae Jeon XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE), 59939e24cfd0SDarrick J. Wong mp, XFS_ERRTAG_BMAPIFORMAT))) { 5994a904b1caSNamjae Jeon XFS_ERROR_REPORT("xfs_bmap_split_extent_at", 5995a904b1caSNamjae Jeon XFS_ERRLEVEL_LOW, mp); 5996a904b1caSNamjae Jeon return -EFSCORRUPTED; 5997a904b1caSNamjae Jeon } 5998a904b1caSNamjae Jeon 5999a904b1caSNamjae Jeon if (XFS_FORCED_SHUTDOWN(mp)) 6000a904b1caSNamjae Jeon return -EIO; 6001a904b1caSNamjae Jeon 6002a904b1caSNamjae Jeon ifp = XFS_IFORK_PTR(ip, whichfork); 6003a904b1caSNamjae Jeon if (!(ifp->if_flags & XFS_IFEXTENTS)) { 6004a904b1caSNamjae Jeon /* Read in all the extents */ 6005a904b1caSNamjae Jeon error = xfs_iread_extents(tp, ip, whichfork); 6006a904b1caSNamjae Jeon if (error) 6007a904b1caSNamjae Jeon return error; 6008a904b1caSNamjae Jeon } 6009a904b1caSNamjae Jeon 6010a904b1caSNamjae Jeon /* 60114c35445bSChristoph Hellwig * If there are not extents, or split_fsb lies in a hole we are done. 6012a904b1caSNamjae Jeon */ 60134c35445bSChristoph Hellwig if (!xfs_iext_lookup_extent(ip, ifp, split_fsb, ¤t_ext, &got) || 60144c35445bSChristoph Hellwig got.br_startoff >= split_fsb) 6015a904b1caSNamjae Jeon return 0; 6016a904b1caSNamjae Jeon 6017a904b1caSNamjae Jeon gotblkcnt = split_fsb - got.br_startoff; 6018a904b1caSNamjae Jeon new.br_startoff = split_fsb; 6019a904b1caSNamjae Jeon new.br_startblock = got.br_startblock + gotblkcnt; 6020a904b1caSNamjae Jeon new.br_blockcount = got.br_blockcount - gotblkcnt; 6021a904b1caSNamjae Jeon new.br_state = got.br_state; 6022a904b1caSNamjae Jeon 6023a904b1caSNamjae Jeon if (ifp->if_flags & XFS_IFBROOT) { 6024a904b1caSNamjae Jeon cur = xfs_bmbt_init_cursor(mp, tp, ip, whichfork); 6025a904b1caSNamjae Jeon cur->bc_private.b.firstblock = *firstfsb; 60262c3234d1SDarrick J. Wong cur->bc_private.b.dfops = dfops; 6027a904b1caSNamjae Jeon cur->bc_private.b.flags = 0; 6028e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(cur, &got, &i); 6029a904b1caSNamjae Jeon if (error) 6030a904b1caSNamjae Jeon goto del_cursor; 6031a904b1caSNamjae Jeon XFS_WANT_CORRUPTED_GOTO(mp, i == 1, del_cursor); 6032a904b1caSNamjae Jeon } 6033a904b1caSNamjae Jeon 6034a904b1caSNamjae Jeon got.br_blockcount = gotblkcnt; 60354c35445bSChristoph Hellwig xfs_iext_update_extent(ifp, current_ext, &got); 6036a904b1caSNamjae Jeon 6037a904b1caSNamjae Jeon logflags = XFS_ILOG_CORE; 6038a904b1caSNamjae Jeon if (cur) { 6039a67d00a5SChristoph Hellwig error = xfs_bmbt_update(cur, &got); 6040a904b1caSNamjae Jeon if (error) 6041a904b1caSNamjae Jeon goto del_cursor; 6042a904b1caSNamjae Jeon } else 6043a904b1caSNamjae Jeon logflags |= XFS_ILOG_DEXT; 6044a904b1caSNamjae Jeon 6045a904b1caSNamjae Jeon /* Add new extent */ 6046a904b1caSNamjae Jeon current_ext++; 6047a904b1caSNamjae Jeon xfs_iext_insert(ip, current_ext, 1, &new, 0); 6048a904b1caSNamjae Jeon XFS_IFORK_NEXT_SET(ip, whichfork, 6049a904b1caSNamjae Jeon XFS_IFORK_NEXTENTS(ip, whichfork) + 1); 6050a904b1caSNamjae Jeon 6051a904b1caSNamjae Jeon if (cur) { 6052e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(cur, &new, &i); 6053a904b1caSNamjae Jeon if (error) 6054a904b1caSNamjae Jeon goto del_cursor; 6055a904b1caSNamjae Jeon XFS_WANT_CORRUPTED_GOTO(mp, i == 0, del_cursor); 6056a904b1caSNamjae Jeon error = xfs_btree_insert(cur, &i); 6057a904b1caSNamjae Jeon if (error) 6058a904b1caSNamjae Jeon goto del_cursor; 6059a904b1caSNamjae Jeon XFS_WANT_CORRUPTED_GOTO(mp, i == 1, del_cursor); 6060a904b1caSNamjae Jeon } 6061a904b1caSNamjae Jeon 6062a904b1caSNamjae Jeon /* 6063a904b1caSNamjae Jeon * Convert to a btree if necessary. 6064a904b1caSNamjae Jeon */ 6065a904b1caSNamjae Jeon if (xfs_bmap_needs_btree(ip, whichfork)) { 6066a904b1caSNamjae Jeon int tmp_logflags; /* partial log flag return val */ 6067a904b1caSNamjae Jeon 6068a904b1caSNamjae Jeon ASSERT(cur == NULL); 60692c3234d1SDarrick J. Wong error = xfs_bmap_extents_to_btree(tp, ip, firstfsb, dfops, 6070a904b1caSNamjae Jeon &cur, 0, &tmp_logflags, whichfork); 6071a904b1caSNamjae Jeon logflags |= tmp_logflags; 6072a904b1caSNamjae Jeon } 6073a904b1caSNamjae Jeon 6074a904b1caSNamjae Jeon del_cursor: 6075a904b1caSNamjae Jeon if (cur) { 6076a904b1caSNamjae Jeon cur->bc_private.b.allocated = 0; 6077a904b1caSNamjae Jeon xfs_btree_del_cursor(cur, 6078a904b1caSNamjae Jeon error ? XFS_BTREE_ERROR : XFS_BTREE_NOERROR); 6079a904b1caSNamjae Jeon } 6080a904b1caSNamjae Jeon 6081a904b1caSNamjae Jeon if (logflags) 6082a904b1caSNamjae Jeon xfs_trans_log_inode(tp, ip, logflags); 6083a904b1caSNamjae Jeon return error; 6084a904b1caSNamjae Jeon } 6085a904b1caSNamjae Jeon 6086a904b1caSNamjae Jeon int 6087a904b1caSNamjae Jeon xfs_bmap_split_extent( 6088a904b1caSNamjae Jeon struct xfs_inode *ip, 6089a904b1caSNamjae Jeon xfs_fileoff_t split_fsb) 6090a904b1caSNamjae Jeon { 6091a904b1caSNamjae Jeon struct xfs_mount *mp = ip->i_mount; 6092a904b1caSNamjae Jeon struct xfs_trans *tp; 60932c3234d1SDarrick J. Wong struct xfs_defer_ops dfops; 6094a904b1caSNamjae Jeon xfs_fsblock_t firstfsb; 6095a904b1caSNamjae Jeon int error; 6096a904b1caSNamjae Jeon 6097253f4911SChristoph Hellwig error = xfs_trans_alloc(mp, &M_RES(mp)->tr_write, 6098253f4911SChristoph Hellwig XFS_DIOSTRAT_SPACE_RES(mp, 0), 0, 0, &tp); 6099253f4911SChristoph Hellwig if (error) 6100a904b1caSNamjae Jeon return error; 6101a904b1caSNamjae Jeon 6102a904b1caSNamjae Jeon xfs_ilock(ip, XFS_ILOCK_EXCL); 6103a904b1caSNamjae Jeon xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL); 6104a904b1caSNamjae Jeon 61052c3234d1SDarrick J. Wong xfs_defer_init(&dfops, &firstfsb); 6106a904b1caSNamjae Jeon 6107a904b1caSNamjae Jeon error = xfs_bmap_split_extent_at(tp, ip, split_fsb, 61082c3234d1SDarrick J. Wong &firstfsb, &dfops); 6109a904b1caSNamjae Jeon if (error) 6110a904b1caSNamjae Jeon goto out; 6111a904b1caSNamjae Jeon 61128ad7c629SChristoph Hellwig error = xfs_defer_finish(&tp, &dfops); 6113a904b1caSNamjae Jeon if (error) 6114a904b1caSNamjae Jeon goto out; 6115a904b1caSNamjae Jeon 611670393313SChristoph Hellwig return xfs_trans_commit(tp); 6117a904b1caSNamjae Jeon 6118a904b1caSNamjae Jeon out: 61192c3234d1SDarrick J. Wong xfs_defer_cancel(&dfops); 61204906e215SChristoph Hellwig xfs_trans_cancel(tp); 6121a904b1caSNamjae Jeon return error; 6122a904b1caSNamjae Jeon } 61239f3afb57SDarrick J. Wong 61249f3afb57SDarrick J. Wong /* Deferred mapping is only for real extents in the data fork. */ 61259f3afb57SDarrick J. Wong static bool 61269f3afb57SDarrick J. Wong xfs_bmap_is_update_needed( 61279f3afb57SDarrick J. Wong struct xfs_bmbt_irec *bmap) 61289f3afb57SDarrick J. Wong { 61299f3afb57SDarrick J. Wong return bmap->br_startblock != HOLESTARTBLOCK && 61309f3afb57SDarrick J. Wong bmap->br_startblock != DELAYSTARTBLOCK; 61319f3afb57SDarrick J. Wong } 61329f3afb57SDarrick J. Wong 61339f3afb57SDarrick J. Wong /* Record a bmap intent. */ 61349f3afb57SDarrick J. Wong static int 61359f3afb57SDarrick J. Wong __xfs_bmap_add( 61369f3afb57SDarrick J. Wong struct xfs_mount *mp, 61379f3afb57SDarrick J. Wong struct xfs_defer_ops *dfops, 61389f3afb57SDarrick J. Wong enum xfs_bmap_intent_type type, 61399f3afb57SDarrick J. Wong struct xfs_inode *ip, 61409f3afb57SDarrick J. Wong int whichfork, 61419f3afb57SDarrick J. Wong struct xfs_bmbt_irec *bmap) 61429f3afb57SDarrick J. Wong { 61439f3afb57SDarrick J. Wong int error; 61449f3afb57SDarrick J. Wong struct xfs_bmap_intent *bi; 61459f3afb57SDarrick J. Wong 61469f3afb57SDarrick J. Wong trace_xfs_bmap_defer(mp, 61479f3afb57SDarrick J. Wong XFS_FSB_TO_AGNO(mp, bmap->br_startblock), 61489f3afb57SDarrick J. Wong type, 61499f3afb57SDarrick J. Wong XFS_FSB_TO_AGBNO(mp, bmap->br_startblock), 61509f3afb57SDarrick J. Wong ip->i_ino, whichfork, 61519f3afb57SDarrick J. Wong bmap->br_startoff, 61529f3afb57SDarrick J. Wong bmap->br_blockcount, 61539f3afb57SDarrick J. Wong bmap->br_state); 61549f3afb57SDarrick J. Wong 61559f3afb57SDarrick J. Wong bi = kmem_alloc(sizeof(struct xfs_bmap_intent), KM_SLEEP | KM_NOFS); 61569f3afb57SDarrick J. Wong INIT_LIST_HEAD(&bi->bi_list); 61579f3afb57SDarrick J. Wong bi->bi_type = type; 61589f3afb57SDarrick J. Wong bi->bi_owner = ip; 61599f3afb57SDarrick J. Wong bi->bi_whichfork = whichfork; 61609f3afb57SDarrick J. Wong bi->bi_bmap = *bmap; 61619f3afb57SDarrick J. Wong 6162882d8785SChristoph Hellwig error = xfs_defer_ijoin(dfops, bi->bi_owner); 61639f3afb57SDarrick J. Wong if (error) { 61649f3afb57SDarrick J. Wong kmem_free(bi); 61659f3afb57SDarrick J. Wong return error; 61669f3afb57SDarrick J. Wong } 61679f3afb57SDarrick J. Wong 61689f3afb57SDarrick J. Wong xfs_defer_add(dfops, XFS_DEFER_OPS_TYPE_BMAP, &bi->bi_list); 61699f3afb57SDarrick J. Wong return 0; 61709f3afb57SDarrick J. Wong } 61719f3afb57SDarrick J. Wong 61729f3afb57SDarrick J. Wong /* Map an extent into a file. */ 61739f3afb57SDarrick J. Wong int 61749f3afb57SDarrick J. Wong xfs_bmap_map_extent( 61759f3afb57SDarrick J. Wong struct xfs_mount *mp, 61769f3afb57SDarrick J. Wong struct xfs_defer_ops *dfops, 61779f3afb57SDarrick J. Wong struct xfs_inode *ip, 61789f3afb57SDarrick J. Wong struct xfs_bmbt_irec *PREV) 61799f3afb57SDarrick J. Wong { 61809f3afb57SDarrick J. Wong if (!xfs_bmap_is_update_needed(PREV)) 61819f3afb57SDarrick J. Wong return 0; 61829f3afb57SDarrick J. Wong 61839f3afb57SDarrick J. Wong return __xfs_bmap_add(mp, dfops, XFS_BMAP_MAP, ip, 61849f3afb57SDarrick J. Wong XFS_DATA_FORK, PREV); 61859f3afb57SDarrick J. Wong } 61869f3afb57SDarrick J. Wong 61879f3afb57SDarrick J. Wong /* Unmap an extent out of a file. */ 61889f3afb57SDarrick J. Wong int 61899f3afb57SDarrick J. Wong xfs_bmap_unmap_extent( 61909f3afb57SDarrick J. Wong struct xfs_mount *mp, 61919f3afb57SDarrick J. Wong struct xfs_defer_ops *dfops, 61929f3afb57SDarrick J. Wong struct xfs_inode *ip, 61939f3afb57SDarrick J. Wong struct xfs_bmbt_irec *PREV) 61949f3afb57SDarrick J. Wong { 61959f3afb57SDarrick J. Wong if (!xfs_bmap_is_update_needed(PREV)) 61969f3afb57SDarrick J. Wong return 0; 61979f3afb57SDarrick J. Wong 61989f3afb57SDarrick J. Wong return __xfs_bmap_add(mp, dfops, XFS_BMAP_UNMAP, ip, 61999f3afb57SDarrick J. Wong XFS_DATA_FORK, PREV); 62009f3afb57SDarrick J. Wong } 62019f3afb57SDarrick J. Wong 62029f3afb57SDarrick J. Wong /* 62039f3afb57SDarrick J. Wong * Process one of the deferred bmap operations. We pass back the 62049f3afb57SDarrick J. Wong * btree cursor to maintain our lock on the bmapbt between calls. 62059f3afb57SDarrick J. Wong */ 62069f3afb57SDarrick J. Wong int 62079f3afb57SDarrick J. Wong xfs_bmap_finish_one( 62089f3afb57SDarrick J. Wong struct xfs_trans *tp, 62099f3afb57SDarrick J. Wong struct xfs_defer_ops *dfops, 62109f3afb57SDarrick J. Wong struct xfs_inode *ip, 62119f3afb57SDarrick J. Wong enum xfs_bmap_intent_type type, 62129f3afb57SDarrick J. Wong int whichfork, 62139f3afb57SDarrick J. Wong xfs_fileoff_t startoff, 62149f3afb57SDarrick J. Wong xfs_fsblock_t startblock, 6215e1a4e37cSDarrick J. Wong xfs_filblks_t *blockcount, 62169f3afb57SDarrick J. Wong xfs_exntst_t state) 62179f3afb57SDarrick J. Wong { 6218e1a4e37cSDarrick J. Wong xfs_fsblock_t firstfsb; 6219e1a4e37cSDarrick J. Wong int error = 0; 62209f3afb57SDarrick J. Wong 62214c1a67bdSDarrick J. Wong /* 62224c1a67bdSDarrick J. Wong * firstfsb is tied to the transaction lifetime and is used to 62234c1a67bdSDarrick J. Wong * ensure correct AG locking order and schedule work item 62244c1a67bdSDarrick J. Wong * continuations. XFS_BUI_MAX_FAST_EXTENTS (== 1) restricts us 62254c1a67bdSDarrick J. Wong * to only making one bmap call per transaction, so it should 62264c1a67bdSDarrick J. Wong * be safe to have it as a local variable here. 62274c1a67bdSDarrick J. Wong */ 62284c1a67bdSDarrick J. Wong firstfsb = NULLFSBLOCK; 62294c1a67bdSDarrick J. Wong 62309f3afb57SDarrick J. Wong trace_xfs_bmap_deferred(tp->t_mountp, 62319f3afb57SDarrick J. Wong XFS_FSB_TO_AGNO(tp->t_mountp, startblock), type, 62329f3afb57SDarrick J. Wong XFS_FSB_TO_AGBNO(tp->t_mountp, startblock), 6233e1a4e37cSDarrick J. Wong ip->i_ino, whichfork, startoff, *blockcount, state); 62349f3afb57SDarrick J. Wong 623539e07daaSChristoph Hellwig if (WARN_ON_ONCE(whichfork != XFS_DATA_FORK)) 62369f3afb57SDarrick J. Wong return -EFSCORRUPTED; 62379f3afb57SDarrick J. Wong 62389f3afb57SDarrick J. Wong if (XFS_TEST_ERROR(false, tp->t_mountp, 62399e24cfd0SDarrick J. Wong XFS_ERRTAG_BMAP_FINISH_ONE)) 62409f3afb57SDarrick J. Wong return -EIO; 62419f3afb57SDarrick J. Wong 62429f3afb57SDarrick J. Wong switch (type) { 62439f3afb57SDarrick J. Wong case XFS_BMAP_MAP: 6244e1a4e37cSDarrick J. Wong error = xfs_bmapi_remap(tp, ip, startoff, *blockcount, 62456ebd5a44SChristoph Hellwig startblock, dfops); 6246e1a4e37cSDarrick J. Wong *blockcount = 0; 62479f3afb57SDarrick J. Wong break; 62489f3afb57SDarrick J. Wong case XFS_BMAP_UNMAP: 6249e1a4e37cSDarrick J. Wong error = __xfs_bunmapi(tp, ip, startoff, blockcount, 6250e1a4e37cSDarrick J. Wong XFS_BMAPI_REMAP, 1, &firstfsb, dfops); 62519f3afb57SDarrick J. Wong break; 62529f3afb57SDarrick J. Wong default: 62539f3afb57SDarrick J. Wong ASSERT(0); 62549f3afb57SDarrick J. Wong error = -EFSCORRUPTED; 62559f3afb57SDarrick J. Wong } 62569f3afb57SDarrick J. Wong 62579f3afb57SDarrick J. Wong return error; 62589f3afb57SDarrick J. Wong } 6259