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" 41e9e899a2SDarrick J. Wong #include "xfs_errortag.h" 4230f712c9SDave Chinner #include "xfs_error.h" 4330f712c9SDave Chinner #include "xfs_quota.h" 4430f712c9SDave Chinner #include "xfs_trans_space.h" 4530f712c9SDave Chinner #include "xfs_buf_item.h" 4630f712c9SDave Chinner #include "xfs_trace.h" 4730f712c9SDave Chinner #include "xfs_symlink.h" 4830f712c9SDave Chinner #include "xfs_attr_leaf.h" 4930f712c9SDave Chinner #include "xfs_filestream.h" 50340785ccSDarrick J. Wong #include "xfs_rmap.h" 513fd129b6SDarrick J. Wong #include "xfs_ag_resv.h" 5262aab20fSDarrick J. Wong #include "xfs_refcount.h" 53974ae922SBrian Foster #include "xfs_icache.h" 5430f712c9SDave Chinner 5530f712c9SDave Chinner 5630f712c9SDave Chinner kmem_zone_t *xfs_bmap_free_item_zone; 5730f712c9SDave Chinner 5830f712c9SDave Chinner /* 5930f712c9SDave Chinner * Miscellaneous helper functions 6030f712c9SDave Chinner */ 6130f712c9SDave Chinner 6230f712c9SDave Chinner /* 6330f712c9SDave Chinner * Compute and fill in the value of the maximum depth of a bmap btree 6430f712c9SDave Chinner * in this filesystem. Done once, during mount. 6530f712c9SDave Chinner */ 6630f712c9SDave Chinner void 6730f712c9SDave Chinner xfs_bmap_compute_maxlevels( 6830f712c9SDave Chinner xfs_mount_t *mp, /* file system mount structure */ 6930f712c9SDave Chinner int whichfork) /* data or attr fork */ 7030f712c9SDave Chinner { 7130f712c9SDave Chinner int level; /* btree level */ 7230f712c9SDave Chinner uint maxblocks; /* max blocks at this level */ 7330f712c9SDave Chinner uint maxleafents; /* max leaf entries possible */ 7430f712c9SDave Chinner int maxrootrecs; /* max records in root block */ 7530f712c9SDave Chinner int minleafrecs; /* min records in leaf block */ 7630f712c9SDave Chinner int minnoderecs; /* min records in node block */ 7730f712c9SDave Chinner int sz; /* root block size */ 7830f712c9SDave Chinner 7930f712c9SDave Chinner /* 8030f712c9SDave Chinner * The maximum number of extents in a file, hence the maximum 8130f712c9SDave Chinner * number of leaf entries, is controlled by the type of di_nextents 8230f712c9SDave Chinner * (a signed 32-bit number, xfs_extnum_t), or by di_anextents 8330f712c9SDave Chinner * (a signed 16-bit number, xfs_aextnum_t). 8430f712c9SDave Chinner * 8530f712c9SDave Chinner * Note that we can no longer assume that if we are in ATTR1 that 8630f712c9SDave Chinner * the fork offset of all the inodes will be 8730f712c9SDave Chinner * (xfs_default_attroffset(ip) >> 3) because we could have mounted 8830f712c9SDave Chinner * with ATTR2 and then mounted back with ATTR1, keeping the 8930f712c9SDave Chinner * di_forkoff's fixed but probably at various positions. Therefore, 9030f712c9SDave Chinner * for both ATTR1 and ATTR2 we have to assume the worst case scenario 9130f712c9SDave Chinner * of a minimum size available. 9230f712c9SDave Chinner */ 9330f712c9SDave Chinner if (whichfork == XFS_DATA_FORK) { 9430f712c9SDave Chinner maxleafents = MAXEXTNUM; 9530f712c9SDave Chinner sz = XFS_BMDR_SPACE_CALC(MINDBTPTRS); 9630f712c9SDave Chinner } else { 9730f712c9SDave Chinner maxleafents = MAXAEXTNUM; 9830f712c9SDave Chinner sz = XFS_BMDR_SPACE_CALC(MINABTPTRS); 9930f712c9SDave Chinner } 10030f712c9SDave Chinner maxrootrecs = xfs_bmdr_maxrecs(sz, 0); 10130f712c9SDave Chinner minleafrecs = mp->m_bmap_dmnr[0]; 10230f712c9SDave Chinner minnoderecs = mp->m_bmap_dmnr[1]; 10330f712c9SDave Chinner maxblocks = (maxleafents + minleafrecs - 1) / minleafrecs; 10430f712c9SDave Chinner for (level = 1; maxblocks > 1; level++) { 10530f712c9SDave Chinner if (maxblocks <= maxrootrecs) 10630f712c9SDave Chinner maxblocks = 1; 10730f712c9SDave Chinner else 10830f712c9SDave Chinner maxblocks = (maxblocks + minnoderecs - 1) / minnoderecs; 10930f712c9SDave Chinner } 11030f712c9SDave Chinner mp->m_bm_maxlevels[whichfork] = level; 11130f712c9SDave Chinner } 11230f712c9SDave Chinner 11330f712c9SDave Chinner STATIC int /* error */ 11430f712c9SDave Chinner xfs_bmbt_lookup_eq( 11530f712c9SDave Chinner struct xfs_btree_cur *cur, 116e16cf9b0SChristoph Hellwig struct xfs_bmbt_irec *irec, 11730f712c9SDave Chinner int *stat) /* success/failure */ 11830f712c9SDave Chinner { 119e16cf9b0SChristoph Hellwig cur->bc_rec.b = *irec; 12030f712c9SDave Chinner return xfs_btree_lookup(cur, XFS_LOOKUP_EQ, stat); 12130f712c9SDave Chinner } 12230f712c9SDave Chinner 12330f712c9SDave Chinner STATIC int /* error */ 124b5cfbc22SChristoph Hellwig xfs_bmbt_lookup_first( 12530f712c9SDave Chinner struct xfs_btree_cur *cur, 12630f712c9SDave Chinner int *stat) /* success/failure */ 12730f712c9SDave Chinner { 128b5cfbc22SChristoph Hellwig cur->bc_rec.b.br_startoff = 0; 129b5cfbc22SChristoph Hellwig cur->bc_rec.b.br_startblock = 0; 130b5cfbc22SChristoph Hellwig cur->bc_rec.b.br_blockcount = 0; 13130f712c9SDave Chinner return xfs_btree_lookup(cur, XFS_LOOKUP_GE, stat); 13230f712c9SDave Chinner } 13330f712c9SDave Chinner 13430f712c9SDave Chinner /* 13530f712c9SDave Chinner * Check if the inode needs to be converted to btree format. 13630f712c9SDave Chinner */ 13730f712c9SDave Chinner static inline bool xfs_bmap_needs_btree(struct xfs_inode *ip, int whichfork) 13830f712c9SDave Chinner { 13960b4984fSDarrick J. Wong return whichfork != XFS_COW_FORK && 14060b4984fSDarrick J. Wong XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_EXTENTS && 14130f712c9SDave Chinner XFS_IFORK_NEXTENTS(ip, whichfork) > 14230f712c9SDave Chinner XFS_IFORK_MAXEXT(ip, whichfork); 14330f712c9SDave Chinner } 14430f712c9SDave Chinner 14530f712c9SDave Chinner /* 14630f712c9SDave Chinner * Check if the inode should be converted to extent format. 14730f712c9SDave Chinner */ 14830f712c9SDave Chinner static inline bool xfs_bmap_wants_extents(struct xfs_inode *ip, int whichfork) 14930f712c9SDave Chinner { 15060b4984fSDarrick J. Wong return whichfork != XFS_COW_FORK && 15160b4984fSDarrick J. Wong XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_BTREE && 15230f712c9SDave Chinner XFS_IFORK_NEXTENTS(ip, whichfork) <= 15330f712c9SDave Chinner XFS_IFORK_MAXEXT(ip, whichfork); 15430f712c9SDave Chinner } 15530f712c9SDave Chinner 15630f712c9SDave Chinner /* 157a67d00a5SChristoph Hellwig * Update the record referred to by cur to the value given by irec 15830f712c9SDave Chinner * This either works (return 0) or gets an EFSCORRUPTED error. 15930f712c9SDave Chinner */ 16030f712c9SDave Chinner STATIC int 16130f712c9SDave Chinner xfs_bmbt_update( 16230f712c9SDave Chinner struct xfs_btree_cur *cur, 163a67d00a5SChristoph Hellwig struct xfs_bmbt_irec *irec) 16430f712c9SDave Chinner { 16530f712c9SDave Chinner union xfs_btree_rec rec; 16630f712c9SDave Chinner 167a67d00a5SChristoph Hellwig xfs_bmbt_disk_set_all(&rec.bmbt, irec); 16830f712c9SDave Chinner return xfs_btree_update(cur, &rec); 16930f712c9SDave Chinner } 17030f712c9SDave Chinner 17130f712c9SDave Chinner /* 17230f712c9SDave Chinner * Compute the worst-case number of indirect blocks that will be used 17330f712c9SDave Chinner * for ip's delayed extent of length "len". 17430f712c9SDave Chinner */ 17530f712c9SDave Chinner STATIC xfs_filblks_t 17630f712c9SDave Chinner xfs_bmap_worst_indlen( 17730f712c9SDave Chinner xfs_inode_t *ip, /* incore inode pointer */ 17830f712c9SDave Chinner xfs_filblks_t len) /* delayed extent length */ 17930f712c9SDave Chinner { 18030f712c9SDave Chinner int level; /* btree level number */ 18130f712c9SDave Chinner int maxrecs; /* maximum record count at this level */ 18230f712c9SDave Chinner xfs_mount_t *mp; /* mount structure */ 18330f712c9SDave Chinner xfs_filblks_t rval; /* return value */ 18430f712c9SDave Chinner 18530f712c9SDave Chinner mp = ip->i_mount; 18630f712c9SDave Chinner maxrecs = mp->m_bmap_dmxr[0]; 18730f712c9SDave Chinner for (level = 0, rval = 0; 18830f712c9SDave Chinner level < XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK); 18930f712c9SDave Chinner level++) { 19030f712c9SDave Chinner len += maxrecs - 1; 19130f712c9SDave Chinner do_div(len, maxrecs); 19230f712c9SDave Chinner rval += len; 1935e5c943cSDarrick J. Wong if (len == 1) 1945e5c943cSDarrick J. Wong return rval + XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK) - 19530f712c9SDave Chinner level - 1; 19630f712c9SDave Chinner if (level == 0) 19730f712c9SDave Chinner maxrecs = mp->m_bmap_dmxr[1]; 19830f712c9SDave Chinner } 19930f712c9SDave Chinner return rval; 20030f712c9SDave Chinner } 20130f712c9SDave Chinner 20230f712c9SDave Chinner /* 20330f712c9SDave Chinner * Calculate the default attribute fork offset for newly created inodes. 20430f712c9SDave Chinner */ 20530f712c9SDave Chinner uint 20630f712c9SDave Chinner xfs_default_attroffset( 20730f712c9SDave Chinner struct xfs_inode *ip) 20830f712c9SDave Chinner { 20930f712c9SDave Chinner struct xfs_mount *mp = ip->i_mount; 21030f712c9SDave Chinner uint offset; 21130f712c9SDave Chinner 21230f712c9SDave Chinner if (mp->m_sb.sb_inodesize == 256) { 21330f712c9SDave Chinner offset = XFS_LITINO(mp, ip->i_d.di_version) - 21430f712c9SDave Chinner XFS_BMDR_SPACE_CALC(MINABTPTRS); 21530f712c9SDave Chinner } else { 21630f712c9SDave Chinner offset = XFS_BMDR_SPACE_CALC(6 * MINABTPTRS); 21730f712c9SDave Chinner } 21830f712c9SDave Chinner 21930f712c9SDave Chinner ASSERT(offset < XFS_LITINO(mp, ip->i_d.di_version)); 22030f712c9SDave Chinner return offset; 22130f712c9SDave Chinner } 22230f712c9SDave Chinner 22330f712c9SDave Chinner /* 22430f712c9SDave Chinner * Helper routine to reset inode di_forkoff field when switching 22530f712c9SDave Chinner * attribute fork from local to extent format - we reset it where 22630f712c9SDave Chinner * possible to make space available for inline data fork extents. 22730f712c9SDave Chinner */ 22830f712c9SDave Chinner STATIC void 22930f712c9SDave Chinner xfs_bmap_forkoff_reset( 23030f712c9SDave Chinner xfs_inode_t *ip, 23130f712c9SDave Chinner int whichfork) 23230f712c9SDave Chinner { 23330f712c9SDave Chinner if (whichfork == XFS_ATTR_FORK && 23430f712c9SDave Chinner ip->i_d.di_format != XFS_DINODE_FMT_DEV && 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, 40359f6fec3SDarrick J. Wong xfs_verify_fsbno(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 * Validate that the bmbt_irecs being returned from bmapi are valid 49230f712c9SDave Chinner * given the caller's original parameters. Specifically check the 49330f712c9SDave Chinner * ranges of the returned irecs to ensure that they only extend beyond 49430f712c9SDave Chinner * the given parameters if the XFS_BMAPI_ENTIRE flag was set. 49530f712c9SDave Chinner */ 49630f712c9SDave Chinner STATIC void 49730f712c9SDave Chinner xfs_bmap_validate_ret( 49830f712c9SDave Chinner xfs_fileoff_t bno, 49930f712c9SDave Chinner xfs_filblks_t len, 50030f712c9SDave Chinner int flags, 50130f712c9SDave Chinner xfs_bmbt_irec_t *mval, 50230f712c9SDave Chinner int nmap, 50330f712c9SDave Chinner int ret_nmap) 50430f712c9SDave Chinner { 50530f712c9SDave Chinner int i; /* index to map values */ 50630f712c9SDave Chinner 50730f712c9SDave Chinner ASSERT(ret_nmap <= nmap); 50830f712c9SDave Chinner 50930f712c9SDave Chinner for (i = 0; i < ret_nmap; i++) { 51030f712c9SDave Chinner ASSERT(mval[i].br_blockcount > 0); 51130f712c9SDave Chinner if (!(flags & XFS_BMAPI_ENTIRE)) { 51230f712c9SDave Chinner ASSERT(mval[i].br_startoff >= bno); 51330f712c9SDave Chinner ASSERT(mval[i].br_blockcount <= len); 51430f712c9SDave Chinner ASSERT(mval[i].br_startoff + mval[i].br_blockcount <= 51530f712c9SDave Chinner bno + len); 51630f712c9SDave Chinner } else { 51730f712c9SDave Chinner ASSERT(mval[i].br_startoff < bno + len); 51830f712c9SDave Chinner ASSERT(mval[i].br_startoff + mval[i].br_blockcount > 51930f712c9SDave Chinner bno); 52030f712c9SDave Chinner } 52130f712c9SDave Chinner ASSERT(i == 0 || 52230f712c9SDave Chinner mval[i - 1].br_startoff + mval[i - 1].br_blockcount == 52330f712c9SDave Chinner mval[i].br_startoff); 52430f712c9SDave Chinner ASSERT(mval[i].br_startblock != DELAYSTARTBLOCK && 52530f712c9SDave Chinner mval[i].br_startblock != HOLESTARTBLOCK); 52630f712c9SDave Chinner ASSERT(mval[i].br_state == XFS_EXT_NORM || 52730f712c9SDave Chinner mval[i].br_state == XFS_EXT_UNWRITTEN); 52830f712c9SDave Chinner } 52930f712c9SDave Chinner } 53030f712c9SDave Chinner 53130f712c9SDave Chinner #else 53230f712c9SDave Chinner #define xfs_bmap_check_leaf_extents(cur, ip, whichfork) do { } while (0) 5337bf7a193SDarrick J. Wong #define xfs_bmap_validate_ret(bno,len,flags,mval,onmap,nmap) do { } while (0) 53430f712c9SDave Chinner #endif /* DEBUG */ 53530f712c9SDave Chinner 53630f712c9SDave Chinner /* 53730f712c9SDave Chinner * bmap free list manipulation functions 53830f712c9SDave Chinner */ 53930f712c9SDave Chinner 54030f712c9SDave Chinner /* 54130f712c9SDave Chinner * Add the extent to the list of extents to be free at transaction end. 54230f712c9SDave Chinner * The list is maintained sorted (by block number). 54330f712c9SDave Chinner */ 54430f712c9SDave Chinner void 54530f712c9SDave Chinner xfs_bmap_add_free( 546340785ccSDarrick J. Wong struct xfs_mount *mp, 547340785ccSDarrick J. Wong struct xfs_defer_ops *dfops, 548340785ccSDarrick J. Wong xfs_fsblock_t bno, 549340785ccSDarrick J. Wong xfs_filblks_t len, 550340785ccSDarrick J. Wong struct xfs_owner_info *oinfo) 55130f712c9SDave Chinner { 552310a75a3SDarrick J. Wong struct xfs_extent_free_item *new; /* new element */ 55330f712c9SDave Chinner #ifdef DEBUG 55430f712c9SDave Chinner xfs_agnumber_t agno; 55530f712c9SDave Chinner xfs_agblock_t agbno; 55630f712c9SDave Chinner 55730f712c9SDave Chinner ASSERT(bno != NULLFSBLOCK); 55830f712c9SDave Chinner ASSERT(len > 0); 55930f712c9SDave Chinner ASSERT(len <= MAXEXTLEN); 56030f712c9SDave Chinner ASSERT(!isnullstartblock(bno)); 56130f712c9SDave Chinner agno = XFS_FSB_TO_AGNO(mp, bno); 56230f712c9SDave Chinner agbno = XFS_FSB_TO_AGBNO(mp, bno); 56330f712c9SDave Chinner ASSERT(agno < mp->m_sb.sb_agcount); 56430f712c9SDave Chinner ASSERT(agbno < mp->m_sb.sb_agblocks); 56530f712c9SDave Chinner ASSERT(len < mp->m_sb.sb_agblocks); 56630f712c9SDave Chinner ASSERT(agbno + len <= mp->m_sb.sb_agblocks); 56730f712c9SDave Chinner #endif 56830f712c9SDave Chinner ASSERT(xfs_bmap_free_item_zone != NULL); 569340785ccSDarrick J. Wong 57030f712c9SDave Chinner new = kmem_zone_alloc(xfs_bmap_free_item_zone, KM_SLEEP); 571310a75a3SDarrick J. Wong new->xefi_startblock = bno; 572310a75a3SDarrick J. Wong new->xefi_blockcount = (xfs_extlen_t)len; 573340785ccSDarrick J. Wong if (oinfo) 574340785ccSDarrick J. Wong new->xefi_oinfo = *oinfo; 575340785ccSDarrick J. Wong else 576340785ccSDarrick J. Wong xfs_rmap_skip_owner_update(&new->xefi_oinfo); 577ba9e7802SDarrick J. Wong trace_xfs_bmap_free_defer(mp, XFS_FSB_TO_AGNO(mp, bno), 0, 578ba9e7802SDarrick J. Wong XFS_FSB_TO_AGBNO(mp, bno), len); 5792c3234d1SDarrick J. Wong xfs_defer_add(dfops, XFS_DEFER_OPS_TYPE_FREE, &new->xefi_list); 58030f712c9SDave Chinner } 58130f712c9SDave Chinner 58230f712c9SDave Chinner /* 58330f712c9SDave Chinner * Inode fork format manipulation functions 58430f712c9SDave Chinner */ 58530f712c9SDave Chinner 58630f712c9SDave Chinner /* 58730f712c9SDave Chinner * Transform a btree format file with only one leaf node, where the 58830f712c9SDave Chinner * extents list will fit in the inode, into an extents format file. 58930f712c9SDave Chinner * Since the file extents are already in-core, all we have to do is 59030f712c9SDave Chinner * give up the space for the btree root and pitch the leaf block. 59130f712c9SDave Chinner */ 59230f712c9SDave Chinner STATIC int /* error */ 59330f712c9SDave Chinner xfs_bmap_btree_to_extents( 59430f712c9SDave Chinner xfs_trans_t *tp, /* transaction pointer */ 59530f712c9SDave Chinner xfs_inode_t *ip, /* incore inode pointer */ 59630f712c9SDave Chinner xfs_btree_cur_t *cur, /* btree cursor */ 59730f712c9SDave Chinner int *logflagsp, /* inode logging flags */ 59830f712c9SDave Chinner int whichfork) /* data or attr fork */ 59930f712c9SDave Chinner { 60030f712c9SDave Chinner /* REFERENCED */ 60130f712c9SDave Chinner struct xfs_btree_block *cblock;/* child btree block */ 60230f712c9SDave Chinner xfs_fsblock_t cbno; /* child block number */ 60330f712c9SDave Chinner xfs_buf_t *cbp; /* child block's buffer */ 60430f712c9SDave Chinner int error; /* error return value */ 60530f712c9SDave Chinner xfs_ifork_t *ifp; /* inode fork data */ 60630f712c9SDave Chinner xfs_mount_t *mp; /* mount point structure */ 60730f712c9SDave Chinner __be64 *pp; /* ptr to block address */ 60830f712c9SDave Chinner struct xfs_btree_block *rblock;/* root btree block */ 609340785ccSDarrick J. Wong struct xfs_owner_info oinfo; 61030f712c9SDave Chinner 61130f712c9SDave Chinner mp = ip->i_mount; 61230f712c9SDave Chinner ifp = XFS_IFORK_PTR(ip, whichfork); 61360b4984fSDarrick J. Wong ASSERT(whichfork != XFS_COW_FORK); 61430f712c9SDave Chinner ASSERT(ifp->if_flags & XFS_IFEXTENTS); 61530f712c9SDave Chinner ASSERT(XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_BTREE); 61630f712c9SDave Chinner rblock = ifp->if_broot; 61730f712c9SDave Chinner ASSERT(be16_to_cpu(rblock->bb_level) == 1); 61830f712c9SDave Chinner ASSERT(be16_to_cpu(rblock->bb_numrecs) == 1); 61930f712c9SDave Chinner ASSERT(xfs_bmbt_maxrecs(mp, ifp->if_broot_bytes, 0) == 1); 62030f712c9SDave Chinner pp = XFS_BMAP_BROOT_PTR_ADDR(mp, rblock, 1, ifp->if_broot_bytes); 62130f712c9SDave Chinner cbno = be64_to_cpu(*pp); 62230f712c9SDave Chinner *logflagsp = 0; 62330f712c9SDave Chinner #ifdef DEBUG 624f135761aSDarrick J. Wong XFS_WANT_CORRUPTED_RETURN(cur->bc_mp, 625f135761aSDarrick J. Wong xfs_btree_check_lptr(cur, cbno, 1)); 62630f712c9SDave Chinner #endif 62730f712c9SDave Chinner error = xfs_btree_read_bufl(mp, tp, cbno, 0, &cbp, XFS_BMAP_BTREE_REF, 62830f712c9SDave Chinner &xfs_bmbt_buf_ops); 62930f712c9SDave Chinner if (error) 63030f712c9SDave Chinner return error; 63130f712c9SDave Chinner cblock = XFS_BUF_TO_BLOCK(cbp); 63230f712c9SDave Chinner if ((error = xfs_btree_check_block(cur, cblock, 0, cbp))) 63330f712c9SDave Chinner return error; 634340785ccSDarrick J. Wong xfs_rmap_ino_bmbt_owner(&oinfo, ip->i_ino, whichfork); 635340785ccSDarrick J. Wong xfs_bmap_add_free(mp, cur->bc_private.b.dfops, cbno, 1, &oinfo); 63630f712c9SDave Chinner ip->i_d.di_nblocks--; 63730f712c9SDave Chinner xfs_trans_mod_dquot_byino(tp, ip, XFS_TRANS_DQ_BCOUNT, -1L); 63830f712c9SDave Chinner xfs_trans_binval(tp, cbp); 63930f712c9SDave Chinner if (cur->bc_bufs[0] == cbp) 64030f712c9SDave Chinner cur->bc_bufs[0] = NULL; 64130f712c9SDave Chinner xfs_iroot_realloc(ip, -1, whichfork); 64230f712c9SDave Chinner ASSERT(ifp->if_broot == NULL); 64330f712c9SDave Chinner ASSERT((ifp->if_flags & XFS_IFBROOT) == 0); 64430f712c9SDave Chinner XFS_IFORK_FMT_SET(ip, whichfork, XFS_DINODE_FMT_EXTENTS); 64530f712c9SDave Chinner *logflagsp = XFS_ILOG_CORE | xfs_ilog_fext(whichfork); 64630f712c9SDave Chinner return 0; 64730f712c9SDave Chinner } 64830f712c9SDave Chinner 64930f712c9SDave Chinner /* 65030f712c9SDave Chinner * Convert an extents-format file into a btree-format file. 65130f712c9SDave Chinner * The new file will have a root block (in the inode) and a single child block. 65230f712c9SDave Chinner */ 65330f712c9SDave Chinner STATIC int /* error */ 65430f712c9SDave Chinner xfs_bmap_extents_to_btree( 65530f712c9SDave Chinner xfs_trans_t *tp, /* transaction pointer */ 65630f712c9SDave Chinner xfs_inode_t *ip, /* incore inode pointer */ 65730f712c9SDave Chinner xfs_fsblock_t *firstblock, /* first-block-allocated */ 6582c3234d1SDarrick J. Wong struct xfs_defer_ops *dfops, /* blocks freed in xaction */ 65930f712c9SDave Chinner xfs_btree_cur_t **curp, /* cursor returned to caller */ 66030f712c9SDave Chinner int wasdel, /* converting a delayed alloc */ 66130f712c9SDave Chinner int *logflagsp, /* inode logging flags */ 66230f712c9SDave Chinner int whichfork) /* data or attr fork */ 66330f712c9SDave Chinner { 66430f712c9SDave Chinner struct xfs_btree_block *ablock; /* allocated (child) bt block */ 66530f712c9SDave Chinner xfs_buf_t *abp; /* buffer for ablock */ 66630f712c9SDave Chinner xfs_alloc_arg_t args; /* allocation arguments */ 66730f712c9SDave Chinner xfs_bmbt_rec_t *arp; /* child record pointer */ 66830f712c9SDave Chinner struct xfs_btree_block *block; /* btree root block */ 66930f712c9SDave Chinner xfs_btree_cur_t *cur; /* bmap btree cursor */ 67030f712c9SDave Chinner int error; /* error return value */ 67130f712c9SDave Chinner xfs_ifork_t *ifp; /* inode fork pointer */ 67230f712c9SDave Chinner xfs_bmbt_key_t *kp; /* root block key pointer */ 67330f712c9SDave Chinner xfs_mount_t *mp; /* mount structure */ 67430f712c9SDave Chinner xfs_bmbt_ptr_t *pp; /* root block address pointer */ 675b2b1712aSChristoph Hellwig struct xfs_iext_cursor icur; 676906abed5SChristoph Hellwig struct xfs_bmbt_irec rec; 677b2b1712aSChristoph Hellwig xfs_extnum_t cnt = 0; 67830f712c9SDave Chinner 67930f712c9SDave Chinner mp = ip->i_mount; 68060b4984fSDarrick J. Wong ASSERT(whichfork != XFS_COW_FORK); 68130f712c9SDave Chinner ifp = XFS_IFORK_PTR(ip, whichfork); 68230f712c9SDave Chinner ASSERT(XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_EXTENTS); 68330f712c9SDave Chinner 68430f712c9SDave Chinner /* 68530f712c9SDave Chinner * Make space in the inode incore. 68630f712c9SDave Chinner */ 68730f712c9SDave Chinner xfs_iroot_realloc(ip, 1, whichfork); 68830f712c9SDave Chinner ifp->if_flags |= XFS_IFBROOT; 68930f712c9SDave Chinner 69030f712c9SDave Chinner /* 69130f712c9SDave Chinner * Fill in the root. 69230f712c9SDave Chinner */ 69330f712c9SDave Chinner block = ifp->if_broot; 69430f712c9SDave Chinner xfs_btree_init_block_int(mp, block, XFS_BUF_DADDR_NULL, 695b6f41e44SEric Sandeen XFS_BTNUM_BMAP, 1, 1, ip->i_ino, 696f88ae46bSEric Sandeen XFS_BTREE_LONG_PTRS); 69730f712c9SDave Chinner /* 69830f712c9SDave Chinner * Need a cursor. Can't allocate until bb_level is filled in. 69930f712c9SDave Chinner */ 70030f712c9SDave Chinner cur = xfs_bmbt_init_cursor(mp, tp, ip, whichfork); 70130f712c9SDave Chinner cur->bc_private.b.firstblock = *firstblock; 7022c3234d1SDarrick J. Wong cur->bc_private.b.dfops = dfops; 70330f712c9SDave Chinner cur->bc_private.b.flags = wasdel ? XFS_BTCUR_BPRV_WASDEL : 0; 70430f712c9SDave Chinner /* 70530f712c9SDave Chinner * Convert to a btree with two levels, one record in root. 70630f712c9SDave Chinner */ 70730f712c9SDave Chinner XFS_IFORK_FMT_SET(ip, whichfork, XFS_DINODE_FMT_BTREE); 70830f712c9SDave Chinner memset(&args, 0, sizeof(args)); 70930f712c9SDave Chinner args.tp = tp; 71030f712c9SDave Chinner args.mp = mp; 711340785ccSDarrick J. Wong xfs_rmap_ino_bmbt_owner(&args.oinfo, ip->i_ino, whichfork); 71230f712c9SDave Chinner args.firstblock = *firstblock; 71330f712c9SDave Chinner if (*firstblock == NULLFSBLOCK) { 71430f712c9SDave Chinner args.type = XFS_ALLOCTYPE_START_BNO; 71530f712c9SDave Chinner args.fsbno = XFS_INO_TO_FSB(mp, ip->i_ino); 7162c3234d1SDarrick J. Wong } else if (dfops->dop_low) { 71730f712c9SDave Chinner args.type = XFS_ALLOCTYPE_START_BNO; 71830f712c9SDave Chinner args.fsbno = *firstblock; 71930f712c9SDave Chinner } else { 72030f712c9SDave Chinner args.type = XFS_ALLOCTYPE_NEAR_BNO; 72130f712c9SDave Chinner args.fsbno = *firstblock; 72230f712c9SDave Chinner } 72330f712c9SDave Chinner args.minlen = args.maxlen = args.prod = 1; 72430f712c9SDave Chinner args.wasdel = wasdel; 72530f712c9SDave Chinner *logflagsp = 0; 72630f712c9SDave Chinner if ((error = xfs_alloc_vextent(&args))) { 72730f712c9SDave Chinner xfs_iroot_realloc(ip, -1, whichfork); 7282c4306f7SEric Sandeen ASSERT(ifp->if_broot == NULL); 7292c4306f7SEric Sandeen XFS_IFORK_FMT_SET(ip, whichfork, XFS_DINODE_FMT_EXTENTS); 73030f712c9SDave Chinner xfs_btree_del_cursor(cur, XFS_BTREE_ERROR); 73130f712c9SDave Chinner return error; 73230f712c9SDave Chinner } 73390e2056dSDarrick J. Wong 7342fcc319dSChristoph Hellwig if (WARN_ON_ONCE(args.fsbno == NULLFSBLOCK)) { 7352fcc319dSChristoph Hellwig xfs_iroot_realloc(ip, -1, whichfork); 7362c4306f7SEric Sandeen ASSERT(ifp->if_broot == NULL); 7372c4306f7SEric Sandeen XFS_IFORK_FMT_SET(ip, whichfork, XFS_DINODE_FMT_EXTENTS); 7382fcc319dSChristoph Hellwig xfs_btree_del_cursor(cur, XFS_BTREE_ERROR); 7392fcc319dSChristoph Hellwig return -ENOSPC; 7402fcc319dSChristoph Hellwig } 74130f712c9SDave Chinner /* 74230f712c9SDave Chinner * Allocation can't fail, the space was reserved. 74330f712c9SDave Chinner */ 74430f712c9SDave Chinner ASSERT(*firstblock == NULLFSBLOCK || 745410d17f6SChristoph Hellwig args.agno >= XFS_FSB_TO_AGNO(mp, *firstblock)); 74630f712c9SDave Chinner *firstblock = cur->bc_private.b.firstblock = args.fsbno; 74730f712c9SDave Chinner cur->bc_private.b.allocated++; 74830f712c9SDave Chinner ip->i_d.di_nblocks++; 74930f712c9SDave Chinner xfs_trans_mod_dquot_byino(tp, ip, XFS_TRANS_DQ_BCOUNT, 1L); 75030f712c9SDave Chinner abp = xfs_btree_get_bufl(mp, tp, args.fsbno, 0); 75130f712c9SDave Chinner /* 75230f712c9SDave Chinner * Fill in the child block. 75330f712c9SDave Chinner */ 75430f712c9SDave Chinner abp->b_ops = &xfs_bmbt_buf_ops; 75530f712c9SDave Chinner ablock = XFS_BUF_TO_BLOCK(abp); 75630f712c9SDave Chinner xfs_btree_init_block_int(mp, ablock, abp->b_bn, 757b6f41e44SEric Sandeen XFS_BTNUM_BMAP, 0, 0, ip->i_ino, 75830f712c9SDave Chinner XFS_BTREE_LONG_PTRS); 75930f712c9SDave Chinner 760b2b1712aSChristoph Hellwig for_each_xfs_iext(ifp, &icur, &rec) { 761906abed5SChristoph Hellwig if (isnullstartblock(rec.br_startblock)) 762906abed5SChristoph Hellwig continue; 763906abed5SChristoph Hellwig arp = XFS_BMBT_REC_ADDR(mp, ablock, 1 + cnt); 764906abed5SChristoph Hellwig xfs_bmbt_disk_set_all(arp, &rec); 765906abed5SChristoph Hellwig cnt++; 76630f712c9SDave Chinner } 76730f712c9SDave Chinner ASSERT(cnt == XFS_IFORK_NEXTENTS(ip, whichfork)); 76830f712c9SDave Chinner xfs_btree_set_numrecs(ablock, cnt); 76930f712c9SDave Chinner 77030f712c9SDave Chinner /* 77130f712c9SDave Chinner * Fill in the root key and pointer. 77230f712c9SDave Chinner */ 77330f712c9SDave Chinner kp = XFS_BMBT_KEY_ADDR(mp, block, 1); 77430f712c9SDave Chinner arp = XFS_BMBT_REC_ADDR(mp, ablock, 1); 77530f712c9SDave Chinner kp->br_startoff = cpu_to_be64(xfs_bmbt_disk_get_startoff(arp)); 77630f712c9SDave Chinner pp = XFS_BMBT_PTR_ADDR(mp, block, 1, xfs_bmbt_get_maxrecs(cur, 77730f712c9SDave Chinner be16_to_cpu(block->bb_level))); 77830f712c9SDave Chinner *pp = cpu_to_be64(args.fsbno); 77930f712c9SDave Chinner 78030f712c9SDave Chinner /* 78130f712c9SDave Chinner * Do all this logging at the end so that 78230f712c9SDave Chinner * the root is at the right level. 78330f712c9SDave Chinner */ 78430f712c9SDave Chinner xfs_btree_log_block(cur, abp, XFS_BB_ALL_BITS); 78530f712c9SDave Chinner xfs_btree_log_recs(cur, abp, 1, be16_to_cpu(ablock->bb_numrecs)); 78630f712c9SDave Chinner ASSERT(*curp == NULL); 78730f712c9SDave Chinner *curp = cur; 78830f712c9SDave Chinner *logflagsp = XFS_ILOG_CORE | xfs_ilog_fbroot(whichfork); 78930f712c9SDave Chinner return 0; 79030f712c9SDave Chinner } 79130f712c9SDave Chinner 79230f712c9SDave Chinner /* 79330f712c9SDave Chinner * Convert a local file to an extents file. 79430f712c9SDave Chinner * This code is out of bounds for data forks of regular files, 79530f712c9SDave Chinner * since the file data needs to get logged so things will stay consistent. 79630f712c9SDave Chinner * (The bmap-level manipulations are ok, though). 79730f712c9SDave Chinner */ 79830f712c9SDave Chinner void 79930f712c9SDave Chinner xfs_bmap_local_to_extents_empty( 80030f712c9SDave Chinner struct xfs_inode *ip, 80130f712c9SDave Chinner int whichfork) 80230f712c9SDave Chinner { 80330f712c9SDave Chinner struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, whichfork); 80430f712c9SDave Chinner 80560b4984fSDarrick J. Wong ASSERT(whichfork != XFS_COW_FORK); 80630f712c9SDave Chinner ASSERT(XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_LOCAL); 80730f712c9SDave Chinner ASSERT(ifp->if_bytes == 0); 80830f712c9SDave Chinner ASSERT(XFS_IFORK_NEXTENTS(ip, whichfork) == 0); 80930f712c9SDave Chinner 81030f712c9SDave Chinner xfs_bmap_forkoff_reset(ip, whichfork); 81130f712c9SDave Chinner ifp->if_flags &= ~XFS_IFINLINE; 81230f712c9SDave Chinner ifp->if_flags |= XFS_IFEXTENTS; 8136bdcf26aSChristoph Hellwig ifp->if_u1.if_root = NULL; 8146bdcf26aSChristoph Hellwig ifp->if_height = 0; 81530f712c9SDave Chinner XFS_IFORK_FMT_SET(ip, whichfork, XFS_DINODE_FMT_EXTENTS); 81630f712c9SDave Chinner } 81730f712c9SDave Chinner 81830f712c9SDave Chinner 81930f712c9SDave Chinner STATIC int /* error */ 82030f712c9SDave Chinner xfs_bmap_local_to_extents( 82130f712c9SDave Chinner xfs_trans_t *tp, /* transaction pointer */ 82230f712c9SDave Chinner xfs_inode_t *ip, /* incore inode pointer */ 82330f712c9SDave Chinner xfs_fsblock_t *firstblock, /* first block allocated in xaction */ 82430f712c9SDave Chinner xfs_extlen_t total, /* total blocks needed by transaction */ 82530f712c9SDave Chinner int *logflagsp, /* inode logging flags */ 82630f712c9SDave Chinner int whichfork, 82730f712c9SDave Chinner void (*init_fn)(struct xfs_trans *tp, 82830f712c9SDave Chinner struct xfs_buf *bp, 82930f712c9SDave Chinner struct xfs_inode *ip, 83030f712c9SDave Chinner struct xfs_ifork *ifp)) 83130f712c9SDave Chinner { 83230f712c9SDave Chinner int error = 0; 83330f712c9SDave Chinner int flags; /* logging flags returned */ 83430f712c9SDave Chinner xfs_ifork_t *ifp; /* inode fork pointer */ 83530f712c9SDave Chinner xfs_alloc_arg_t args; /* allocation arguments */ 83630f712c9SDave Chinner xfs_buf_t *bp; /* buffer for extent block */ 83750bb44c2SChristoph Hellwig struct xfs_bmbt_irec rec; 838b2b1712aSChristoph Hellwig struct xfs_iext_cursor icur; 83930f712c9SDave Chinner 84030f712c9SDave Chinner /* 84130f712c9SDave Chinner * We don't want to deal with the case of keeping inode data inline yet. 84230f712c9SDave Chinner * So sending the data fork of a regular inode is invalid. 84330f712c9SDave Chinner */ 844c19b3b05SDave Chinner ASSERT(!(S_ISREG(VFS_I(ip)->i_mode) && whichfork == XFS_DATA_FORK)); 84530f712c9SDave Chinner ifp = XFS_IFORK_PTR(ip, whichfork); 84630f712c9SDave Chinner ASSERT(XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_LOCAL); 84730f712c9SDave Chinner 84830f712c9SDave Chinner if (!ifp->if_bytes) { 84930f712c9SDave Chinner xfs_bmap_local_to_extents_empty(ip, whichfork); 85030f712c9SDave Chinner flags = XFS_ILOG_CORE; 85130f712c9SDave Chinner goto done; 85230f712c9SDave Chinner } 85330f712c9SDave Chinner 85430f712c9SDave Chinner flags = 0; 85530f712c9SDave Chinner error = 0; 8566bdcf26aSChristoph Hellwig ASSERT((ifp->if_flags & (XFS_IFINLINE|XFS_IFEXTENTS)) == XFS_IFINLINE); 85730f712c9SDave Chinner memset(&args, 0, sizeof(args)); 85830f712c9SDave Chinner args.tp = tp; 85930f712c9SDave Chinner args.mp = ip->i_mount; 860340785ccSDarrick J. Wong xfs_rmap_ino_owner(&args.oinfo, ip->i_ino, whichfork, 0); 86130f712c9SDave Chinner args.firstblock = *firstblock; 86230f712c9SDave Chinner /* 86330f712c9SDave Chinner * Allocate a block. We know we need only one, since the 86430f712c9SDave Chinner * file currently fits in an inode. 86530f712c9SDave Chinner */ 86630f712c9SDave Chinner if (*firstblock == NULLFSBLOCK) { 86730f712c9SDave Chinner args.fsbno = XFS_INO_TO_FSB(args.mp, ip->i_ino); 86830f712c9SDave Chinner args.type = XFS_ALLOCTYPE_START_BNO; 86930f712c9SDave Chinner } else { 87030f712c9SDave Chinner args.fsbno = *firstblock; 87130f712c9SDave Chinner args.type = XFS_ALLOCTYPE_NEAR_BNO; 87230f712c9SDave Chinner } 87330f712c9SDave Chinner args.total = total; 87430f712c9SDave Chinner args.minlen = args.maxlen = args.prod = 1; 87530f712c9SDave Chinner error = xfs_alloc_vextent(&args); 87630f712c9SDave Chinner if (error) 87730f712c9SDave Chinner goto done; 87830f712c9SDave Chinner 87930f712c9SDave Chinner /* Can't fail, the space was reserved. */ 88030f712c9SDave Chinner ASSERT(args.fsbno != NULLFSBLOCK); 88130f712c9SDave Chinner ASSERT(args.len == 1); 88230f712c9SDave Chinner *firstblock = args.fsbno; 88330f712c9SDave Chinner bp = xfs_btree_get_bufl(args.mp, tp, args.fsbno, 0); 88430f712c9SDave Chinner 885fe22d552SDave Chinner /* 886b7cdc66bSBrian Foster * Initialize the block, copy the data and log the remote buffer. 887fe22d552SDave Chinner * 888b7cdc66bSBrian Foster * The callout is responsible for logging because the remote format 889b7cdc66bSBrian Foster * might differ from the local format and thus we don't know how much to 890b7cdc66bSBrian Foster * log here. Note that init_fn must also set the buffer log item type 891b7cdc66bSBrian Foster * correctly. 892fe22d552SDave Chinner */ 89330f712c9SDave Chinner init_fn(tp, bp, ip, ifp); 89430f712c9SDave Chinner 895b7cdc66bSBrian Foster /* account for the change in fork size */ 89630f712c9SDave Chinner xfs_idata_realloc(ip, -ifp->if_bytes, whichfork); 89730f712c9SDave Chinner xfs_bmap_local_to_extents_empty(ip, whichfork); 89830f712c9SDave Chinner flags |= XFS_ILOG_CORE; 89930f712c9SDave Chinner 9006bdcf26aSChristoph Hellwig ifp->if_u1.if_root = NULL; 9016bdcf26aSChristoph Hellwig ifp->if_height = 0; 9026bdcf26aSChristoph Hellwig 90350bb44c2SChristoph Hellwig rec.br_startoff = 0; 90450bb44c2SChristoph Hellwig rec.br_startblock = args.fsbno; 90550bb44c2SChristoph Hellwig rec.br_blockcount = 1; 90650bb44c2SChristoph Hellwig rec.br_state = XFS_EXT_NORM; 907b2b1712aSChristoph Hellwig xfs_iext_first(ifp, &icur); 9080254c2f2SChristoph Hellwig xfs_iext_insert(ip, &icur, &rec, 0); 90950bb44c2SChristoph Hellwig 91030f712c9SDave Chinner XFS_IFORK_NEXT_SET(ip, whichfork, 1); 91130f712c9SDave Chinner ip->i_d.di_nblocks = 1; 91230f712c9SDave Chinner xfs_trans_mod_dquot_byino(tp, ip, 91330f712c9SDave Chinner XFS_TRANS_DQ_BCOUNT, 1L); 91430f712c9SDave Chinner flags |= xfs_ilog_fext(whichfork); 91530f712c9SDave Chinner 91630f712c9SDave Chinner done: 91730f712c9SDave Chinner *logflagsp = flags; 91830f712c9SDave Chinner return error; 91930f712c9SDave Chinner } 92030f712c9SDave Chinner 92130f712c9SDave Chinner /* 92230f712c9SDave Chinner * Called from xfs_bmap_add_attrfork to handle btree format files. 92330f712c9SDave Chinner */ 92430f712c9SDave Chinner STATIC int /* error */ 92530f712c9SDave Chinner xfs_bmap_add_attrfork_btree( 92630f712c9SDave Chinner xfs_trans_t *tp, /* transaction pointer */ 92730f712c9SDave Chinner xfs_inode_t *ip, /* incore inode pointer */ 92830f712c9SDave Chinner xfs_fsblock_t *firstblock, /* first block allocated */ 9292c3234d1SDarrick J. Wong struct xfs_defer_ops *dfops, /* blocks to free at commit */ 93030f712c9SDave Chinner int *flags) /* inode logging flags */ 93130f712c9SDave Chinner { 93230f712c9SDave Chinner xfs_btree_cur_t *cur; /* btree cursor */ 93330f712c9SDave Chinner int error; /* error return value */ 93430f712c9SDave Chinner xfs_mount_t *mp; /* file system mount struct */ 93530f712c9SDave Chinner int stat; /* newroot status */ 93630f712c9SDave Chinner 93730f712c9SDave Chinner mp = ip->i_mount; 93830f712c9SDave Chinner if (ip->i_df.if_broot_bytes <= XFS_IFORK_DSIZE(ip)) 93930f712c9SDave Chinner *flags |= XFS_ILOG_DBROOT; 94030f712c9SDave Chinner else { 94130f712c9SDave Chinner cur = xfs_bmbt_init_cursor(mp, tp, ip, XFS_DATA_FORK); 9422c3234d1SDarrick J. Wong cur->bc_private.b.dfops = dfops; 94330f712c9SDave Chinner cur->bc_private.b.firstblock = *firstblock; 944b5cfbc22SChristoph Hellwig error = xfs_bmbt_lookup_first(cur, &stat); 945b5cfbc22SChristoph Hellwig if (error) 94630f712c9SDave Chinner goto error0; 94730f712c9SDave Chinner /* must be at least one entry */ 948c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, stat == 1, error0); 94930f712c9SDave Chinner if ((error = xfs_btree_new_iroot(cur, flags, &stat))) 95030f712c9SDave Chinner goto error0; 95130f712c9SDave Chinner if (stat == 0) { 95230f712c9SDave Chinner xfs_btree_del_cursor(cur, XFS_BTREE_NOERROR); 9532451337dSDave Chinner return -ENOSPC; 95430f712c9SDave Chinner } 95530f712c9SDave Chinner *firstblock = cur->bc_private.b.firstblock; 95630f712c9SDave Chinner cur->bc_private.b.allocated = 0; 95730f712c9SDave Chinner xfs_btree_del_cursor(cur, XFS_BTREE_NOERROR); 95830f712c9SDave Chinner } 95930f712c9SDave Chinner return 0; 96030f712c9SDave Chinner error0: 96130f712c9SDave Chinner xfs_btree_del_cursor(cur, XFS_BTREE_ERROR); 96230f712c9SDave Chinner return error; 96330f712c9SDave Chinner } 96430f712c9SDave Chinner 96530f712c9SDave Chinner /* 96630f712c9SDave Chinner * Called from xfs_bmap_add_attrfork to handle extents format files. 96730f712c9SDave Chinner */ 96830f712c9SDave Chinner STATIC int /* error */ 96930f712c9SDave Chinner xfs_bmap_add_attrfork_extents( 97030f712c9SDave Chinner xfs_trans_t *tp, /* transaction pointer */ 97130f712c9SDave Chinner xfs_inode_t *ip, /* incore inode pointer */ 97230f712c9SDave Chinner xfs_fsblock_t *firstblock, /* first block allocated */ 9732c3234d1SDarrick J. Wong struct xfs_defer_ops *dfops, /* blocks to free at commit */ 97430f712c9SDave Chinner int *flags) /* inode logging flags */ 97530f712c9SDave Chinner { 97630f712c9SDave Chinner xfs_btree_cur_t *cur; /* bmap btree cursor */ 97730f712c9SDave Chinner int error; /* error return value */ 97830f712c9SDave Chinner 97930f712c9SDave Chinner if (ip->i_d.di_nextents * sizeof(xfs_bmbt_rec_t) <= XFS_IFORK_DSIZE(ip)) 98030f712c9SDave Chinner return 0; 98130f712c9SDave Chinner cur = NULL; 9822c3234d1SDarrick J. Wong error = xfs_bmap_extents_to_btree(tp, ip, firstblock, dfops, &cur, 0, 98330f712c9SDave Chinner flags, XFS_DATA_FORK); 98430f712c9SDave Chinner if (cur) { 98530f712c9SDave Chinner cur->bc_private.b.allocated = 0; 98630f712c9SDave Chinner xfs_btree_del_cursor(cur, 98730f712c9SDave Chinner error ? XFS_BTREE_ERROR : XFS_BTREE_NOERROR); 98830f712c9SDave Chinner } 98930f712c9SDave Chinner return error; 99030f712c9SDave Chinner } 99130f712c9SDave Chinner 99230f712c9SDave Chinner /* 99330f712c9SDave Chinner * Called from xfs_bmap_add_attrfork to handle local format files. Each 99430f712c9SDave Chinner * different data fork content type needs a different callout to do the 99530f712c9SDave Chinner * conversion. Some are basic and only require special block initialisation 99630f712c9SDave Chinner * callouts for the data formating, others (directories) are so specialised they 99730f712c9SDave Chinner * handle everything themselves. 99830f712c9SDave Chinner * 99930f712c9SDave Chinner * XXX (dgc): investigate whether directory conversion can use the generic 100030f712c9SDave Chinner * formatting callout. It should be possible - it's just a very complex 100130f712c9SDave Chinner * formatter. 100230f712c9SDave Chinner */ 100330f712c9SDave Chinner STATIC int /* error */ 100430f712c9SDave Chinner xfs_bmap_add_attrfork_local( 100530f712c9SDave Chinner xfs_trans_t *tp, /* transaction pointer */ 100630f712c9SDave Chinner xfs_inode_t *ip, /* incore inode pointer */ 100730f712c9SDave Chinner xfs_fsblock_t *firstblock, /* first block allocated */ 10082c3234d1SDarrick J. Wong struct xfs_defer_ops *dfops, /* blocks to free at commit */ 100930f712c9SDave Chinner int *flags) /* inode logging flags */ 101030f712c9SDave Chinner { 101130f712c9SDave Chinner xfs_da_args_t dargs; /* args for dir/attr code */ 101230f712c9SDave Chinner 101330f712c9SDave Chinner if (ip->i_df.if_bytes <= XFS_IFORK_DSIZE(ip)) 101430f712c9SDave Chinner return 0; 101530f712c9SDave Chinner 1016c19b3b05SDave Chinner if (S_ISDIR(VFS_I(ip)->i_mode)) { 101730f712c9SDave Chinner memset(&dargs, 0, sizeof(dargs)); 101830f712c9SDave Chinner dargs.geo = ip->i_mount->m_dir_geo; 101930f712c9SDave Chinner dargs.dp = ip; 102030f712c9SDave Chinner dargs.firstblock = firstblock; 10212c3234d1SDarrick J. Wong dargs.dfops = dfops; 102230f712c9SDave Chinner dargs.total = dargs.geo->fsbcount; 102330f712c9SDave Chinner dargs.whichfork = XFS_DATA_FORK; 102430f712c9SDave Chinner dargs.trans = tp; 102530f712c9SDave Chinner return xfs_dir2_sf_to_block(&dargs); 102630f712c9SDave Chinner } 102730f712c9SDave Chinner 1028c19b3b05SDave Chinner if (S_ISLNK(VFS_I(ip)->i_mode)) 102930f712c9SDave Chinner return xfs_bmap_local_to_extents(tp, ip, firstblock, 1, 103030f712c9SDave Chinner flags, XFS_DATA_FORK, 103130f712c9SDave Chinner xfs_symlink_local_to_remote); 103230f712c9SDave Chinner 103330f712c9SDave Chinner /* should only be called for types that support local format data */ 103430f712c9SDave Chinner ASSERT(0); 10352451337dSDave Chinner return -EFSCORRUPTED; 103630f712c9SDave Chinner } 103730f712c9SDave Chinner 103830f712c9SDave Chinner /* 103930f712c9SDave Chinner * Convert inode from non-attributed to attributed. 104030f712c9SDave Chinner * Must not be in a transaction, ip must not be locked. 104130f712c9SDave Chinner */ 104230f712c9SDave Chinner int /* error code */ 104330f712c9SDave Chinner xfs_bmap_add_attrfork( 104430f712c9SDave Chinner xfs_inode_t *ip, /* incore inode pointer */ 104530f712c9SDave Chinner int size, /* space new attribute needs */ 104630f712c9SDave Chinner int rsvd) /* xact may use reserved blks */ 104730f712c9SDave Chinner { 104830f712c9SDave Chinner xfs_fsblock_t firstblock; /* 1st block/ag allocated */ 10492c3234d1SDarrick J. Wong struct xfs_defer_ops dfops; /* freed extent records */ 105030f712c9SDave Chinner xfs_mount_t *mp; /* mount structure */ 105130f712c9SDave Chinner xfs_trans_t *tp; /* transaction pointer */ 105230f712c9SDave Chinner int blks; /* space reservation */ 105330f712c9SDave Chinner int version = 1; /* superblock attr version */ 105430f712c9SDave Chinner int logflags; /* logging flags */ 105530f712c9SDave Chinner int error; /* error return value */ 105630f712c9SDave Chinner 105730f712c9SDave Chinner ASSERT(XFS_IFORK_Q(ip) == 0); 105830f712c9SDave Chinner 105930f712c9SDave Chinner mp = ip->i_mount; 106030f712c9SDave Chinner ASSERT(!XFS_NOT_DQATTACHED(mp, ip)); 1061253f4911SChristoph Hellwig 106230f712c9SDave Chinner blks = XFS_ADDAFORK_SPACE_RES(mp); 1063253f4911SChristoph Hellwig 1064253f4911SChristoph Hellwig error = xfs_trans_alloc(mp, &M_RES(mp)->tr_addafork, blks, 0, 1065253f4911SChristoph Hellwig rsvd ? XFS_TRANS_RESERVE : 0, &tp); 1066253f4911SChristoph Hellwig if (error) 106730f712c9SDave Chinner return error; 1068253f4911SChristoph Hellwig 106930f712c9SDave Chinner xfs_ilock(ip, XFS_ILOCK_EXCL); 107030f712c9SDave Chinner error = xfs_trans_reserve_quota_nblks(tp, ip, blks, 0, rsvd ? 107130f712c9SDave Chinner XFS_QMOPT_RES_REGBLKS | XFS_QMOPT_FORCE_RES : 107230f712c9SDave Chinner XFS_QMOPT_RES_REGBLKS); 107330f712c9SDave Chinner if (error) 107430f712c9SDave Chinner goto trans_cancel; 107530f712c9SDave Chinner if (XFS_IFORK_Q(ip)) 107630f712c9SDave Chinner goto trans_cancel; 10770f352f8eSDarrick J. Wong if (ip->i_d.di_anextents != 0) { 10780f352f8eSDarrick J. Wong error = -EFSCORRUPTED; 10790f352f8eSDarrick J. Wong goto trans_cancel; 10800f352f8eSDarrick J. Wong } 108130f712c9SDave Chinner if (ip->i_d.di_aformat != XFS_DINODE_FMT_EXTENTS) { 108230f712c9SDave Chinner /* 108330f712c9SDave Chinner * For inodes coming from pre-6.2 filesystems. 108430f712c9SDave Chinner */ 108530f712c9SDave Chinner ASSERT(ip->i_d.di_aformat == 0); 108630f712c9SDave Chinner ip->i_d.di_aformat = XFS_DINODE_FMT_EXTENTS; 108730f712c9SDave Chinner } 108830f712c9SDave Chinner 108930f712c9SDave Chinner xfs_trans_ijoin(tp, ip, 0); 109030f712c9SDave Chinner xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE); 109130f712c9SDave Chinner 109230f712c9SDave Chinner switch (ip->i_d.di_format) { 109330f712c9SDave Chinner case XFS_DINODE_FMT_DEV: 109430f712c9SDave Chinner ip->i_d.di_forkoff = roundup(sizeof(xfs_dev_t), 8) >> 3; 109530f712c9SDave Chinner break; 109630f712c9SDave Chinner case XFS_DINODE_FMT_LOCAL: 109730f712c9SDave Chinner case XFS_DINODE_FMT_EXTENTS: 109830f712c9SDave Chinner case XFS_DINODE_FMT_BTREE: 109930f712c9SDave Chinner ip->i_d.di_forkoff = xfs_attr_shortform_bytesfit(ip, size); 110030f712c9SDave Chinner if (!ip->i_d.di_forkoff) 110130f712c9SDave Chinner ip->i_d.di_forkoff = xfs_default_attroffset(ip) >> 3; 110230f712c9SDave Chinner else if (mp->m_flags & XFS_MOUNT_ATTR2) 110330f712c9SDave Chinner version = 2; 110430f712c9SDave Chinner break; 110530f712c9SDave Chinner default: 110630f712c9SDave Chinner ASSERT(0); 11072451337dSDave Chinner error = -EINVAL; 110830f712c9SDave Chinner goto trans_cancel; 110930f712c9SDave Chinner } 111030f712c9SDave Chinner 111130f712c9SDave Chinner ASSERT(ip->i_afp == NULL); 111230f712c9SDave Chinner ip->i_afp = kmem_zone_zalloc(xfs_ifork_zone, KM_SLEEP); 111330f712c9SDave Chinner ip->i_afp->if_flags = XFS_IFEXTENTS; 111430f712c9SDave Chinner logflags = 0; 11152c3234d1SDarrick J. Wong xfs_defer_init(&dfops, &firstblock); 111630f712c9SDave Chinner switch (ip->i_d.di_format) { 111730f712c9SDave Chinner case XFS_DINODE_FMT_LOCAL: 11182c3234d1SDarrick J. Wong error = xfs_bmap_add_attrfork_local(tp, ip, &firstblock, &dfops, 111930f712c9SDave Chinner &logflags); 112030f712c9SDave Chinner break; 112130f712c9SDave Chinner case XFS_DINODE_FMT_EXTENTS: 112230f712c9SDave Chinner error = xfs_bmap_add_attrfork_extents(tp, ip, &firstblock, 11232c3234d1SDarrick J. Wong &dfops, &logflags); 112430f712c9SDave Chinner break; 112530f712c9SDave Chinner case XFS_DINODE_FMT_BTREE: 11262c3234d1SDarrick J. Wong error = xfs_bmap_add_attrfork_btree(tp, ip, &firstblock, &dfops, 112730f712c9SDave Chinner &logflags); 112830f712c9SDave Chinner break; 112930f712c9SDave Chinner default: 113030f712c9SDave Chinner error = 0; 113130f712c9SDave Chinner break; 113230f712c9SDave Chinner } 113330f712c9SDave Chinner if (logflags) 113430f712c9SDave Chinner xfs_trans_log_inode(tp, ip, logflags); 113530f712c9SDave Chinner if (error) 113630f712c9SDave Chinner goto bmap_cancel; 113730f712c9SDave Chinner if (!xfs_sb_version_hasattr(&mp->m_sb) || 113830f712c9SDave Chinner (!xfs_sb_version_hasattr2(&mp->m_sb) && version == 2)) { 113961e63ecbSDave Chinner bool log_sb = false; 114030f712c9SDave Chinner 114130f712c9SDave Chinner spin_lock(&mp->m_sb_lock); 114230f712c9SDave Chinner if (!xfs_sb_version_hasattr(&mp->m_sb)) { 114330f712c9SDave Chinner xfs_sb_version_addattr(&mp->m_sb); 114461e63ecbSDave Chinner log_sb = true; 114530f712c9SDave Chinner } 114630f712c9SDave Chinner if (!xfs_sb_version_hasattr2(&mp->m_sb) && version == 2) { 114730f712c9SDave Chinner xfs_sb_version_addattr2(&mp->m_sb); 114861e63ecbSDave Chinner log_sb = true; 114930f712c9SDave Chinner } 115030f712c9SDave Chinner spin_unlock(&mp->m_sb_lock); 115161e63ecbSDave Chinner if (log_sb) 115261e63ecbSDave Chinner xfs_log_sb(tp); 115330f712c9SDave Chinner } 115430f712c9SDave Chinner 11558ad7c629SChristoph Hellwig error = xfs_defer_finish(&tp, &dfops); 115630f712c9SDave Chinner if (error) 115730f712c9SDave Chinner goto bmap_cancel; 115870393313SChristoph Hellwig error = xfs_trans_commit(tp); 115930f712c9SDave Chinner xfs_iunlock(ip, XFS_ILOCK_EXCL); 116030f712c9SDave Chinner return error; 116130f712c9SDave Chinner 116230f712c9SDave Chinner bmap_cancel: 11632c3234d1SDarrick J. Wong xfs_defer_cancel(&dfops); 116430f712c9SDave Chinner trans_cancel: 11654906e215SChristoph Hellwig xfs_trans_cancel(tp); 116630f712c9SDave Chinner xfs_iunlock(ip, XFS_ILOCK_EXCL); 116730f712c9SDave Chinner return error; 116830f712c9SDave Chinner } 116930f712c9SDave Chinner 117030f712c9SDave Chinner /* 117130f712c9SDave Chinner * Internal and external extent tree search functions. 117230f712c9SDave Chinner */ 117330f712c9SDave Chinner 117430f712c9SDave Chinner /* 1175211e95bbSChristoph Hellwig * Read in extents from a btree-format inode. 117630f712c9SDave Chinner */ 1177211e95bbSChristoph Hellwig int 1178211e95bbSChristoph Hellwig xfs_iread_extents( 1179211e95bbSChristoph Hellwig struct xfs_trans *tp, 1180211e95bbSChristoph Hellwig struct xfs_inode *ip, 1181211e95bbSChristoph Hellwig int whichfork) 118230f712c9SDave Chinner { 1183211e95bbSChristoph Hellwig struct xfs_mount *mp = ip->i_mount; 1184e8e0e170SChristoph Hellwig int state = xfs_bmap_fork_to_state(whichfork); 1185211e95bbSChristoph Hellwig struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, whichfork); 1186211e95bbSChristoph Hellwig xfs_extnum_t nextents = XFS_IFORK_NEXTENTS(ip, whichfork); 1187211e95bbSChristoph Hellwig struct xfs_btree_block *block = ifp->if_broot; 1188b2b1712aSChristoph Hellwig struct xfs_iext_cursor icur; 11896bdcf26aSChristoph Hellwig struct xfs_bmbt_irec new; 1190211e95bbSChristoph Hellwig xfs_fsblock_t bno; 1191211e95bbSChristoph Hellwig struct xfs_buf *bp; 1192211e95bbSChristoph Hellwig xfs_extnum_t i, j; 1193211e95bbSChristoph Hellwig int level; 1194211e95bbSChristoph Hellwig __be64 *pp; 1195211e95bbSChristoph Hellwig int error; 119630f712c9SDave Chinner 1197211e95bbSChristoph Hellwig ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL)); 1198211e95bbSChristoph Hellwig 1199211e95bbSChristoph Hellwig if (unlikely(XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE)) { 1200211e95bbSChristoph Hellwig XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_LOW, mp); 1201211e95bbSChristoph Hellwig return -EFSCORRUPTED; 1202211e95bbSChristoph Hellwig } 1203211e95bbSChristoph Hellwig 120430f712c9SDave Chinner /* 120530f712c9SDave Chinner * Root level must use BMAP_BROOT_PTR_ADDR macro to get ptr out. 120630f712c9SDave Chinner */ 120730f712c9SDave Chinner level = be16_to_cpu(block->bb_level); 120830f712c9SDave Chinner ASSERT(level > 0); 120930f712c9SDave Chinner pp = XFS_BMAP_BROOT_PTR_ADDR(mp, block, 1, ifp->if_broot_bytes); 121030f712c9SDave Chinner bno = be64_to_cpu(*pp); 1211d5a91baeSDarrick J. Wong 121230f712c9SDave Chinner /* 121330f712c9SDave Chinner * Go down the tree until leaf level is reached, following the first 121430f712c9SDave Chinner * pointer (leftmost) at each level. 121530f712c9SDave Chinner */ 121630f712c9SDave Chinner while (level-- > 0) { 121730f712c9SDave Chinner error = xfs_btree_read_bufl(mp, tp, bno, 0, &bp, 121830f712c9SDave Chinner XFS_BMAP_BTREE_REF, &xfs_bmbt_buf_ops); 121930f712c9SDave Chinner if (error) 1220211e95bbSChristoph Hellwig goto out; 122130f712c9SDave Chinner block = XFS_BUF_TO_BLOCK(bp); 122230f712c9SDave Chinner if (level == 0) 122330f712c9SDave Chinner break; 122430f712c9SDave Chinner pp = XFS_BMBT_PTR_ADDR(mp, block, 1, mp->m_bmap_dmxr[1]); 122530f712c9SDave Chinner bno = be64_to_cpu(*pp); 1226c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, 122759f6fec3SDarrick J. Wong xfs_verify_fsbno(mp, bno), out_brelse); 122830f712c9SDave Chinner xfs_trans_brelse(tp, bp); 122930f712c9SDave Chinner } 1230211e95bbSChristoph Hellwig 123130f712c9SDave Chinner /* 123230f712c9SDave Chinner * Here with bp and block set to the leftmost leaf node in the tree. 123330f712c9SDave Chinner */ 123430f712c9SDave Chinner i = 0; 1235b2b1712aSChristoph Hellwig xfs_iext_first(ifp, &icur); 1236211e95bbSChristoph Hellwig 123730f712c9SDave Chinner /* 123830f712c9SDave Chinner * Loop over all leaf nodes. Copy information to the extent records. 123930f712c9SDave Chinner */ 124030f712c9SDave Chinner for (;;) { 124130f712c9SDave Chinner xfs_bmbt_rec_t *frp; 124230f712c9SDave Chinner xfs_fsblock_t nextbno; 124330f712c9SDave Chinner xfs_extnum_t num_recs; 124430f712c9SDave Chinner 124530f712c9SDave Chinner num_recs = xfs_btree_get_numrecs(block); 1246211e95bbSChristoph Hellwig if (unlikely(i + num_recs > nextents)) { 1247211e95bbSChristoph Hellwig ASSERT(i + num_recs <= nextents); 124830f712c9SDave Chinner xfs_warn(ip->i_mount, 124930f712c9SDave Chinner "corrupt dinode %Lu, (btree extents).", 125030f712c9SDave Chinner (unsigned long long) ip->i_ino); 125190a58f95SDarrick J. Wong xfs_inode_verifier_error(ip, -EFSCORRUPTED, 125290a58f95SDarrick J. Wong __func__, block, sizeof(*block), 125390a58f95SDarrick J. Wong __this_address); 1254211e95bbSChristoph Hellwig error = -EFSCORRUPTED; 1255211e95bbSChristoph Hellwig goto out_brelse; 125630f712c9SDave Chinner } 125730f712c9SDave Chinner /* 125830f712c9SDave Chinner * Read-ahead the next leaf block, if any. 125930f712c9SDave Chinner */ 126030f712c9SDave Chinner nextbno = be64_to_cpu(block->bb_u.l.bb_rightsib); 126130f712c9SDave Chinner if (nextbno != NULLFSBLOCK) 126230f712c9SDave Chinner xfs_btree_reada_bufl(mp, nextbno, 1, 126330f712c9SDave Chinner &xfs_bmbt_buf_ops); 126430f712c9SDave Chinner /* 126530f712c9SDave Chinner * Copy records into the extent records. 126630f712c9SDave Chinner */ 126730f712c9SDave Chinner frp = XFS_BMBT_REC_ADDR(mp, block, 1); 12686bdcf26aSChristoph Hellwig for (j = 0; j < num_recs; j++, frp++, i++) { 126930b0984dSDarrick J. Wong xfs_failaddr_t fa; 127030b0984dSDarrick J. Wong 1271dac9c9b1SChristoph Hellwig xfs_bmbt_disk_get_all(frp, &new); 127230b0984dSDarrick J. Wong fa = xfs_bmap_validate_extent(ip, whichfork, &new); 127330b0984dSDarrick J. Wong if (fa) { 1274211e95bbSChristoph Hellwig error = -EFSCORRUPTED; 127530b0984dSDarrick J. Wong xfs_inode_verifier_error(ip, error, 127630b0984dSDarrick J. Wong "xfs_iread_extents(2)", 127730b0984dSDarrick J. Wong frp, sizeof(*frp), fa); 1278211e95bbSChristoph Hellwig goto out_brelse; 127930f712c9SDave Chinner } 12800254c2f2SChristoph Hellwig xfs_iext_insert(ip, &icur, &new, state); 1281b2b1712aSChristoph Hellwig trace_xfs_read_extent(ip, &icur, state, _THIS_IP_); 1282b2b1712aSChristoph Hellwig xfs_iext_next(ifp, &icur); 128330f712c9SDave Chinner } 128430f712c9SDave Chinner xfs_trans_brelse(tp, bp); 128530f712c9SDave Chinner bno = nextbno; 128630f712c9SDave Chinner /* 128730f712c9SDave Chinner * If we've reached the end, stop. 128830f712c9SDave Chinner */ 128930f712c9SDave Chinner if (bno == NULLFSBLOCK) 129030f712c9SDave Chinner break; 129130f712c9SDave Chinner error = xfs_btree_read_bufl(mp, tp, bno, 0, &bp, 129230f712c9SDave Chinner XFS_BMAP_BTREE_REF, &xfs_bmbt_buf_ops); 129330f712c9SDave Chinner if (error) 1294211e95bbSChristoph Hellwig goto out; 129530f712c9SDave Chinner block = XFS_BUF_TO_BLOCK(bp); 129630f712c9SDave Chinner } 1297211e95bbSChristoph Hellwig 1298211e95bbSChristoph Hellwig if (i != XFS_IFORK_NEXTENTS(ip, whichfork)) { 1299211e95bbSChristoph Hellwig error = -EFSCORRUPTED; 1300211e95bbSChristoph Hellwig goto out; 1301211e95bbSChristoph Hellwig } 13025d829300SEric Sandeen ASSERT(i == xfs_iext_count(ifp)); 1303211e95bbSChristoph Hellwig 1304211e95bbSChristoph Hellwig ifp->if_flags |= XFS_IFEXTENTS; 130530f712c9SDave Chinner return 0; 1306211e95bbSChristoph Hellwig 1307211e95bbSChristoph Hellwig out_brelse: 130830f712c9SDave Chinner xfs_trans_brelse(tp, bp); 1309211e95bbSChristoph Hellwig out: 1310211e95bbSChristoph Hellwig xfs_iext_destroy(ifp); 1311211e95bbSChristoph Hellwig return error; 131230f712c9SDave Chinner } 131330f712c9SDave Chinner 131430f712c9SDave Chinner /* 131529b3e94aSChristoph Hellwig * Returns the relative block number of the first unused block(s) in the given 131629b3e94aSChristoph Hellwig * fork with at least "len" logically contiguous blocks free. This is the 131729b3e94aSChristoph Hellwig * lowest-address hole if the fork has holes, else the first block past the end 131829b3e94aSChristoph Hellwig * of fork. Return 0 if the fork is currently local (in-inode). 131930f712c9SDave Chinner */ 132030f712c9SDave Chinner int /* error */ 132130f712c9SDave Chinner xfs_bmap_first_unused( 132229b3e94aSChristoph Hellwig struct xfs_trans *tp, /* transaction pointer */ 132329b3e94aSChristoph Hellwig struct xfs_inode *ip, /* incore inode */ 132430f712c9SDave Chinner xfs_extlen_t len, /* size of hole to find */ 132530f712c9SDave Chinner xfs_fileoff_t *first_unused, /* unused block */ 132630f712c9SDave Chinner int whichfork) /* data or attr fork */ 132730f712c9SDave Chinner { 132829b3e94aSChristoph Hellwig struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, whichfork); 132929b3e94aSChristoph Hellwig struct xfs_bmbt_irec got; 1330b2b1712aSChristoph Hellwig struct xfs_iext_cursor icur; 133129b3e94aSChristoph Hellwig xfs_fileoff_t lastaddr = 0; 133229b3e94aSChristoph Hellwig xfs_fileoff_t lowest, max; 133329b3e94aSChristoph Hellwig int error; 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); 133829b3e94aSChristoph Hellwig 133930f712c9SDave Chinner if (XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_LOCAL) { 134030f712c9SDave Chinner *first_unused = 0; 134130f712c9SDave Chinner return 0; 134230f712c9SDave Chinner } 134329b3e94aSChristoph Hellwig 134429b3e94aSChristoph Hellwig if (!(ifp->if_flags & XFS_IFEXTENTS)) { 134529b3e94aSChristoph Hellwig error = xfs_iread_extents(tp, ip, whichfork); 134629b3e94aSChristoph Hellwig if (error) 134730f712c9SDave Chinner return error; 134829b3e94aSChristoph Hellwig } 1349f2285c14SChristoph Hellwig 135029b3e94aSChristoph Hellwig lowest = max = *first_unused; 1351b2b1712aSChristoph Hellwig for_each_xfs_iext(ifp, &icur, &got) { 135230f712c9SDave Chinner /* 135330f712c9SDave Chinner * See if the hole before this extent will work. 135430f712c9SDave Chinner */ 1355f2285c14SChristoph Hellwig if (got.br_startoff >= lowest + len && 135629b3e94aSChristoph Hellwig got.br_startoff - max >= len) 135729b3e94aSChristoph Hellwig break; 1358f2285c14SChristoph Hellwig lastaddr = got.br_startoff + got.br_blockcount; 135930f712c9SDave Chinner max = XFS_FILEOFF_MAX(lastaddr, lowest); 136030f712c9SDave Chinner } 136129b3e94aSChristoph Hellwig 136230f712c9SDave Chinner *first_unused = max; 136330f712c9SDave Chinner return 0; 136430f712c9SDave Chinner } 136530f712c9SDave Chinner 136630f712c9SDave Chinner /* 136730f712c9SDave Chinner * Returns the file-relative block number of the last block - 1 before 136830f712c9SDave Chinner * last_block (input value) in the file. 136930f712c9SDave Chinner * This is not based on i_size, it is based on the extent records. 137030f712c9SDave Chinner * Returns 0 for local files, as they do not have extent records. 137130f712c9SDave Chinner */ 137230f712c9SDave Chinner int /* error */ 137330f712c9SDave Chinner xfs_bmap_last_before( 137486685f7bSChristoph Hellwig struct xfs_trans *tp, /* transaction pointer */ 137586685f7bSChristoph Hellwig struct xfs_inode *ip, /* incore inode */ 137630f712c9SDave Chinner xfs_fileoff_t *last_block, /* last block */ 137730f712c9SDave Chinner int whichfork) /* data or attr fork */ 137830f712c9SDave Chinner { 137986685f7bSChristoph Hellwig struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, whichfork); 138086685f7bSChristoph Hellwig struct xfs_bmbt_irec got; 1381b2b1712aSChristoph Hellwig struct xfs_iext_cursor icur; 138286685f7bSChristoph Hellwig int error; 138330f712c9SDave Chinner 138486685f7bSChristoph Hellwig switch (XFS_IFORK_FORMAT(ip, whichfork)) { 138586685f7bSChristoph Hellwig case XFS_DINODE_FMT_LOCAL: 138630f712c9SDave Chinner *last_block = 0; 138730f712c9SDave Chinner return 0; 138886685f7bSChristoph Hellwig case XFS_DINODE_FMT_BTREE: 138986685f7bSChristoph Hellwig case XFS_DINODE_FMT_EXTENTS: 139086685f7bSChristoph Hellwig break; 139186685f7bSChristoph Hellwig default: 139286685f7bSChristoph Hellwig return -EIO; 139330f712c9SDave Chinner } 139486685f7bSChristoph Hellwig 139586685f7bSChristoph Hellwig if (!(ifp->if_flags & XFS_IFEXTENTS)) { 139686685f7bSChristoph Hellwig error = xfs_iread_extents(tp, ip, whichfork); 139786685f7bSChristoph Hellwig if (error) 139830f712c9SDave Chinner return error; 139930f712c9SDave Chinner } 140086685f7bSChristoph Hellwig 1401b2b1712aSChristoph Hellwig if (!xfs_iext_lookup_extent_before(ip, ifp, last_block, &icur, &got)) 140286685f7bSChristoph Hellwig *last_block = 0; 140330f712c9SDave Chinner return 0; 140430f712c9SDave Chinner } 140530f712c9SDave Chinner 140630f712c9SDave Chinner int 140730f712c9SDave Chinner xfs_bmap_last_extent( 140830f712c9SDave Chinner struct xfs_trans *tp, 140930f712c9SDave Chinner struct xfs_inode *ip, 141030f712c9SDave Chinner int whichfork, 141130f712c9SDave Chinner struct xfs_bmbt_irec *rec, 141230f712c9SDave Chinner int *is_empty) 141330f712c9SDave Chinner { 141430f712c9SDave Chinner struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, whichfork); 1415b2b1712aSChristoph Hellwig struct xfs_iext_cursor icur; 141630f712c9SDave Chinner int error; 141730f712c9SDave Chinner 141830f712c9SDave Chinner if (!(ifp->if_flags & XFS_IFEXTENTS)) { 141930f712c9SDave Chinner error = xfs_iread_extents(tp, ip, whichfork); 142030f712c9SDave Chinner if (error) 142130f712c9SDave Chinner return error; 142230f712c9SDave Chinner } 142330f712c9SDave Chinner 1424b2b1712aSChristoph Hellwig xfs_iext_last(ifp, &icur); 1425b2b1712aSChristoph Hellwig if (!xfs_iext_get_extent(ifp, &icur, rec)) 142630f712c9SDave Chinner *is_empty = 1; 1427b2b1712aSChristoph Hellwig else 142830f712c9SDave Chinner *is_empty = 0; 142930f712c9SDave Chinner return 0; 143030f712c9SDave Chinner } 143130f712c9SDave Chinner 143230f712c9SDave Chinner /* 143330f712c9SDave Chinner * Check the last inode extent to determine whether this allocation will result 143430f712c9SDave Chinner * in blocks being allocated at the end of the file. When we allocate new data 143530f712c9SDave Chinner * blocks at the end of the file which do not start at the previous data block, 143630f712c9SDave Chinner * we will try to align the new blocks at stripe unit boundaries. 143730f712c9SDave Chinner * 143830f712c9SDave Chinner * Returns 1 in bma->aeof if the file (fork) is empty as any new write will be 143930f712c9SDave Chinner * at, or past the EOF. 144030f712c9SDave Chinner */ 144130f712c9SDave Chinner STATIC int 144230f712c9SDave Chinner xfs_bmap_isaeof( 144330f712c9SDave Chinner struct xfs_bmalloca *bma, 144430f712c9SDave Chinner int whichfork) 144530f712c9SDave Chinner { 144630f712c9SDave Chinner struct xfs_bmbt_irec rec; 144730f712c9SDave Chinner int is_empty; 144830f712c9SDave Chinner int error; 144930f712c9SDave Chinner 1450749f24f3SThomas Meyer bma->aeof = false; 145130f712c9SDave Chinner error = xfs_bmap_last_extent(NULL, bma->ip, whichfork, &rec, 145230f712c9SDave Chinner &is_empty); 145330f712c9SDave Chinner if (error) 145430f712c9SDave Chinner return error; 145530f712c9SDave Chinner 145630f712c9SDave Chinner if (is_empty) { 1457749f24f3SThomas Meyer bma->aeof = true; 145830f712c9SDave Chinner return 0; 145930f712c9SDave Chinner } 146030f712c9SDave Chinner 146130f712c9SDave Chinner /* 146230f712c9SDave Chinner * Check if we are allocation or past the last extent, or at least into 146330f712c9SDave Chinner * the last delayed allocated extent. 146430f712c9SDave Chinner */ 146530f712c9SDave Chinner bma->aeof = bma->offset >= rec.br_startoff + rec.br_blockcount || 146630f712c9SDave Chinner (bma->offset >= rec.br_startoff && 146730f712c9SDave Chinner isnullstartblock(rec.br_startblock)); 146830f712c9SDave Chinner return 0; 146930f712c9SDave Chinner } 147030f712c9SDave Chinner 147130f712c9SDave Chinner /* 147230f712c9SDave Chinner * Returns the file-relative block number of the first block past eof in 147330f712c9SDave Chinner * the file. This is not based on i_size, it is based on the extent records. 147430f712c9SDave Chinner * Returns 0 for local files, as they do not have extent records. 147530f712c9SDave Chinner */ 147630f712c9SDave Chinner int 147730f712c9SDave Chinner xfs_bmap_last_offset( 147830f712c9SDave Chinner struct xfs_inode *ip, 147930f712c9SDave Chinner xfs_fileoff_t *last_block, 148030f712c9SDave Chinner int whichfork) 148130f712c9SDave Chinner { 148230f712c9SDave Chinner struct xfs_bmbt_irec rec; 148330f712c9SDave Chinner int is_empty; 148430f712c9SDave Chinner int error; 148530f712c9SDave Chinner 148630f712c9SDave Chinner *last_block = 0; 148730f712c9SDave Chinner 148830f712c9SDave Chinner if (XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_LOCAL) 148930f712c9SDave Chinner return 0; 149030f712c9SDave Chinner 149130f712c9SDave Chinner if (XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE && 149230f712c9SDave Chinner XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS) 14932451337dSDave Chinner return -EIO; 149430f712c9SDave Chinner 149530f712c9SDave Chinner error = xfs_bmap_last_extent(NULL, ip, whichfork, &rec, &is_empty); 149630f712c9SDave Chinner if (error || is_empty) 149730f712c9SDave Chinner return error; 149830f712c9SDave Chinner 149930f712c9SDave Chinner *last_block = rec.br_startoff + rec.br_blockcount; 150030f712c9SDave Chinner return 0; 150130f712c9SDave Chinner } 150230f712c9SDave Chinner 150330f712c9SDave Chinner /* 150430f712c9SDave Chinner * Returns whether the selected fork of the inode has exactly one 150530f712c9SDave Chinner * block or not. For the data fork we check this matches di_size, 150630f712c9SDave Chinner * implying the file's range is 0..bsize-1. 150730f712c9SDave Chinner */ 150830f712c9SDave Chinner int /* 1=>1 block, 0=>otherwise */ 150930f712c9SDave Chinner xfs_bmap_one_block( 151030f712c9SDave Chinner xfs_inode_t *ip, /* incore inode */ 151130f712c9SDave Chinner int whichfork) /* data or attr fork */ 151230f712c9SDave Chinner { 151330f712c9SDave Chinner xfs_ifork_t *ifp; /* inode fork pointer */ 151430f712c9SDave Chinner int rval; /* return value */ 151530f712c9SDave Chinner xfs_bmbt_irec_t s; /* internal version of extent */ 1516b2b1712aSChristoph Hellwig struct xfs_iext_cursor icur; 151730f712c9SDave Chinner 151830f712c9SDave Chinner #ifndef DEBUG 151930f712c9SDave Chinner if (whichfork == XFS_DATA_FORK) 152030f712c9SDave Chinner return XFS_ISIZE(ip) == ip->i_mount->m_sb.sb_blocksize; 152130f712c9SDave Chinner #endif /* !DEBUG */ 152230f712c9SDave Chinner if (XFS_IFORK_NEXTENTS(ip, whichfork) != 1) 152330f712c9SDave Chinner return 0; 152430f712c9SDave Chinner if (XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS) 152530f712c9SDave Chinner return 0; 152630f712c9SDave Chinner ifp = XFS_IFORK_PTR(ip, whichfork); 152730f712c9SDave Chinner ASSERT(ifp->if_flags & XFS_IFEXTENTS); 1528b2b1712aSChristoph Hellwig xfs_iext_first(ifp, &icur); 1529b2b1712aSChristoph Hellwig xfs_iext_get_extent(ifp, &icur, &s); 153030f712c9SDave Chinner rval = s.br_startoff == 0 && s.br_blockcount == 1; 153130f712c9SDave Chinner if (rval && whichfork == XFS_DATA_FORK) 153230f712c9SDave Chinner ASSERT(XFS_ISIZE(ip) == ip->i_mount->m_sb.sb_blocksize); 153330f712c9SDave Chinner return rval; 153430f712c9SDave Chinner } 153530f712c9SDave Chinner 153630f712c9SDave Chinner /* 153730f712c9SDave Chinner * Extent tree manipulation functions used during allocation. 153830f712c9SDave Chinner */ 153930f712c9SDave Chinner 154030f712c9SDave Chinner /* 154130f712c9SDave Chinner * Convert a delayed allocation to a real allocation. 154230f712c9SDave Chinner */ 154330f712c9SDave Chinner STATIC int /* error */ 154430f712c9SDave Chinner xfs_bmap_add_extent_delay_real( 154560b4984fSDarrick J. Wong struct xfs_bmalloca *bma, 154660b4984fSDarrick J. Wong int whichfork) 154730f712c9SDave Chinner { 154830f712c9SDave Chinner struct xfs_bmbt_irec *new = &bma->got; 154930f712c9SDave Chinner int error; /* error return value */ 155030f712c9SDave Chinner int i; /* temp state */ 155130f712c9SDave Chinner xfs_ifork_t *ifp; /* inode fork pointer */ 155230f712c9SDave Chinner xfs_fileoff_t new_endoff; /* end offset of new entry */ 155330f712c9SDave Chinner xfs_bmbt_irec_t r[3]; /* neighbor extent entries */ 155430f712c9SDave Chinner /* left is 0, right is 1, prev is 2 */ 155530f712c9SDave Chinner int rval=0; /* return value (logging flags) */ 1556060ea65bSChristoph Hellwig int state = xfs_bmap_fork_to_state(whichfork); 155730f712c9SDave Chinner xfs_filblks_t da_new; /* new count del alloc blocks used */ 155830f712c9SDave Chinner xfs_filblks_t da_old; /* old count del alloc blocks used */ 155930f712c9SDave Chinner xfs_filblks_t temp=0; /* value for da_new calculations */ 156030f712c9SDave Chinner int tmp_rval; /* partial logging flags */ 1561c29aad41SEric Sandeen struct xfs_mount *mp; 156260b4984fSDarrick J. Wong xfs_extnum_t *nextents; 15634dcb8869SChristoph Hellwig struct xfs_bmbt_irec old; 156430f712c9SDave Chinner 1565f1f96c49SEric Sandeen mp = bma->ip->i_mount; 15666d3eb1ecSDarrick J. Wong ifp = XFS_IFORK_PTR(bma->ip, whichfork); 156760b4984fSDarrick J. Wong ASSERT(whichfork != XFS_ATTR_FORK); 156860b4984fSDarrick J. Wong nextents = (whichfork == XFS_COW_FORK ? &bma->ip->i_cnextents : 156960b4984fSDarrick J. Wong &bma->ip->i_d.di_nextents); 157030f712c9SDave Chinner 157130f712c9SDave Chinner ASSERT(!isnullstartblock(new->br_startblock)); 157230f712c9SDave Chinner ASSERT(!bma->cur || 157330f712c9SDave Chinner (bma->cur->bc_private.b.flags & XFS_BTCUR_BPRV_WASDEL)); 157430f712c9SDave Chinner 1575ff6d6af2SBill O'Donnell XFS_STATS_INC(mp, xs_add_exlist); 157630f712c9SDave Chinner 157730f712c9SDave Chinner #define LEFT r[0] 157830f712c9SDave Chinner #define RIGHT r[1] 157930f712c9SDave Chinner #define PREV r[2] 158030f712c9SDave Chinner 158130f712c9SDave Chinner /* 158230f712c9SDave Chinner * Set up a bunch of variables to make the tests simpler. 158330f712c9SDave Chinner */ 1584b2b1712aSChristoph Hellwig xfs_iext_get_extent(ifp, &bma->icur, &PREV); 158530f712c9SDave Chinner new_endoff = new->br_startoff + new->br_blockcount; 15864dcb8869SChristoph Hellwig ASSERT(isnullstartblock(PREV.br_startblock)); 158730f712c9SDave Chinner ASSERT(PREV.br_startoff <= new->br_startoff); 158830f712c9SDave Chinner ASSERT(PREV.br_startoff + PREV.br_blockcount >= new_endoff); 158930f712c9SDave Chinner 159030f712c9SDave Chinner da_old = startblockval(PREV.br_startblock); 159130f712c9SDave Chinner da_new = 0; 159230f712c9SDave Chinner 159330f712c9SDave Chinner /* 159430f712c9SDave Chinner * Set flags determining what part of the previous delayed allocation 159530f712c9SDave Chinner * extent is being replaced by a real allocation. 159630f712c9SDave Chinner */ 159730f712c9SDave Chinner if (PREV.br_startoff == new->br_startoff) 159830f712c9SDave Chinner state |= BMAP_LEFT_FILLING; 159930f712c9SDave Chinner if (PREV.br_startoff + PREV.br_blockcount == new_endoff) 160030f712c9SDave Chinner state |= BMAP_RIGHT_FILLING; 160130f712c9SDave Chinner 160230f712c9SDave Chinner /* 160330f712c9SDave Chinner * Check and set flags if this segment has a left neighbor. 160430f712c9SDave Chinner * Don't set contiguous if the combined extent would be too large. 160530f712c9SDave Chinner */ 1606b2b1712aSChristoph Hellwig if (xfs_iext_peek_prev_extent(ifp, &bma->icur, &LEFT)) { 160730f712c9SDave Chinner state |= BMAP_LEFT_VALID; 160830f712c9SDave Chinner if (isnullstartblock(LEFT.br_startblock)) 160930f712c9SDave Chinner state |= BMAP_LEFT_DELAY; 161030f712c9SDave Chinner } 161130f712c9SDave Chinner 161230f712c9SDave Chinner if ((state & BMAP_LEFT_VALID) && !(state & BMAP_LEFT_DELAY) && 161330f712c9SDave Chinner LEFT.br_startoff + LEFT.br_blockcount == new->br_startoff && 161430f712c9SDave Chinner LEFT.br_startblock + LEFT.br_blockcount == new->br_startblock && 161530f712c9SDave Chinner LEFT.br_state == new->br_state && 161630f712c9SDave Chinner LEFT.br_blockcount + new->br_blockcount <= MAXEXTLEN) 161730f712c9SDave Chinner state |= BMAP_LEFT_CONTIG; 161830f712c9SDave Chinner 161930f712c9SDave Chinner /* 162030f712c9SDave Chinner * Check and set flags if this segment has a right neighbor. 162130f712c9SDave Chinner * Don't set contiguous if the combined extent would be too large. 162230f712c9SDave Chinner * Also check for all-three-contiguous being too large. 162330f712c9SDave Chinner */ 1624b2b1712aSChristoph Hellwig if (xfs_iext_peek_next_extent(ifp, &bma->icur, &RIGHT)) { 162530f712c9SDave Chinner state |= BMAP_RIGHT_VALID; 162630f712c9SDave Chinner if (isnullstartblock(RIGHT.br_startblock)) 162730f712c9SDave Chinner state |= BMAP_RIGHT_DELAY; 162830f712c9SDave Chinner } 162930f712c9SDave Chinner 163030f712c9SDave Chinner if ((state & BMAP_RIGHT_VALID) && !(state & BMAP_RIGHT_DELAY) && 163130f712c9SDave Chinner new_endoff == RIGHT.br_startoff && 163230f712c9SDave Chinner new->br_startblock + new->br_blockcount == RIGHT.br_startblock && 163330f712c9SDave Chinner new->br_state == RIGHT.br_state && 163430f712c9SDave Chinner new->br_blockcount + RIGHT.br_blockcount <= MAXEXTLEN && 163530f712c9SDave Chinner ((state & (BMAP_LEFT_CONTIG | BMAP_LEFT_FILLING | 163630f712c9SDave Chinner BMAP_RIGHT_FILLING)) != 163730f712c9SDave Chinner (BMAP_LEFT_CONTIG | BMAP_LEFT_FILLING | 163830f712c9SDave Chinner BMAP_RIGHT_FILLING) || 163930f712c9SDave Chinner LEFT.br_blockcount + new->br_blockcount + RIGHT.br_blockcount 164030f712c9SDave Chinner <= MAXEXTLEN)) 164130f712c9SDave Chinner state |= BMAP_RIGHT_CONTIG; 164230f712c9SDave Chinner 164330f712c9SDave Chinner error = 0; 164430f712c9SDave Chinner /* 164530f712c9SDave Chinner * Switch out based on the FILLING and CONTIG state bits. 164630f712c9SDave Chinner */ 164730f712c9SDave Chinner switch (state & (BMAP_LEFT_FILLING | BMAP_LEFT_CONTIG | 164830f712c9SDave Chinner BMAP_RIGHT_FILLING | BMAP_RIGHT_CONTIG)) { 164930f712c9SDave Chinner case BMAP_LEFT_FILLING | BMAP_LEFT_CONTIG | 165030f712c9SDave Chinner BMAP_RIGHT_FILLING | BMAP_RIGHT_CONTIG: 165130f712c9SDave Chinner /* 165230f712c9SDave Chinner * Filling in all of a previously delayed allocation extent. 165330f712c9SDave Chinner * The left and right neighbors are both contiguous with new. 165430f712c9SDave Chinner */ 16554dcb8869SChristoph Hellwig LEFT.br_blockcount += PREV.br_blockcount + RIGHT.br_blockcount; 165630f712c9SDave Chinner 1657c38ccf59SChristoph Hellwig xfs_iext_remove(bma->ip, &bma->icur, state); 1658c38ccf59SChristoph Hellwig xfs_iext_remove(bma->ip, &bma->icur, state); 1659b2b1712aSChristoph Hellwig xfs_iext_prev(ifp, &bma->icur); 1660b2b1712aSChristoph Hellwig xfs_iext_update_extent(bma->ip, state, &bma->icur, &LEFT); 166160b4984fSDarrick J. Wong (*nextents)--; 16620d045540SChristoph Hellwig 166330f712c9SDave Chinner if (bma->cur == NULL) 166430f712c9SDave Chinner rval = XFS_ILOG_CORE | XFS_ILOG_DEXT; 166530f712c9SDave Chinner else { 166630f712c9SDave Chinner rval = XFS_ILOG_CORE; 1667e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(bma->cur, &RIGHT, &i); 166830f712c9SDave Chinner if (error) 166930f712c9SDave Chinner goto done; 1670c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 167130f712c9SDave Chinner error = xfs_btree_delete(bma->cur, &i); 167230f712c9SDave Chinner if (error) 167330f712c9SDave Chinner goto done; 1674c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 167530f712c9SDave Chinner error = xfs_btree_decrement(bma->cur, 0, &i); 167630f712c9SDave Chinner if (error) 167730f712c9SDave Chinner goto done; 1678c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 1679a67d00a5SChristoph Hellwig error = xfs_bmbt_update(bma->cur, &LEFT); 168030f712c9SDave Chinner if (error) 168130f712c9SDave Chinner goto done; 168230f712c9SDave Chinner } 168330f712c9SDave Chinner break; 168430f712c9SDave Chinner 168530f712c9SDave Chinner case BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING | BMAP_LEFT_CONTIG: 168630f712c9SDave Chinner /* 168730f712c9SDave Chinner * Filling in all of a previously delayed allocation extent. 168830f712c9SDave Chinner * The left neighbor is contiguous, the right is not. 168930f712c9SDave Chinner */ 16904dcb8869SChristoph Hellwig old = LEFT; 16914dcb8869SChristoph Hellwig LEFT.br_blockcount += PREV.br_blockcount; 16920d045540SChristoph Hellwig 1693c38ccf59SChristoph Hellwig xfs_iext_remove(bma->ip, &bma->icur, state); 1694b2b1712aSChristoph Hellwig xfs_iext_prev(ifp, &bma->icur); 1695b2b1712aSChristoph Hellwig xfs_iext_update_extent(bma->ip, state, &bma->icur, &LEFT); 169630f712c9SDave Chinner 169730f712c9SDave Chinner if (bma->cur == NULL) 169830f712c9SDave Chinner rval = XFS_ILOG_DEXT; 169930f712c9SDave Chinner else { 170030f712c9SDave Chinner rval = 0; 1701e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(bma->cur, &old, &i); 170230f712c9SDave Chinner if (error) 170330f712c9SDave Chinner goto done; 1704c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 1705a67d00a5SChristoph Hellwig error = xfs_bmbt_update(bma->cur, &LEFT); 170630f712c9SDave Chinner if (error) 170730f712c9SDave Chinner goto done; 170830f712c9SDave Chinner } 170930f712c9SDave Chinner break; 171030f712c9SDave Chinner 171130f712c9SDave Chinner case BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING | BMAP_RIGHT_CONTIG: 171230f712c9SDave Chinner /* 171330f712c9SDave Chinner * Filling in all of a previously delayed allocation extent. 171430f712c9SDave Chinner * The right neighbor is contiguous, the left is not. 171530f712c9SDave Chinner */ 17164dcb8869SChristoph Hellwig PREV.br_startblock = new->br_startblock; 17174dcb8869SChristoph Hellwig PREV.br_blockcount += RIGHT.br_blockcount; 17180d045540SChristoph Hellwig 1719b2b1712aSChristoph Hellwig xfs_iext_next(ifp, &bma->icur); 1720c38ccf59SChristoph Hellwig xfs_iext_remove(bma->ip, &bma->icur, state); 1721b2b1712aSChristoph Hellwig xfs_iext_prev(ifp, &bma->icur); 1722b2b1712aSChristoph Hellwig xfs_iext_update_extent(bma->ip, state, &bma->icur, &PREV); 172330f712c9SDave Chinner 172430f712c9SDave Chinner if (bma->cur == NULL) 172530f712c9SDave Chinner rval = XFS_ILOG_DEXT; 172630f712c9SDave Chinner else { 172730f712c9SDave Chinner rval = 0; 1728e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(bma->cur, &RIGHT, &i); 172930f712c9SDave Chinner if (error) 173030f712c9SDave Chinner goto done; 1731c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 1732a67d00a5SChristoph Hellwig error = xfs_bmbt_update(bma->cur, &PREV); 173330f712c9SDave Chinner if (error) 173430f712c9SDave Chinner goto done; 173530f712c9SDave Chinner } 173630f712c9SDave Chinner break; 173730f712c9SDave Chinner 173830f712c9SDave Chinner case BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING: 173930f712c9SDave Chinner /* 174030f712c9SDave Chinner * Filling in all of a previously delayed allocation extent. 174130f712c9SDave Chinner * Neither the left nor right neighbors are contiguous with 174230f712c9SDave Chinner * the new one. 174330f712c9SDave Chinner */ 17444dcb8869SChristoph Hellwig PREV.br_startblock = new->br_startblock; 17454dcb8869SChristoph Hellwig PREV.br_state = new->br_state; 1746b2b1712aSChristoph Hellwig xfs_iext_update_extent(bma->ip, state, &bma->icur, &PREV); 174730f712c9SDave Chinner 174860b4984fSDarrick J. Wong (*nextents)++; 174930f712c9SDave Chinner if (bma->cur == NULL) 175030f712c9SDave Chinner rval = XFS_ILOG_CORE | XFS_ILOG_DEXT; 175130f712c9SDave Chinner else { 175230f712c9SDave Chinner rval = XFS_ILOG_CORE; 1753e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(bma->cur, new, &i); 175430f712c9SDave Chinner if (error) 175530f712c9SDave Chinner goto done; 1756c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 0, done); 175730f712c9SDave Chinner error = xfs_btree_insert(bma->cur, &i); 175830f712c9SDave Chinner if (error) 175930f712c9SDave Chinner goto done; 1760c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 176130f712c9SDave Chinner } 176230f712c9SDave Chinner break; 176330f712c9SDave Chinner 176430f712c9SDave Chinner case BMAP_LEFT_FILLING | BMAP_LEFT_CONTIG: 176530f712c9SDave Chinner /* 176630f712c9SDave Chinner * Filling in the first part of a previous delayed allocation. 176730f712c9SDave Chinner * The left neighbor is contiguous. 176830f712c9SDave Chinner */ 17694dcb8869SChristoph Hellwig old = LEFT; 17704dcb8869SChristoph Hellwig temp = PREV.br_blockcount - new->br_blockcount; 17714dcb8869SChristoph Hellwig da_new = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(bma->ip, temp), 17724dcb8869SChristoph Hellwig startblockval(PREV.br_startblock)); 17734dcb8869SChristoph Hellwig 17744dcb8869SChristoph Hellwig LEFT.br_blockcount += new->br_blockcount; 177530f712c9SDave Chinner 1776bf99971cSChristoph Hellwig PREV.br_blockcount = temp; 17774dcb8869SChristoph Hellwig PREV.br_startoff += new->br_blockcount; 17784dcb8869SChristoph Hellwig PREV.br_startblock = nullstartblock(da_new); 17790d045540SChristoph Hellwig 1780b2b1712aSChristoph Hellwig xfs_iext_update_extent(bma->ip, state, &bma->icur, &PREV); 1781b2b1712aSChristoph Hellwig xfs_iext_prev(ifp, &bma->icur); 1782b2b1712aSChristoph Hellwig xfs_iext_update_extent(bma->ip, state, &bma->icur, &LEFT); 17834dcb8869SChristoph Hellwig 178430f712c9SDave Chinner if (bma->cur == NULL) 178530f712c9SDave Chinner rval = XFS_ILOG_DEXT; 178630f712c9SDave Chinner else { 178730f712c9SDave Chinner rval = 0; 1788e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(bma->cur, &old, &i); 178930f712c9SDave Chinner if (error) 179030f712c9SDave Chinner goto done; 1791c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 1792a67d00a5SChristoph Hellwig error = xfs_bmbt_update(bma->cur, &LEFT); 179330f712c9SDave Chinner if (error) 179430f712c9SDave Chinner goto done; 179530f712c9SDave Chinner } 179630f712c9SDave Chinner break; 179730f712c9SDave Chinner 179830f712c9SDave Chinner case BMAP_LEFT_FILLING: 179930f712c9SDave Chinner /* 180030f712c9SDave Chinner * Filling in the first part of a previous delayed allocation. 180130f712c9SDave Chinner * The left neighbor is not contiguous. 180230f712c9SDave Chinner */ 1803b2b1712aSChristoph Hellwig xfs_iext_update_extent(bma->ip, state, &bma->icur, new); 180460b4984fSDarrick J. Wong (*nextents)++; 180530f712c9SDave Chinner if (bma->cur == NULL) 180630f712c9SDave Chinner rval = XFS_ILOG_CORE | XFS_ILOG_DEXT; 180730f712c9SDave Chinner else { 180830f712c9SDave Chinner rval = XFS_ILOG_CORE; 1809e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(bma->cur, new, &i); 181030f712c9SDave Chinner if (error) 181130f712c9SDave Chinner goto done; 1812c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 0, done); 181330f712c9SDave Chinner error = xfs_btree_insert(bma->cur, &i); 181430f712c9SDave Chinner if (error) 181530f712c9SDave Chinner goto done; 1816c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 181730f712c9SDave Chinner } 181830f712c9SDave Chinner 18196d3eb1ecSDarrick J. Wong if (xfs_bmap_needs_btree(bma->ip, whichfork)) { 182030f712c9SDave Chinner error = xfs_bmap_extents_to_btree(bma->tp, bma->ip, 18212c3234d1SDarrick J. Wong bma->firstblock, bma->dfops, 18226d3eb1ecSDarrick J. Wong &bma->cur, 1, &tmp_rval, whichfork); 182330f712c9SDave Chinner rval |= tmp_rval; 182430f712c9SDave Chinner if (error) 182530f712c9SDave Chinner goto done; 182630f712c9SDave Chinner } 18274dcb8869SChristoph Hellwig 18284dcb8869SChristoph Hellwig temp = PREV.br_blockcount - new->br_blockcount; 182930f712c9SDave Chinner da_new = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(bma->ip, temp), 183030f712c9SDave Chinner startblockval(PREV.br_startblock) - 183130f712c9SDave Chinner (bma->cur ? bma->cur->bc_private.b.allocated : 0)); 18324dcb8869SChristoph Hellwig 18334dcb8869SChristoph Hellwig PREV.br_startoff = new_endoff; 18344dcb8869SChristoph Hellwig PREV.br_blockcount = temp; 18354dcb8869SChristoph Hellwig PREV.br_startblock = nullstartblock(da_new); 1836b2b1712aSChristoph Hellwig xfs_iext_next(ifp, &bma->icur); 18370254c2f2SChristoph Hellwig xfs_iext_insert(bma->ip, &bma->icur, &PREV, state); 1838b2b1712aSChristoph Hellwig xfs_iext_prev(ifp, &bma->icur); 183930f712c9SDave Chinner break; 184030f712c9SDave Chinner 184130f712c9SDave Chinner case BMAP_RIGHT_FILLING | BMAP_RIGHT_CONTIG: 184230f712c9SDave Chinner /* 184330f712c9SDave Chinner * Filling in the last part of a previous delayed allocation. 184430f712c9SDave Chinner * The right neighbor is contiguous with the new allocation. 184530f712c9SDave Chinner */ 18464dcb8869SChristoph Hellwig old = RIGHT; 18474dcb8869SChristoph Hellwig RIGHT.br_startoff = new->br_startoff; 18484dcb8869SChristoph Hellwig RIGHT.br_startblock = new->br_startblock; 18494dcb8869SChristoph Hellwig RIGHT.br_blockcount += new->br_blockcount; 18504dcb8869SChristoph Hellwig 185130f712c9SDave Chinner if (bma->cur == NULL) 185230f712c9SDave Chinner rval = XFS_ILOG_DEXT; 185330f712c9SDave Chinner else { 185430f712c9SDave Chinner rval = 0; 1855e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(bma->cur, &old, &i); 185630f712c9SDave Chinner if (error) 185730f712c9SDave Chinner goto done; 1858c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 1859a67d00a5SChristoph Hellwig error = xfs_bmbt_update(bma->cur, &RIGHT); 186030f712c9SDave Chinner if (error) 186130f712c9SDave Chinner goto done; 186230f712c9SDave Chinner } 186330f712c9SDave Chinner 18644dcb8869SChristoph Hellwig temp = PREV.br_blockcount - new->br_blockcount; 186530f712c9SDave Chinner da_new = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(bma->ip, temp), 186630f712c9SDave Chinner startblockval(PREV.br_startblock)); 18674dcb8869SChristoph Hellwig 18684dcb8869SChristoph Hellwig PREV.br_blockcount = temp; 18694dcb8869SChristoph Hellwig PREV.br_startblock = nullstartblock(da_new); 187030f712c9SDave Chinner 1871b2b1712aSChristoph Hellwig xfs_iext_update_extent(bma->ip, state, &bma->icur, &PREV); 1872b2b1712aSChristoph Hellwig xfs_iext_next(ifp, &bma->icur); 1873b2b1712aSChristoph Hellwig xfs_iext_update_extent(bma->ip, state, &bma->icur, &RIGHT); 187430f712c9SDave Chinner break; 187530f712c9SDave Chinner 187630f712c9SDave Chinner case BMAP_RIGHT_FILLING: 187730f712c9SDave Chinner /* 187830f712c9SDave Chinner * Filling in the last part of a previous delayed allocation. 187930f712c9SDave Chinner * The right neighbor is not contiguous. 188030f712c9SDave Chinner */ 1881b2b1712aSChristoph Hellwig xfs_iext_update_extent(bma->ip, state, &bma->icur, new); 188260b4984fSDarrick J. Wong (*nextents)++; 188330f712c9SDave Chinner if (bma->cur == NULL) 188430f712c9SDave Chinner rval = XFS_ILOG_CORE | XFS_ILOG_DEXT; 188530f712c9SDave Chinner else { 188630f712c9SDave Chinner rval = XFS_ILOG_CORE; 1887e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(bma->cur, new, &i); 188830f712c9SDave Chinner if (error) 188930f712c9SDave Chinner goto done; 1890c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 0, done); 189130f712c9SDave Chinner error = xfs_btree_insert(bma->cur, &i); 189230f712c9SDave Chinner if (error) 189330f712c9SDave Chinner goto done; 1894c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 189530f712c9SDave Chinner } 189630f712c9SDave Chinner 18976d3eb1ecSDarrick J. Wong if (xfs_bmap_needs_btree(bma->ip, whichfork)) { 189830f712c9SDave Chinner error = xfs_bmap_extents_to_btree(bma->tp, bma->ip, 18992c3234d1SDarrick J. Wong bma->firstblock, bma->dfops, &bma->cur, 1, 19006d3eb1ecSDarrick J. Wong &tmp_rval, whichfork); 190130f712c9SDave Chinner rval |= tmp_rval; 190230f712c9SDave Chinner if (error) 190330f712c9SDave Chinner goto done; 190430f712c9SDave Chinner } 19054dcb8869SChristoph Hellwig 19064dcb8869SChristoph Hellwig temp = PREV.br_blockcount - new->br_blockcount; 190730f712c9SDave Chinner da_new = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(bma->ip, temp), 190830f712c9SDave Chinner startblockval(PREV.br_startblock) - 190930f712c9SDave Chinner (bma->cur ? bma->cur->bc_private.b.allocated : 0)); 19104dcb8869SChristoph Hellwig 19114dcb8869SChristoph Hellwig PREV.br_startblock = nullstartblock(da_new); 19124dcb8869SChristoph Hellwig PREV.br_blockcount = temp; 19130254c2f2SChristoph Hellwig xfs_iext_insert(bma->ip, &bma->icur, &PREV, state); 1914b2b1712aSChristoph Hellwig xfs_iext_next(ifp, &bma->icur); 191530f712c9SDave Chinner break; 191630f712c9SDave Chinner 191730f712c9SDave Chinner case 0: 191830f712c9SDave Chinner /* 191930f712c9SDave Chinner * Filling in the middle part of a previous delayed allocation. 192030f712c9SDave Chinner * Contiguity is impossible here. 192130f712c9SDave Chinner * This case is avoided almost all the time. 192230f712c9SDave Chinner * 192330f712c9SDave Chinner * We start with a delayed allocation: 192430f712c9SDave Chinner * 192530f712c9SDave Chinner * +ddddddddddddddddddddddddddddddddddddddddddddddddddddddd+ 192630f712c9SDave Chinner * PREV @ idx 192730f712c9SDave Chinner * 192830f712c9SDave Chinner * and we are allocating: 192930f712c9SDave Chinner * +rrrrrrrrrrrrrrrrr+ 193030f712c9SDave Chinner * new 193130f712c9SDave Chinner * 193230f712c9SDave Chinner * and we set it up for insertion as: 193330f712c9SDave Chinner * +ddddddddddddddddddd+rrrrrrrrrrrrrrrrr+ddddddddddddddddd+ 193430f712c9SDave Chinner * new 193530f712c9SDave Chinner * PREV @ idx LEFT RIGHT 193630f712c9SDave Chinner * inserted at idx + 1 193730f712c9SDave Chinner */ 19384dcb8869SChristoph Hellwig old = PREV; 19394dcb8869SChristoph Hellwig 19404dcb8869SChristoph Hellwig /* LEFT is the new middle */ 194130f712c9SDave Chinner LEFT = *new; 19424dcb8869SChristoph Hellwig 19434dcb8869SChristoph Hellwig /* RIGHT is the new right */ 194430f712c9SDave Chinner RIGHT.br_state = PREV.br_state; 194530f712c9SDave Chinner RIGHT.br_startoff = new_endoff; 19464dcb8869SChristoph Hellwig RIGHT.br_blockcount = 19474dcb8869SChristoph Hellwig PREV.br_startoff + PREV.br_blockcount - new_endoff; 19484dcb8869SChristoph Hellwig RIGHT.br_startblock = 19494dcb8869SChristoph Hellwig nullstartblock(xfs_bmap_worst_indlen(bma->ip, 19504dcb8869SChristoph Hellwig RIGHT.br_blockcount)); 19514dcb8869SChristoph Hellwig 19524dcb8869SChristoph Hellwig /* truncate PREV */ 19534dcb8869SChristoph Hellwig PREV.br_blockcount = new->br_startoff - PREV.br_startoff; 19544dcb8869SChristoph Hellwig PREV.br_startblock = 19554dcb8869SChristoph Hellwig nullstartblock(xfs_bmap_worst_indlen(bma->ip, 19564dcb8869SChristoph Hellwig PREV.br_blockcount)); 1957b2b1712aSChristoph Hellwig xfs_iext_update_extent(bma->ip, state, &bma->icur, &PREV); 19584dcb8869SChristoph Hellwig 1959b2b1712aSChristoph Hellwig xfs_iext_next(ifp, &bma->icur); 19600254c2f2SChristoph Hellwig xfs_iext_insert(bma->ip, &bma->icur, &RIGHT, state); 19610254c2f2SChristoph Hellwig xfs_iext_insert(bma->ip, &bma->icur, &LEFT, state); 196260b4984fSDarrick J. Wong (*nextents)++; 19634dcb8869SChristoph Hellwig 196430f712c9SDave Chinner if (bma->cur == NULL) 196530f712c9SDave Chinner rval = XFS_ILOG_CORE | XFS_ILOG_DEXT; 196630f712c9SDave Chinner else { 196730f712c9SDave Chinner rval = XFS_ILOG_CORE; 1968e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(bma->cur, new, &i); 196930f712c9SDave Chinner if (error) 197030f712c9SDave Chinner goto done; 1971c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 0, done); 197230f712c9SDave Chinner error = xfs_btree_insert(bma->cur, &i); 197330f712c9SDave Chinner if (error) 197430f712c9SDave Chinner goto done; 1975c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 197630f712c9SDave Chinner } 197730f712c9SDave Chinner 19786d3eb1ecSDarrick J. Wong if (xfs_bmap_needs_btree(bma->ip, whichfork)) { 197930f712c9SDave Chinner error = xfs_bmap_extents_to_btree(bma->tp, bma->ip, 19802c3234d1SDarrick J. Wong bma->firstblock, bma->dfops, &bma->cur, 19816d3eb1ecSDarrick J. Wong 1, &tmp_rval, whichfork); 198230f712c9SDave Chinner rval |= tmp_rval; 198330f712c9SDave Chinner if (error) 198430f712c9SDave Chinner goto done; 198530f712c9SDave Chinner } 19864dcb8869SChristoph Hellwig 19874dcb8869SChristoph Hellwig da_new = startblockval(PREV.br_startblock) + 19884dcb8869SChristoph Hellwig startblockval(RIGHT.br_startblock); 198930f712c9SDave Chinner break; 199030f712c9SDave Chinner 199130f712c9SDave Chinner case BMAP_LEFT_FILLING | BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG: 199230f712c9SDave Chinner case BMAP_RIGHT_FILLING | BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG: 199330f712c9SDave Chinner case BMAP_LEFT_FILLING | BMAP_RIGHT_CONTIG: 199430f712c9SDave Chinner case BMAP_RIGHT_FILLING | BMAP_LEFT_CONTIG: 199530f712c9SDave Chinner case BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG: 199630f712c9SDave Chinner case BMAP_LEFT_CONTIG: 199730f712c9SDave Chinner case BMAP_RIGHT_CONTIG: 199830f712c9SDave Chinner /* 199930f712c9SDave Chinner * These cases are all impossible. 200030f712c9SDave Chinner */ 200130f712c9SDave Chinner ASSERT(0); 200230f712c9SDave Chinner } 200330f712c9SDave Chinner 20049c194644SDarrick J. Wong /* add reverse mapping */ 20059c194644SDarrick J. Wong error = xfs_rmap_map_extent(mp, bma->dfops, bma->ip, whichfork, new); 20069c194644SDarrick J. Wong if (error) 20079c194644SDarrick J. Wong goto done; 20089c194644SDarrick J. Wong 200930f712c9SDave Chinner /* convert to a btree if necessary */ 20106d3eb1ecSDarrick J. Wong if (xfs_bmap_needs_btree(bma->ip, whichfork)) { 201130f712c9SDave Chinner int tmp_logflags; /* partial log flag return val */ 201230f712c9SDave Chinner 201330f712c9SDave Chinner ASSERT(bma->cur == NULL); 201430f712c9SDave Chinner error = xfs_bmap_extents_to_btree(bma->tp, bma->ip, 20152c3234d1SDarrick J. Wong bma->firstblock, bma->dfops, &bma->cur, 20166d3eb1ecSDarrick J. Wong da_old > 0, &tmp_logflags, whichfork); 201730f712c9SDave Chinner bma->logflags |= tmp_logflags; 201830f712c9SDave Chinner if (error) 201930f712c9SDave Chinner goto done; 202030f712c9SDave Chinner } 202130f712c9SDave Chinner 2022ca1862b0SChristoph Hellwig if (bma->cur) { 2023ca1862b0SChristoph Hellwig da_new += bma->cur->bc_private.b.allocated; 2024ca1862b0SChristoph Hellwig bma->cur->bc_private.b.allocated = 0; 202530f712c9SDave Chinner } 202630f712c9SDave Chinner 2027ca1862b0SChristoph Hellwig /* adjust for changes in reserved delayed indirect blocks */ 2028ca1862b0SChristoph Hellwig if (da_new != da_old) { 2029ca1862b0SChristoph Hellwig ASSERT(state == 0 || da_new < da_old); 2030ca1862b0SChristoph Hellwig error = xfs_mod_fdblocks(mp, (int64_t)(da_old - da_new), 2031ca1862b0SChristoph Hellwig false); 2032ca1862b0SChristoph Hellwig } 203330f712c9SDave Chinner 20346d3eb1ecSDarrick J. Wong xfs_bmap_check_leaf_extents(bma->cur, bma->ip, whichfork); 203530f712c9SDave Chinner done: 203660b4984fSDarrick J. Wong if (whichfork != XFS_COW_FORK) 203730f712c9SDave Chinner bma->logflags |= rval; 203830f712c9SDave Chinner return error; 203930f712c9SDave Chinner #undef LEFT 204030f712c9SDave Chinner #undef RIGHT 204130f712c9SDave Chinner #undef PREV 204230f712c9SDave Chinner } 204330f712c9SDave Chinner 204430f712c9SDave Chinner /* 204530f712c9SDave Chinner * Convert an unwritten allocation to a real allocation or vice versa. 204630f712c9SDave Chinner */ 204730f712c9SDave Chinner STATIC int /* error */ 204830f712c9SDave Chinner xfs_bmap_add_extent_unwritten_real( 204930f712c9SDave Chinner struct xfs_trans *tp, 205030f712c9SDave Chinner xfs_inode_t *ip, /* incore inode pointer */ 205105a630d7SDarrick J. Wong int whichfork, 2052b2b1712aSChristoph Hellwig struct xfs_iext_cursor *icur, 205330f712c9SDave Chinner xfs_btree_cur_t **curp, /* if *curp is null, not a btree */ 205430f712c9SDave Chinner xfs_bmbt_irec_t *new, /* new data to add to file extents */ 205530f712c9SDave Chinner xfs_fsblock_t *first, /* pointer to firstblock variable */ 20562c3234d1SDarrick J. Wong struct xfs_defer_ops *dfops, /* list of extents to be freed */ 205730f712c9SDave Chinner int *logflagsp) /* inode logging flags */ 205830f712c9SDave Chinner { 205930f712c9SDave Chinner xfs_btree_cur_t *cur; /* btree cursor */ 206030f712c9SDave Chinner int error; /* error return value */ 206130f712c9SDave Chinner int i; /* temp state */ 206230f712c9SDave Chinner xfs_ifork_t *ifp; /* inode fork pointer */ 206330f712c9SDave Chinner xfs_fileoff_t new_endoff; /* end offset of new entry */ 206430f712c9SDave Chinner xfs_bmbt_irec_t r[3]; /* neighbor extent entries */ 206530f712c9SDave Chinner /* left is 0, right is 1, prev is 2 */ 206630f712c9SDave Chinner int rval=0; /* return value (logging flags) */ 2067060ea65bSChristoph Hellwig int state = xfs_bmap_fork_to_state(whichfork); 206805a630d7SDarrick J. Wong struct xfs_mount *mp = ip->i_mount; 206979fa6143SChristoph Hellwig struct xfs_bmbt_irec old; 207030f712c9SDave Chinner 207130f712c9SDave Chinner *logflagsp = 0; 207230f712c9SDave Chinner 207330f712c9SDave Chinner cur = *curp; 207405a630d7SDarrick J. Wong ifp = XFS_IFORK_PTR(ip, whichfork); 207530f712c9SDave Chinner 207630f712c9SDave Chinner ASSERT(!isnullstartblock(new->br_startblock)); 207730f712c9SDave Chinner 2078ff6d6af2SBill O'Donnell XFS_STATS_INC(mp, xs_add_exlist); 207930f712c9SDave Chinner 208030f712c9SDave Chinner #define LEFT r[0] 208130f712c9SDave Chinner #define RIGHT r[1] 208230f712c9SDave Chinner #define PREV r[2] 208330f712c9SDave Chinner 208430f712c9SDave Chinner /* 208530f712c9SDave Chinner * Set up a bunch of variables to make the tests simpler. 208630f712c9SDave Chinner */ 208730f712c9SDave Chinner error = 0; 2088b2b1712aSChristoph Hellwig xfs_iext_get_extent(ifp, icur, &PREV); 208979fa6143SChristoph Hellwig ASSERT(new->br_state != PREV.br_state); 209030f712c9SDave Chinner new_endoff = new->br_startoff + new->br_blockcount; 209130f712c9SDave Chinner ASSERT(PREV.br_startoff <= new->br_startoff); 209230f712c9SDave Chinner ASSERT(PREV.br_startoff + PREV.br_blockcount >= new_endoff); 209330f712c9SDave Chinner 209430f712c9SDave Chinner /* 209530f712c9SDave Chinner * Set flags determining what part of the previous oldext allocation 209630f712c9SDave Chinner * extent is being replaced by a newext allocation. 209730f712c9SDave Chinner */ 209830f712c9SDave Chinner if (PREV.br_startoff == new->br_startoff) 209930f712c9SDave Chinner state |= BMAP_LEFT_FILLING; 210030f712c9SDave Chinner if (PREV.br_startoff + PREV.br_blockcount == new_endoff) 210130f712c9SDave Chinner state |= BMAP_RIGHT_FILLING; 210230f712c9SDave Chinner 210330f712c9SDave Chinner /* 210430f712c9SDave Chinner * Check and set flags if this segment has a left neighbor. 210530f712c9SDave Chinner * Don't set contiguous if the combined extent would be too large. 210630f712c9SDave Chinner */ 2107b2b1712aSChristoph Hellwig if (xfs_iext_peek_prev_extent(ifp, icur, &LEFT)) { 210830f712c9SDave Chinner state |= BMAP_LEFT_VALID; 210930f712c9SDave Chinner if (isnullstartblock(LEFT.br_startblock)) 211030f712c9SDave Chinner state |= BMAP_LEFT_DELAY; 211130f712c9SDave Chinner } 211230f712c9SDave Chinner 211330f712c9SDave Chinner if ((state & BMAP_LEFT_VALID) && !(state & BMAP_LEFT_DELAY) && 211430f712c9SDave Chinner LEFT.br_startoff + LEFT.br_blockcount == new->br_startoff && 211530f712c9SDave Chinner LEFT.br_startblock + LEFT.br_blockcount == new->br_startblock && 211679fa6143SChristoph Hellwig LEFT.br_state == new->br_state && 211730f712c9SDave Chinner LEFT.br_blockcount + new->br_blockcount <= MAXEXTLEN) 211830f712c9SDave Chinner state |= BMAP_LEFT_CONTIG; 211930f712c9SDave Chinner 212030f712c9SDave Chinner /* 212130f712c9SDave Chinner * Check and set flags if this segment has a right neighbor. 212230f712c9SDave Chinner * Don't set contiguous if the combined extent would be too large. 212330f712c9SDave Chinner * Also check for all-three-contiguous being too large. 212430f712c9SDave Chinner */ 2125b2b1712aSChristoph Hellwig if (xfs_iext_peek_next_extent(ifp, icur, &RIGHT)) { 212630f712c9SDave Chinner state |= BMAP_RIGHT_VALID; 212730f712c9SDave Chinner if (isnullstartblock(RIGHT.br_startblock)) 212830f712c9SDave Chinner state |= BMAP_RIGHT_DELAY; 212930f712c9SDave Chinner } 213030f712c9SDave Chinner 213130f712c9SDave Chinner if ((state & BMAP_RIGHT_VALID) && !(state & BMAP_RIGHT_DELAY) && 213230f712c9SDave Chinner new_endoff == RIGHT.br_startoff && 213330f712c9SDave Chinner new->br_startblock + new->br_blockcount == RIGHT.br_startblock && 213479fa6143SChristoph Hellwig new->br_state == RIGHT.br_state && 213530f712c9SDave Chinner new->br_blockcount + RIGHT.br_blockcount <= MAXEXTLEN && 213630f712c9SDave Chinner ((state & (BMAP_LEFT_CONTIG | BMAP_LEFT_FILLING | 213730f712c9SDave Chinner BMAP_RIGHT_FILLING)) != 213830f712c9SDave Chinner (BMAP_LEFT_CONTIG | BMAP_LEFT_FILLING | 213930f712c9SDave Chinner BMAP_RIGHT_FILLING) || 214030f712c9SDave Chinner LEFT.br_blockcount + new->br_blockcount + RIGHT.br_blockcount 214130f712c9SDave Chinner <= MAXEXTLEN)) 214230f712c9SDave Chinner state |= BMAP_RIGHT_CONTIG; 214330f712c9SDave Chinner 214430f712c9SDave Chinner /* 214530f712c9SDave Chinner * Switch out based on the FILLING and CONTIG state bits. 214630f712c9SDave Chinner */ 214730f712c9SDave Chinner switch (state & (BMAP_LEFT_FILLING | BMAP_LEFT_CONTIG | 214830f712c9SDave Chinner BMAP_RIGHT_FILLING | BMAP_RIGHT_CONTIG)) { 214930f712c9SDave Chinner case BMAP_LEFT_FILLING | BMAP_LEFT_CONTIG | 215030f712c9SDave Chinner BMAP_RIGHT_FILLING | BMAP_RIGHT_CONTIG: 215130f712c9SDave Chinner /* 215230f712c9SDave Chinner * Setting all of a previous oldext extent to newext. 215330f712c9SDave Chinner * The left and right neighbors are both contiguous with new. 215430f712c9SDave Chinner */ 215579fa6143SChristoph Hellwig LEFT.br_blockcount += PREV.br_blockcount + RIGHT.br_blockcount; 215630f712c9SDave Chinner 2157c38ccf59SChristoph Hellwig xfs_iext_remove(ip, icur, state); 2158c38ccf59SChristoph Hellwig xfs_iext_remove(ip, icur, state); 2159b2b1712aSChristoph Hellwig xfs_iext_prev(ifp, icur); 2160b2b1712aSChristoph Hellwig xfs_iext_update_extent(ip, state, icur, &LEFT); 216105a630d7SDarrick J. Wong XFS_IFORK_NEXT_SET(ip, whichfork, 216205a630d7SDarrick J. Wong XFS_IFORK_NEXTENTS(ip, whichfork) - 2); 216330f712c9SDave Chinner if (cur == NULL) 216430f712c9SDave Chinner rval = XFS_ILOG_CORE | XFS_ILOG_DEXT; 216530f712c9SDave Chinner else { 216630f712c9SDave Chinner rval = XFS_ILOG_CORE; 2167e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(cur, &RIGHT, &i); 2168e16cf9b0SChristoph Hellwig if (error) 216930f712c9SDave Chinner goto done; 2170c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 217130f712c9SDave Chinner if ((error = xfs_btree_delete(cur, &i))) 217230f712c9SDave Chinner goto done; 2173c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 217430f712c9SDave Chinner if ((error = xfs_btree_decrement(cur, 0, &i))) 217530f712c9SDave Chinner goto done; 2176c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 217730f712c9SDave Chinner if ((error = xfs_btree_delete(cur, &i))) 217830f712c9SDave Chinner goto done; 2179c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 218030f712c9SDave Chinner if ((error = xfs_btree_decrement(cur, 0, &i))) 218130f712c9SDave Chinner goto done; 2182c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 2183a67d00a5SChristoph Hellwig error = xfs_bmbt_update(cur, &LEFT); 218479fa6143SChristoph Hellwig if (error) 218530f712c9SDave Chinner goto done; 218630f712c9SDave Chinner } 218730f712c9SDave Chinner break; 218830f712c9SDave Chinner 218930f712c9SDave Chinner case BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING | BMAP_LEFT_CONTIG: 219030f712c9SDave Chinner /* 219130f712c9SDave Chinner * Setting all of a previous oldext extent to newext. 219230f712c9SDave Chinner * The left neighbor is contiguous, the right is not. 219330f712c9SDave Chinner */ 219479fa6143SChristoph Hellwig LEFT.br_blockcount += PREV.br_blockcount; 219530f712c9SDave Chinner 2196c38ccf59SChristoph Hellwig xfs_iext_remove(ip, icur, state); 2197b2b1712aSChristoph Hellwig xfs_iext_prev(ifp, icur); 2198b2b1712aSChristoph Hellwig xfs_iext_update_extent(ip, state, icur, &LEFT); 219905a630d7SDarrick J. Wong XFS_IFORK_NEXT_SET(ip, whichfork, 220005a630d7SDarrick J. Wong XFS_IFORK_NEXTENTS(ip, whichfork) - 1); 220130f712c9SDave Chinner if (cur == NULL) 220230f712c9SDave Chinner rval = XFS_ILOG_CORE | XFS_ILOG_DEXT; 220330f712c9SDave Chinner else { 220430f712c9SDave Chinner rval = XFS_ILOG_CORE; 2205e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(cur, &PREV, &i); 2206e16cf9b0SChristoph Hellwig if (error) 220730f712c9SDave Chinner goto done; 2208c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 220930f712c9SDave Chinner if ((error = xfs_btree_delete(cur, &i))) 221030f712c9SDave Chinner goto done; 2211c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 221230f712c9SDave Chinner if ((error = xfs_btree_decrement(cur, 0, &i))) 221330f712c9SDave Chinner goto done; 2214c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 2215a67d00a5SChristoph Hellwig error = xfs_bmbt_update(cur, &LEFT); 221679fa6143SChristoph Hellwig if (error) 221730f712c9SDave Chinner goto done; 221830f712c9SDave Chinner } 221930f712c9SDave Chinner break; 222030f712c9SDave Chinner 222130f712c9SDave Chinner case BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING | BMAP_RIGHT_CONTIG: 222230f712c9SDave Chinner /* 222330f712c9SDave Chinner * Setting all of a previous oldext extent to newext. 222430f712c9SDave Chinner * The right neighbor is contiguous, the left is not. 222530f712c9SDave Chinner */ 222679fa6143SChristoph Hellwig PREV.br_blockcount += RIGHT.br_blockcount; 222779fa6143SChristoph Hellwig PREV.br_state = new->br_state; 2228a6818477SChristoph Hellwig 2229b2b1712aSChristoph Hellwig xfs_iext_next(ifp, icur); 2230c38ccf59SChristoph Hellwig xfs_iext_remove(ip, icur, state); 2231b2b1712aSChristoph Hellwig xfs_iext_prev(ifp, icur); 2232b2b1712aSChristoph Hellwig xfs_iext_update_extent(ip, state, icur, &PREV); 223379fa6143SChristoph Hellwig 223405a630d7SDarrick J. Wong XFS_IFORK_NEXT_SET(ip, whichfork, 223505a630d7SDarrick J. Wong XFS_IFORK_NEXTENTS(ip, whichfork) - 1); 223630f712c9SDave Chinner if (cur == NULL) 223730f712c9SDave Chinner rval = XFS_ILOG_CORE | XFS_ILOG_DEXT; 223830f712c9SDave Chinner else { 223930f712c9SDave Chinner rval = XFS_ILOG_CORE; 2240e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(cur, &RIGHT, &i); 2241e16cf9b0SChristoph Hellwig if (error) 224230f712c9SDave Chinner goto done; 2243c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 224430f712c9SDave Chinner if ((error = xfs_btree_delete(cur, &i))) 224530f712c9SDave Chinner goto done; 2246c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 224730f712c9SDave Chinner if ((error = xfs_btree_decrement(cur, 0, &i))) 224830f712c9SDave Chinner goto done; 2249c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 2250a67d00a5SChristoph Hellwig error = xfs_bmbt_update(cur, &PREV); 225179fa6143SChristoph Hellwig if (error) 225230f712c9SDave Chinner goto done; 225330f712c9SDave Chinner } 225430f712c9SDave Chinner break; 225530f712c9SDave Chinner 225630f712c9SDave Chinner case BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING: 225730f712c9SDave Chinner /* 225830f712c9SDave Chinner * Setting all of a previous oldext extent to newext. 225930f712c9SDave Chinner * Neither the left nor right neighbors are contiguous with 226030f712c9SDave Chinner * the new one. 226130f712c9SDave Chinner */ 226279fa6143SChristoph Hellwig PREV.br_state = new->br_state; 2263b2b1712aSChristoph Hellwig xfs_iext_update_extent(ip, state, icur, &PREV); 226430f712c9SDave Chinner 226530f712c9SDave Chinner if (cur == NULL) 226630f712c9SDave Chinner rval = XFS_ILOG_DEXT; 226730f712c9SDave Chinner else { 226830f712c9SDave Chinner rval = 0; 2269e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(cur, new, &i); 2270e16cf9b0SChristoph Hellwig if (error) 227130f712c9SDave Chinner goto done; 2272c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 2273a67d00a5SChristoph Hellwig error = xfs_bmbt_update(cur, &PREV); 227479fa6143SChristoph Hellwig if (error) 227530f712c9SDave Chinner goto done; 227630f712c9SDave Chinner } 227730f712c9SDave Chinner break; 227830f712c9SDave Chinner 227930f712c9SDave Chinner case BMAP_LEFT_FILLING | BMAP_LEFT_CONTIG: 228030f712c9SDave Chinner /* 228130f712c9SDave Chinner * Setting the first part of a previous oldext extent to newext. 228230f712c9SDave Chinner * The left neighbor is contiguous. 228330f712c9SDave Chinner */ 228479fa6143SChristoph Hellwig LEFT.br_blockcount += new->br_blockcount; 228530f712c9SDave Chinner 228679fa6143SChristoph Hellwig old = PREV; 228779fa6143SChristoph Hellwig PREV.br_startoff += new->br_blockcount; 228879fa6143SChristoph Hellwig PREV.br_startblock += new->br_blockcount; 228979fa6143SChristoph Hellwig PREV.br_blockcount -= new->br_blockcount; 229030f712c9SDave Chinner 2291b2b1712aSChristoph Hellwig xfs_iext_update_extent(ip, state, icur, &PREV); 2292b2b1712aSChristoph Hellwig xfs_iext_prev(ifp, icur); 2293b2b1712aSChristoph Hellwig xfs_iext_update_extent(ip, state, icur, &LEFT); 229430f712c9SDave Chinner 229530f712c9SDave Chinner if (cur == NULL) 229630f712c9SDave Chinner rval = XFS_ILOG_DEXT; 229730f712c9SDave Chinner else { 229830f712c9SDave Chinner rval = 0; 2299e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(cur, &old, &i); 230079fa6143SChristoph Hellwig if (error) 230130f712c9SDave Chinner goto done; 2302c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 2303a67d00a5SChristoph Hellwig error = xfs_bmbt_update(cur, &PREV); 230479fa6143SChristoph Hellwig if (error) 230530f712c9SDave Chinner goto done; 230679fa6143SChristoph Hellwig error = xfs_btree_decrement(cur, 0, &i); 230779fa6143SChristoph Hellwig if (error) 230830f712c9SDave Chinner goto done; 2309a67d00a5SChristoph Hellwig error = xfs_bmbt_update(cur, &LEFT); 231030f712c9SDave Chinner if (error) 231130f712c9SDave Chinner goto done; 231230f712c9SDave Chinner } 231330f712c9SDave Chinner break; 231430f712c9SDave Chinner 231530f712c9SDave Chinner case BMAP_LEFT_FILLING: 231630f712c9SDave Chinner /* 231730f712c9SDave Chinner * Setting the first part of a previous oldext extent to newext. 231830f712c9SDave Chinner * The left neighbor is not contiguous. 231930f712c9SDave Chinner */ 232079fa6143SChristoph Hellwig old = PREV; 232179fa6143SChristoph Hellwig PREV.br_startoff += new->br_blockcount; 232279fa6143SChristoph Hellwig PREV.br_startblock += new->br_blockcount; 232379fa6143SChristoph Hellwig PREV.br_blockcount -= new->br_blockcount; 232430f712c9SDave Chinner 2325b2b1712aSChristoph Hellwig xfs_iext_update_extent(ip, state, icur, &PREV); 23260254c2f2SChristoph Hellwig xfs_iext_insert(ip, icur, new, state); 232705a630d7SDarrick J. Wong XFS_IFORK_NEXT_SET(ip, whichfork, 232805a630d7SDarrick J. Wong XFS_IFORK_NEXTENTS(ip, whichfork) + 1); 232930f712c9SDave Chinner if (cur == NULL) 233030f712c9SDave Chinner rval = XFS_ILOG_CORE | XFS_ILOG_DEXT; 233130f712c9SDave Chinner else { 233230f712c9SDave Chinner rval = XFS_ILOG_CORE; 2333e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(cur, &old, &i); 233479fa6143SChristoph Hellwig if (error) 233530f712c9SDave Chinner goto done; 2336c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 2337a67d00a5SChristoph Hellwig error = xfs_bmbt_update(cur, &PREV); 233879fa6143SChristoph Hellwig if (error) 233930f712c9SDave Chinner goto done; 234030f712c9SDave Chinner cur->bc_rec.b = *new; 234130f712c9SDave Chinner if ((error = xfs_btree_insert(cur, &i))) 234230f712c9SDave Chinner goto done; 2343c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 234430f712c9SDave Chinner } 234530f712c9SDave Chinner break; 234630f712c9SDave Chinner 234730f712c9SDave Chinner case BMAP_RIGHT_FILLING | BMAP_RIGHT_CONTIG: 234830f712c9SDave Chinner /* 234930f712c9SDave Chinner * Setting the last part of a previous oldext extent to newext. 235030f712c9SDave Chinner * The right neighbor is contiguous with the new allocation. 235130f712c9SDave Chinner */ 235279fa6143SChristoph Hellwig old = PREV; 235379fa6143SChristoph Hellwig PREV.br_blockcount -= new->br_blockcount; 235430f712c9SDave Chinner 235579fa6143SChristoph Hellwig RIGHT.br_startoff = new->br_startoff; 235679fa6143SChristoph Hellwig RIGHT.br_startblock = new->br_startblock; 235779fa6143SChristoph Hellwig RIGHT.br_blockcount += new->br_blockcount; 2358a6818477SChristoph Hellwig 2359b2b1712aSChristoph Hellwig xfs_iext_update_extent(ip, state, icur, &PREV); 2360b2b1712aSChristoph Hellwig xfs_iext_next(ifp, icur); 2361b2b1712aSChristoph Hellwig xfs_iext_update_extent(ip, state, icur, &RIGHT); 236230f712c9SDave Chinner 236330f712c9SDave Chinner if (cur == NULL) 236430f712c9SDave Chinner rval = XFS_ILOG_DEXT; 236530f712c9SDave Chinner else { 236630f712c9SDave Chinner rval = 0; 2367e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(cur, &old, &i); 236879fa6143SChristoph Hellwig if (error) 236930f712c9SDave Chinner goto done; 2370c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 2371a67d00a5SChristoph Hellwig error = xfs_bmbt_update(cur, &PREV); 237279fa6143SChristoph Hellwig if (error) 237330f712c9SDave Chinner goto done; 237479fa6143SChristoph Hellwig error = xfs_btree_increment(cur, 0, &i); 237579fa6143SChristoph Hellwig if (error) 237630f712c9SDave Chinner goto done; 2377a67d00a5SChristoph Hellwig error = xfs_bmbt_update(cur, &RIGHT); 237879fa6143SChristoph Hellwig if (error) 237930f712c9SDave Chinner goto done; 238030f712c9SDave Chinner } 238130f712c9SDave Chinner break; 238230f712c9SDave Chinner 238330f712c9SDave Chinner case BMAP_RIGHT_FILLING: 238430f712c9SDave Chinner /* 238530f712c9SDave Chinner * Setting the last part of a previous oldext extent to newext. 238630f712c9SDave Chinner * The right neighbor is not contiguous. 238730f712c9SDave Chinner */ 238879fa6143SChristoph Hellwig old = PREV; 238979fa6143SChristoph Hellwig PREV.br_blockcount -= new->br_blockcount; 239030f712c9SDave Chinner 2391b2b1712aSChristoph Hellwig xfs_iext_update_extent(ip, state, icur, &PREV); 2392b2b1712aSChristoph Hellwig xfs_iext_next(ifp, icur); 23930254c2f2SChristoph Hellwig xfs_iext_insert(ip, icur, new, state); 239430f712c9SDave Chinner 239505a630d7SDarrick J. Wong XFS_IFORK_NEXT_SET(ip, whichfork, 239605a630d7SDarrick J. Wong XFS_IFORK_NEXTENTS(ip, whichfork) + 1); 239730f712c9SDave Chinner if (cur == NULL) 239830f712c9SDave Chinner rval = XFS_ILOG_CORE | XFS_ILOG_DEXT; 239930f712c9SDave Chinner else { 240030f712c9SDave Chinner rval = XFS_ILOG_CORE; 2401e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(cur, &old, &i); 240279fa6143SChristoph Hellwig if (error) 240330f712c9SDave Chinner goto done; 2404c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 2405a67d00a5SChristoph Hellwig error = xfs_bmbt_update(cur, &PREV); 240679fa6143SChristoph Hellwig if (error) 240730f712c9SDave Chinner goto done; 2408e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(cur, new, &i); 2409e16cf9b0SChristoph Hellwig if (error) 241030f712c9SDave Chinner goto done; 2411c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 0, done); 241230f712c9SDave Chinner if ((error = xfs_btree_insert(cur, &i))) 241330f712c9SDave Chinner goto done; 2414c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 241530f712c9SDave Chinner } 241630f712c9SDave Chinner break; 241730f712c9SDave Chinner 241830f712c9SDave Chinner case 0: 241930f712c9SDave Chinner /* 242030f712c9SDave Chinner * Setting the middle part of a previous oldext extent to 242130f712c9SDave Chinner * newext. Contiguity is impossible here. 242230f712c9SDave Chinner * One extent becomes three extents. 242330f712c9SDave Chinner */ 242479fa6143SChristoph Hellwig old = PREV; 242579fa6143SChristoph Hellwig PREV.br_blockcount = new->br_startoff - PREV.br_startoff; 242630f712c9SDave Chinner 242730f712c9SDave Chinner r[0] = *new; 242830f712c9SDave Chinner r[1].br_startoff = new_endoff; 242930f712c9SDave Chinner r[1].br_blockcount = 243079fa6143SChristoph Hellwig old.br_startoff + old.br_blockcount - new_endoff; 243130f712c9SDave Chinner r[1].br_startblock = new->br_startblock + new->br_blockcount; 243279fa6143SChristoph Hellwig r[1].br_state = PREV.br_state; 243330f712c9SDave Chinner 2434b2b1712aSChristoph Hellwig xfs_iext_update_extent(ip, state, icur, &PREV); 2435b2b1712aSChristoph Hellwig xfs_iext_next(ifp, icur); 24360254c2f2SChristoph Hellwig xfs_iext_insert(ip, icur, &r[1], state); 24370254c2f2SChristoph Hellwig xfs_iext_insert(ip, icur, &r[0], state); 243830f712c9SDave Chinner 243905a630d7SDarrick J. Wong XFS_IFORK_NEXT_SET(ip, whichfork, 244005a630d7SDarrick J. Wong XFS_IFORK_NEXTENTS(ip, whichfork) + 2); 244130f712c9SDave Chinner if (cur == NULL) 244230f712c9SDave Chinner rval = XFS_ILOG_CORE | XFS_ILOG_DEXT; 244330f712c9SDave Chinner else { 244430f712c9SDave Chinner rval = XFS_ILOG_CORE; 2445e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(cur, &old, &i); 244679fa6143SChristoph Hellwig if (error) 244730f712c9SDave Chinner goto done; 2448c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 244930f712c9SDave Chinner /* new right extent - oldext */ 2450a67d00a5SChristoph Hellwig error = xfs_bmbt_update(cur, &r[1]); 2451a67d00a5SChristoph Hellwig if (error) 245230f712c9SDave Chinner goto done; 245330f712c9SDave Chinner /* new left extent - oldext */ 245430f712c9SDave Chinner cur->bc_rec.b = PREV; 245530f712c9SDave Chinner if ((error = xfs_btree_insert(cur, &i))) 245630f712c9SDave Chinner goto done; 2457c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 245830f712c9SDave Chinner /* 245930f712c9SDave Chinner * Reset the cursor to the position of the new extent 246030f712c9SDave Chinner * we are about to insert as we can't trust it after 246130f712c9SDave Chinner * the previous insert. 246230f712c9SDave Chinner */ 2463e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(cur, new, &i); 2464e16cf9b0SChristoph Hellwig if (error) 246530f712c9SDave Chinner goto done; 2466c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 0, done); 246730f712c9SDave Chinner /* new middle extent - newext */ 246830f712c9SDave Chinner if ((error = xfs_btree_insert(cur, &i))) 246930f712c9SDave Chinner goto done; 2470c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 247130f712c9SDave Chinner } 247230f712c9SDave Chinner break; 247330f712c9SDave Chinner 247430f712c9SDave Chinner case BMAP_LEFT_FILLING | BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG: 247530f712c9SDave Chinner case BMAP_RIGHT_FILLING | BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG: 247630f712c9SDave Chinner case BMAP_LEFT_FILLING | BMAP_RIGHT_CONTIG: 247730f712c9SDave Chinner case BMAP_RIGHT_FILLING | BMAP_LEFT_CONTIG: 247830f712c9SDave Chinner case BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG: 247930f712c9SDave Chinner case BMAP_LEFT_CONTIG: 248030f712c9SDave Chinner case BMAP_RIGHT_CONTIG: 248130f712c9SDave Chinner /* 248230f712c9SDave Chinner * These cases are all impossible. 248330f712c9SDave Chinner */ 248430f712c9SDave Chinner ASSERT(0); 248530f712c9SDave Chinner } 248630f712c9SDave Chinner 24879c194644SDarrick J. Wong /* update reverse mappings */ 248805a630d7SDarrick J. Wong error = xfs_rmap_convert_extent(mp, dfops, ip, whichfork, new); 24899c194644SDarrick J. Wong if (error) 24909c194644SDarrick J. Wong goto done; 24919c194644SDarrick J. Wong 249230f712c9SDave Chinner /* convert to a btree if necessary */ 249305a630d7SDarrick J. Wong if (xfs_bmap_needs_btree(ip, whichfork)) { 249430f712c9SDave Chinner int tmp_logflags; /* partial log flag return val */ 249530f712c9SDave Chinner 249630f712c9SDave Chinner ASSERT(cur == NULL); 24972c3234d1SDarrick J. Wong error = xfs_bmap_extents_to_btree(tp, ip, first, dfops, &cur, 249805a630d7SDarrick J. Wong 0, &tmp_logflags, whichfork); 249930f712c9SDave Chinner *logflagsp |= tmp_logflags; 250030f712c9SDave Chinner if (error) 250130f712c9SDave Chinner goto done; 250230f712c9SDave Chinner } 250330f712c9SDave Chinner 250430f712c9SDave Chinner /* clear out the allocated field, done with it now in any case. */ 250530f712c9SDave Chinner if (cur) { 250630f712c9SDave Chinner cur->bc_private.b.allocated = 0; 250730f712c9SDave Chinner *curp = cur; 250830f712c9SDave Chinner } 250930f712c9SDave Chinner 251005a630d7SDarrick J. Wong xfs_bmap_check_leaf_extents(*curp, ip, whichfork); 251130f712c9SDave Chinner done: 251230f712c9SDave Chinner *logflagsp |= rval; 251330f712c9SDave Chinner return error; 251430f712c9SDave Chinner #undef LEFT 251530f712c9SDave Chinner #undef RIGHT 251630f712c9SDave Chinner #undef PREV 251730f712c9SDave Chinner } 251830f712c9SDave Chinner 251930f712c9SDave Chinner /* 252030f712c9SDave Chinner * Convert a hole to a delayed allocation. 252130f712c9SDave Chinner */ 252230f712c9SDave Chinner STATIC void 252330f712c9SDave Chinner xfs_bmap_add_extent_hole_delay( 252430f712c9SDave Chinner xfs_inode_t *ip, /* incore inode pointer */ 2525be51f811SDarrick J. Wong int whichfork, 2526b2b1712aSChristoph Hellwig struct xfs_iext_cursor *icur, 252730f712c9SDave Chinner xfs_bmbt_irec_t *new) /* new data to add to file extents */ 252830f712c9SDave Chinner { 252930f712c9SDave Chinner xfs_ifork_t *ifp; /* inode fork pointer */ 253030f712c9SDave Chinner xfs_bmbt_irec_t left; /* left neighbor extent entry */ 253130f712c9SDave Chinner xfs_filblks_t newlen=0; /* new indirect size */ 253230f712c9SDave Chinner xfs_filblks_t oldlen=0; /* old indirect size */ 253330f712c9SDave Chinner xfs_bmbt_irec_t right; /* right neighbor extent entry */ 2534060ea65bSChristoph Hellwig int state = xfs_bmap_fork_to_state(whichfork); 25353ffc18ecSChristoph Hellwig xfs_filblks_t temp; /* temp for indirect calculations */ 253630f712c9SDave Chinner 2537be51f811SDarrick J. Wong ifp = XFS_IFORK_PTR(ip, whichfork); 253830f712c9SDave Chinner ASSERT(isnullstartblock(new->br_startblock)); 253930f712c9SDave Chinner 254030f712c9SDave Chinner /* 254130f712c9SDave Chinner * Check and set flags if this segment has a left neighbor 254230f712c9SDave Chinner */ 2543b2b1712aSChristoph Hellwig if (xfs_iext_peek_prev_extent(ifp, icur, &left)) { 254430f712c9SDave Chinner state |= BMAP_LEFT_VALID; 254530f712c9SDave Chinner if (isnullstartblock(left.br_startblock)) 254630f712c9SDave Chinner state |= BMAP_LEFT_DELAY; 254730f712c9SDave Chinner } 254830f712c9SDave Chinner 254930f712c9SDave Chinner /* 255030f712c9SDave Chinner * Check and set flags if the current (right) segment exists. 255130f712c9SDave Chinner * If it doesn't exist, we're converting the hole at end-of-file. 255230f712c9SDave Chinner */ 2553b2b1712aSChristoph Hellwig if (xfs_iext_get_extent(ifp, icur, &right)) { 255430f712c9SDave Chinner state |= BMAP_RIGHT_VALID; 255530f712c9SDave Chinner if (isnullstartblock(right.br_startblock)) 255630f712c9SDave Chinner state |= BMAP_RIGHT_DELAY; 255730f712c9SDave Chinner } 255830f712c9SDave Chinner 255930f712c9SDave Chinner /* 256030f712c9SDave Chinner * Set contiguity flags on the left and right neighbors. 256130f712c9SDave Chinner * Don't let extents get too large, even if the pieces are contiguous. 256230f712c9SDave Chinner */ 256330f712c9SDave Chinner if ((state & BMAP_LEFT_VALID) && (state & BMAP_LEFT_DELAY) && 256430f712c9SDave Chinner left.br_startoff + left.br_blockcount == new->br_startoff && 256530f712c9SDave Chinner left.br_blockcount + new->br_blockcount <= MAXEXTLEN) 256630f712c9SDave Chinner state |= BMAP_LEFT_CONTIG; 256730f712c9SDave Chinner 256830f712c9SDave Chinner if ((state & BMAP_RIGHT_VALID) && (state & BMAP_RIGHT_DELAY) && 256930f712c9SDave Chinner new->br_startoff + new->br_blockcount == right.br_startoff && 257030f712c9SDave Chinner new->br_blockcount + right.br_blockcount <= MAXEXTLEN && 257130f712c9SDave Chinner (!(state & BMAP_LEFT_CONTIG) || 257230f712c9SDave Chinner (left.br_blockcount + new->br_blockcount + 257330f712c9SDave Chinner right.br_blockcount <= MAXEXTLEN))) 257430f712c9SDave Chinner state |= BMAP_RIGHT_CONTIG; 257530f712c9SDave Chinner 257630f712c9SDave Chinner /* 257730f712c9SDave Chinner * Switch out based on the contiguity flags. 257830f712c9SDave Chinner */ 257930f712c9SDave Chinner switch (state & (BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG)) { 258030f712c9SDave Chinner case BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG: 258130f712c9SDave Chinner /* 258230f712c9SDave Chinner * New allocation is contiguous with delayed allocations 258330f712c9SDave Chinner * on the left and on the right. 258430f712c9SDave Chinner * Merge all three into a single extent record. 258530f712c9SDave Chinner */ 258630f712c9SDave Chinner temp = left.br_blockcount + new->br_blockcount + 258730f712c9SDave Chinner right.br_blockcount; 258830f712c9SDave Chinner 258930f712c9SDave Chinner oldlen = startblockval(left.br_startblock) + 259030f712c9SDave Chinner startblockval(new->br_startblock) + 259130f712c9SDave Chinner startblockval(right.br_startblock); 25920e339ef8SBrian Foster newlen = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(ip, temp), 25930e339ef8SBrian Foster oldlen); 25943ffc18ecSChristoph Hellwig left.br_startblock = nullstartblock(newlen); 25953ffc18ecSChristoph Hellwig left.br_blockcount = temp; 259630f712c9SDave Chinner 2597c38ccf59SChristoph Hellwig xfs_iext_remove(ip, icur, state); 2598b2b1712aSChristoph Hellwig xfs_iext_prev(ifp, icur); 2599b2b1712aSChristoph Hellwig xfs_iext_update_extent(ip, state, icur, &left); 260030f712c9SDave Chinner break; 260130f712c9SDave Chinner 260230f712c9SDave Chinner case BMAP_LEFT_CONTIG: 260330f712c9SDave Chinner /* 260430f712c9SDave Chinner * New allocation is contiguous with a delayed allocation 260530f712c9SDave Chinner * on the left. 260630f712c9SDave Chinner * Merge the new allocation with the left neighbor. 260730f712c9SDave Chinner */ 260830f712c9SDave Chinner temp = left.br_blockcount + new->br_blockcount; 260930f712c9SDave Chinner 261030f712c9SDave Chinner oldlen = startblockval(left.br_startblock) + 261130f712c9SDave Chinner startblockval(new->br_startblock); 26120e339ef8SBrian Foster newlen = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(ip, temp), 26130e339ef8SBrian Foster oldlen); 26143ffc18ecSChristoph Hellwig left.br_blockcount = temp; 26153ffc18ecSChristoph Hellwig left.br_startblock = nullstartblock(newlen); 261641d196f4SChristoph Hellwig 2617b2b1712aSChristoph Hellwig xfs_iext_prev(ifp, icur); 2618b2b1712aSChristoph Hellwig xfs_iext_update_extent(ip, state, icur, &left); 261930f712c9SDave Chinner break; 262030f712c9SDave Chinner 262130f712c9SDave Chinner case BMAP_RIGHT_CONTIG: 262230f712c9SDave Chinner /* 262330f712c9SDave Chinner * New allocation is contiguous with a delayed allocation 262430f712c9SDave Chinner * on the right. 262530f712c9SDave Chinner * Merge the new allocation with the right neighbor. 262630f712c9SDave Chinner */ 262730f712c9SDave Chinner temp = new->br_blockcount + right.br_blockcount; 262830f712c9SDave Chinner oldlen = startblockval(new->br_startblock) + 262930f712c9SDave Chinner startblockval(right.br_startblock); 26300e339ef8SBrian Foster newlen = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(ip, temp), 26310e339ef8SBrian Foster oldlen); 26323ffc18ecSChristoph Hellwig right.br_startoff = new->br_startoff; 26333ffc18ecSChristoph Hellwig right.br_startblock = nullstartblock(newlen); 26343ffc18ecSChristoph Hellwig right.br_blockcount = temp; 2635b2b1712aSChristoph Hellwig xfs_iext_update_extent(ip, state, icur, &right); 263630f712c9SDave Chinner break; 263730f712c9SDave Chinner 263830f712c9SDave Chinner case 0: 263930f712c9SDave Chinner /* 264030f712c9SDave Chinner * New allocation is not contiguous with another 264130f712c9SDave Chinner * delayed allocation. 264230f712c9SDave Chinner * Insert a new entry. 264330f712c9SDave Chinner */ 264430f712c9SDave Chinner oldlen = newlen = 0; 26450254c2f2SChristoph Hellwig xfs_iext_insert(ip, icur, new, state); 264630f712c9SDave Chinner break; 264730f712c9SDave Chinner } 264830f712c9SDave Chinner if (oldlen != newlen) { 264930f712c9SDave Chinner ASSERT(oldlen > newlen); 26500d485adaSDave Chinner xfs_mod_fdblocks(ip->i_mount, (int64_t)(oldlen - newlen), 26510d485adaSDave Chinner false); 265230f712c9SDave Chinner /* 265330f712c9SDave Chinner * Nothing to do for disk quota accounting here. 265430f712c9SDave Chinner */ 265530f712c9SDave Chinner } 265630f712c9SDave Chinner } 265730f712c9SDave Chinner 265830f712c9SDave Chinner /* 265930f712c9SDave Chinner * Convert a hole to a real allocation. 266030f712c9SDave Chinner */ 266130f712c9SDave Chinner STATIC int /* error */ 266230f712c9SDave Chinner xfs_bmap_add_extent_hole_real( 26636d04558fSChristoph Hellwig struct xfs_trans *tp, 26646d04558fSChristoph Hellwig struct xfs_inode *ip, 26656d04558fSChristoph Hellwig int whichfork, 2666b2b1712aSChristoph Hellwig struct xfs_iext_cursor *icur, 26676d04558fSChristoph Hellwig struct xfs_btree_cur **curp, 26686d04558fSChristoph Hellwig struct xfs_bmbt_irec *new, 26696d04558fSChristoph Hellwig xfs_fsblock_t *first, 26706d04558fSChristoph Hellwig struct xfs_defer_ops *dfops, 26716d04558fSChristoph Hellwig int *logflagsp) 267230f712c9SDave Chinner { 26736d04558fSChristoph Hellwig struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, whichfork); 26746d04558fSChristoph Hellwig struct xfs_mount *mp = ip->i_mount; 26756d04558fSChristoph Hellwig struct xfs_btree_cur *cur = *curp; 267630f712c9SDave Chinner int error; /* error return value */ 267730f712c9SDave Chinner int i; /* temp state */ 267830f712c9SDave Chinner xfs_bmbt_irec_t left; /* left neighbor extent entry */ 267930f712c9SDave Chinner xfs_bmbt_irec_t right; /* right neighbor extent entry */ 268030f712c9SDave Chinner int rval=0; /* return value (logging flags) */ 2681060ea65bSChristoph Hellwig int state = xfs_bmap_fork_to_state(whichfork); 26821abb9e55SChristoph Hellwig struct xfs_bmbt_irec old; 268330f712c9SDave Chinner 268430f712c9SDave Chinner ASSERT(!isnullstartblock(new->br_startblock)); 26856d04558fSChristoph Hellwig ASSERT(!cur || !(cur->bc_private.b.flags & XFS_BTCUR_BPRV_WASDEL)); 268630f712c9SDave Chinner 2687ff6d6af2SBill O'Donnell XFS_STATS_INC(mp, xs_add_exlist); 268830f712c9SDave Chinner 268930f712c9SDave Chinner /* 269030f712c9SDave Chinner * Check and set flags if this segment has a left neighbor. 269130f712c9SDave Chinner */ 2692b2b1712aSChristoph Hellwig if (xfs_iext_peek_prev_extent(ifp, icur, &left)) { 269330f712c9SDave Chinner state |= BMAP_LEFT_VALID; 269430f712c9SDave Chinner if (isnullstartblock(left.br_startblock)) 269530f712c9SDave Chinner state |= BMAP_LEFT_DELAY; 269630f712c9SDave Chinner } 269730f712c9SDave Chinner 269830f712c9SDave Chinner /* 269930f712c9SDave Chinner * Check and set flags if this segment has a current value. 270030f712c9SDave Chinner * Not true if we're inserting into the "hole" at eof. 270130f712c9SDave Chinner */ 2702b2b1712aSChristoph Hellwig if (xfs_iext_get_extent(ifp, icur, &right)) { 270330f712c9SDave Chinner state |= BMAP_RIGHT_VALID; 270430f712c9SDave Chinner if (isnullstartblock(right.br_startblock)) 270530f712c9SDave Chinner state |= BMAP_RIGHT_DELAY; 270630f712c9SDave Chinner } 270730f712c9SDave Chinner 270830f712c9SDave Chinner /* 270930f712c9SDave Chinner * We're inserting a real allocation between "left" and "right". 271030f712c9SDave Chinner * Set the contiguity flags. Don't let extents get too large. 271130f712c9SDave Chinner */ 271230f712c9SDave Chinner if ((state & BMAP_LEFT_VALID) && !(state & BMAP_LEFT_DELAY) && 271330f712c9SDave Chinner left.br_startoff + left.br_blockcount == new->br_startoff && 271430f712c9SDave Chinner left.br_startblock + left.br_blockcount == new->br_startblock && 271530f712c9SDave Chinner left.br_state == new->br_state && 271630f712c9SDave Chinner left.br_blockcount + new->br_blockcount <= MAXEXTLEN) 271730f712c9SDave Chinner state |= BMAP_LEFT_CONTIG; 271830f712c9SDave Chinner 271930f712c9SDave Chinner if ((state & BMAP_RIGHT_VALID) && !(state & BMAP_RIGHT_DELAY) && 272030f712c9SDave Chinner new->br_startoff + new->br_blockcount == right.br_startoff && 272130f712c9SDave Chinner new->br_startblock + new->br_blockcount == right.br_startblock && 272230f712c9SDave Chinner new->br_state == right.br_state && 272330f712c9SDave Chinner new->br_blockcount + right.br_blockcount <= MAXEXTLEN && 272430f712c9SDave Chinner (!(state & BMAP_LEFT_CONTIG) || 272530f712c9SDave Chinner left.br_blockcount + new->br_blockcount + 272630f712c9SDave Chinner right.br_blockcount <= MAXEXTLEN)) 272730f712c9SDave Chinner state |= BMAP_RIGHT_CONTIG; 272830f712c9SDave Chinner 272930f712c9SDave Chinner error = 0; 273030f712c9SDave Chinner /* 273130f712c9SDave Chinner * Select which case we're in here, and implement it. 273230f712c9SDave Chinner */ 273330f712c9SDave Chinner switch (state & (BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG)) { 273430f712c9SDave Chinner case BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG: 273530f712c9SDave Chinner /* 273630f712c9SDave Chinner * New allocation is contiguous with real allocations on the 273730f712c9SDave Chinner * left and on the right. 273830f712c9SDave Chinner * Merge all three into a single extent record. 273930f712c9SDave Chinner */ 27401abb9e55SChristoph Hellwig left.br_blockcount += new->br_blockcount + right.br_blockcount; 274130f712c9SDave Chinner 2742c38ccf59SChristoph Hellwig xfs_iext_remove(ip, icur, state); 2743b2b1712aSChristoph Hellwig xfs_iext_prev(ifp, icur); 2744b2b1712aSChristoph Hellwig xfs_iext_update_extent(ip, state, icur, &left); 274530f712c9SDave Chinner 27466d04558fSChristoph Hellwig XFS_IFORK_NEXT_SET(ip, whichfork, 27476d04558fSChristoph Hellwig XFS_IFORK_NEXTENTS(ip, whichfork) - 1); 27486d04558fSChristoph Hellwig if (cur == NULL) { 274930f712c9SDave Chinner rval = XFS_ILOG_CORE | xfs_ilog_fext(whichfork); 275030f712c9SDave Chinner } else { 275130f712c9SDave Chinner rval = XFS_ILOG_CORE; 2752e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(cur, &right, &i); 275330f712c9SDave Chinner if (error) 275430f712c9SDave Chinner goto done; 2755c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 27566d04558fSChristoph Hellwig error = xfs_btree_delete(cur, &i); 275730f712c9SDave Chinner if (error) 275830f712c9SDave Chinner goto done; 2759c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 27606d04558fSChristoph Hellwig error = xfs_btree_decrement(cur, 0, &i); 276130f712c9SDave Chinner if (error) 276230f712c9SDave Chinner goto done; 2763c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 2764a67d00a5SChristoph Hellwig error = xfs_bmbt_update(cur, &left); 276530f712c9SDave Chinner if (error) 276630f712c9SDave Chinner goto done; 276730f712c9SDave Chinner } 276830f712c9SDave Chinner break; 276930f712c9SDave Chinner 277030f712c9SDave Chinner case BMAP_LEFT_CONTIG: 277130f712c9SDave Chinner /* 277230f712c9SDave Chinner * New allocation is contiguous with a real allocation 277330f712c9SDave Chinner * on the left. 277430f712c9SDave Chinner * Merge the new allocation with the left neighbor. 277530f712c9SDave Chinner */ 27761abb9e55SChristoph Hellwig old = left; 27771abb9e55SChristoph Hellwig left.br_blockcount += new->br_blockcount; 27781d2e0089SChristoph Hellwig 2779b2b1712aSChristoph Hellwig xfs_iext_prev(ifp, icur); 2780b2b1712aSChristoph Hellwig xfs_iext_update_extent(ip, state, icur, &left); 278130f712c9SDave Chinner 27826d04558fSChristoph Hellwig if (cur == NULL) { 278330f712c9SDave Chinner rval = xfs_ilog_fext(whichfork); 278430f712c9SDave Chinner } else { 278530f712c9SDave Chinner rval = 0; 2786e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(cur, &old, &i); 278730f712c9SDave Chinner if (error) 278830f712c9SDave Chinner goto done; 2789c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 2790a67d00a5SChristoph Hellwig error = xfs_bmbt_update(cur, &left); 279130f712c9SDave Chinner if (error) 279230f712c9SDave Chinner goto done; 279330f712c9SDave Chinner } 279430f712c9SDave Chinner break; 279530f712c9SDave Chinner 279630f712c9SDave Chinner case BMAP_RIGHT_CONTIG: 279730f712c9SDave Chinner /* 279830f712c9SDave Chinner * New allocation is contiguous with a real allocation 279930f712c9SDave Chinner * on the right. 280030f712c9SDave Chinner * Merge the new allocation with the right neighbor. 280130f712c9SDave Chinner */ 28021abb9e55SChristoph Hellwig old = right; 2803ca5d8e5bSChristoph Hellwig 28041abb9e55SChristoph Hellwig right.br_startoff = new->br_startoff; 28051abb9e55SChristoph Hellwig right.br_startblock = new->br_startblock; 28061abb9e55SChristoph Hellwig right.br_blockcount += new->br_blockcount; 2807b2b1712aSChristoph Hellwig xfs_iext_update_extent(ip, state, icur, &right); 280830f712c9SDave Chinner 28096d04558fSChristoph Hellwig if (cur == NULL) { 281030f712c9SDave Chinner rval = xfs_ilog_fext(whichfork); 281130f712c9SDave Chinner } else { 281230f712c9SDave Chinner rval = 0; 2813e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(cur, &old, &i); 281430f712c9SDave Chinner if (error) 281530f712c9SDave Chinner goto done; 2816c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 2817a67d00a5SChristoph Hellwig error = xfs_bmbt_update(cur, &right); 281830f712c9SDave Chinner if (error) 281930f712c9SDave Chinner goto done; 282030f712c9SDave Chinner } 282130f712c9SDave Chinner break; 282230f712c9SDave Chinner 282330f712c9SDave Chinner case 0: 282430f712c9SDave Chinner /* 282530f712c9SDave Chinner * New allocation is not contiguous with another 282630f712c9SDave Chinner * real allocation. 282730f712c9SDave Chinner * Insert a new entry. 282830f712c9SDave Chinner */ 28290254c2f2SChristoph Hellwig xfs_iext_insert(ip, icur, new, state); 28306d04558fSChristoph Hellwig XFS_IFORK_NEXT_SET(ip, whichfork, 28316d04558fSChristoph Hellwig XFS_IFORK_NEXTENTS(ip, whichfork) + 1); 28326d04558fSChristoph Hellwig if (cur == NULL) { 283330f712c9SDave Chinner rval = XFS_ILOG_CORE | xfs_ilog_fext(whichfork); 283430f712c9SDave Chinner } else { 283530f712c9SDave Chinner rval = XFS_ILOG_CORE; 2836e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(cur, new, &i); 283730f712c9SDave Chinner if (error) 283830f712c9SDave Chinner goto done; 2839c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 0, done); 28406d04558fSChristoph Hellwig error = xfs_btree_insert(cur, &i); 284130f712c9SDave Chinner if (error) 284230f712c9SDave Chinner goto done; 2843c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 284430f712c9SDave Chinner } 284530f712c9SDave Chinner break; 284630f712c9SDave Chinner } 284730f712c9SDave Chinner 28489c194644SDarrick J. Wong /* add reverse mapping */ 28496d04558fSChristoph Hellwig error = xfs_rmap_map_extent(mp, dfops, ip, whichfork, new); 28509c194644SDarrick J. Wong if (error) 28519c194644SDarrick J. Wong goto done; 28529c194644SDarrick J. Wong 285330f712c9SDave Chinner /* convert to a btree if necessary */ 28546d04558fSChristoph Hellwig if (xfs_bmap_needs_btree(ip, whichfork)) { 285530f712c9SDave Chinner int tmp_logflags; /* partial log flag return val */ 285630f712c9SDave Chinner 28576d04558fSChristoph Hellwig ASSERT(cur == NULL); 28586d04558fSChristoph Hellwig error = xfs_bmap_extents_to_btree(tp, ip, first, dfops, curp, 285930f712c9SDave Chinner 0, &tmp_logflags, whichfork); 28606d04558fSChristoph Hellwig *logflagsp |= tmp_logflags; 28616d04558fSChristoph Hellwig cur = *curp; 286230f712c9SDave Chinner if (error) 286330f712c9SDave Chinner goto done; 286430f712c9SDave Chinner } 286530f712c9SDave Chinner 286630f712c9SDave Chinner /* clear out the allocated field, done with it now in any case. */ 28676d04558fSChristoph Hellwig if (cur) 28686d04558fSChristoph Hellwig cur->bc_private.b.allocated = 0; 286930f712c9SDave Chinner 28706d04558fSChristoph Hellwig xfs_bmap_check_leaf_extents(cur, ip, whichfork); 287130f712c9SDave Chinner done: 28726d04558fSChristoph Hellwig *logflagsp |= rval; 287330f712c9SDave Chinner return error; 287430f712c9SDave Chinner } 287530f712c9SDave Chinner 287630f712c9SDave Chinner /* 287730f712c9SDave Chinner * Functions used in the extent read, allocate and remove paths 287830f712c9SDave Chinner */ 287930f712c9SDave Chinner 288030f712c9SDave Chinner /* 288130f712c9SDave Chinner * Adjust the size of the new extent based on di_extsize and rt extsize. 288230f712c9SDave Chinner */ 288330f712c9SDave Chinner int 288430f712c9SDave Chinner xfs_bmap_extsize_align( 288530f712c9SDave Chinner xfs_mount_t *mp, 288630f712c9SDave Chinner xfs_bmbt_irec_t *gotp, /* next extent pointer */ 288730f712c9SDave Chinner xfs_bmbt_irec_t *prevp, /* previous extent pointer */ 288830f712c9SDave Chinner xfs_extlen_t extsz, /* align to this extent size */ 288930f712c9SDave Chinner int rt, /* is this a realtime inode? */ 289030f712c9SDave Chinner int eof, /* is extent at end-of-file? */ 289130f712c9SDave Chinner int delay, /* creating delalloc extent? */ 289230f712c9SDave Chinner int convert, /* overwriting unwritten extent? */ 289330f712c9SDave Chinner xfs_fileoff_t *offp, /* in/out: aligned offset */ 289430f712c9SDave Chinner xfs_extlen_t *lenp) /* in/out: aligned length */ 289530f712c9SDave Chinner { 289630f712c9SDave Chinner xfs_fileoff_t orig_off; /* original offset */ 289730f712c9SDave Chinner xfs_extlen_t orig_alen; /* original length */ 289830f712c9SDave Chinner xfs_fileoff_t orig_end; /* original off+len */ 289930f712c9SDave Chinner xfs_fileoff_t nexto; /* next file offset */ 290030f712c9SDave Chinner xfs_fileoff_t prevo; /* previous file offset */ 290130f712c9SDave Chinner xfs_fileoff_t align_off; /* temp for offset */ 290230f712c9SDave Chinner xfs_extlen_t align_alen; /* temp for length */ 290330f712c9SDave Chinner xfs_extlen_t temp; /* temp for calculations */ 290430f712c9SDave Chinner 290530f712c9SDave Chinner if (convert) 290630f712c9SDave Chinner return 0; 290730f712c9SDave Chinner 290830f712c9SDave Chinner orig_off = align_off = *offp; 290930f712c9SDave Chinner orig_alen = align_alen = *lenp; 291030f712c9SDave Chinner orig_end = orig_off + orig_alen; 291130f712c9SDave Chinner 291230f712c9SDave Chinner /* 291330f712c9SDave Chinner * If this request overlaps an existing extent, then don't 291430f712c9SDave Chinner * attempt to perform any additional alignment. 291530f712c9SDave Chinner */ 291630f712c9SDave Chinner if (!delay && !eof && 291730f712c9SDave Chinner (orig_off >= gotp->br_startoff) && 291830f712c9SDave Chinner (orig_end <= gotp->br_startoff + gotp->br_blockcount)) { 291930f712c9SDave Chinner return 0; 292030f712c9SDave Chinner } 292130f712c9SDave Chinner 292230f712c9SDave Chinner /* 292330f712c9SDave Chinner * If the file offset is unaligned vs. the extent size 292430f712c9SDave Chinner * we need to align it. This will be possible unless 292530f712c9SDave Chinner * the file was previously written with a kernel that didn't 292630f712c9SDave Chinner * perform this alignment, or if a truncate shot us in the 292730f712c9SDave Chinner * foot. 292830f712c9SDave Chinner */ 292930f712c9SDave Chinner temp = do_mod(orig_off, extsz); 293030f712c9SDave Chinner if (temp) { 293130f712c9SDave Chinner align_alen += temp; 293230f712c9SDave Chinner align_off -= temp; 293330f712c9SDave Chinner } 29346dea405eSDave Chinner 29356dea405eSDave Chinner /* Same adjustment for the end of the requested area. */ 29366dea405eSDave Chinner temp = (align_alen % extsz); 29376dea405eSDave Chinner if (temp) 293830f712c9SDave Chinner align_alen += extsz - temp; 29396dea405eSDave Chinner 29406dea405eSDave Chinner /* 29416dea405eSDave Chinner * For large extent hint sizes, the aligned extent might be larger than 29426dea405eSDave Chinner * MAXEXTLEN. In that case, reduce the size by an extsz so that it pulls 29436dea405eSDave Chinner * the length back under MAXEXTLEN. The outer allocation loops handle 29446dea405eSDave Chinner * short allocation just fine, so it is safe to do this. We only want to 29456dea405eSDave Chinner * do it when we are forced to, though, because it means more allocation 29466dea405eSDave Chinner * operations are required. 29476dea405eSDave Chinner */ 29486dea405eSDave Chinner while (align_alen > MAXEXTLEN) 29496dea405eSDave Chinner align_alen -= extsz; 29506dea405eSDave Chinner ASSERT(align_alen <= MAXEXTLEN); 29516dea405eSDave Chinner 295230f712c9SDave Chinner /* 295330f712c9SDave Chinner * If the previous block overlaps with this proposed allocation 295430f712c9SDave Chinner * then move the start forward without adjusting the length. 295530f712c9SDave Chinner */ 295630f712c9SDave Chinner if (prevp->br_startoff != NULLFILEOFF) { 295730f712c9SDave Chinner if (prevp->br_startblock == HOLESTARTBLOCK) 295830f712c9SDave Chinner prevo = prevp->br_startoff; 295930f712c9SDave Chinner else 296030f712c9SDave Chinner prevo = prevp->br_startoff + prevp->br_blockcount; 296130f712c9SDave Chinner } else 296230f712c9SDave Chinner prevo = 0; 296330f712c9SDave Chinner if (align_off != orig_off && align_off < prevo) 296430f712c9SDave Chinner align_off = prevo; 296530f712c9SDave Chinner /* 296630f712c9SDave Chinner * If the next block overlaps with this proposed allocation 296730f712c9SDave Chinner * then move the start back without adjusting the length, 296830f712c9SDave Chinner * but not before offset 0. 296930f712c9SDave Chinner * This may of course make the start overlap previous block, 297030f712c9SDave Chinner * and if we hit the offset 0 limit then the next block 297130f712c9SDave Chinner * can still overlap too. 297230f712c9SDave Chinner */ 297330f712c9SDave Chinner if (!eof && gotp->br_startoff != NULLFILEOFF) { 297430f712c9SDave Chinner if ((delay && gotp->br_startblock == HOLESTARTBLOCK) || 297530f712c9SDave Chinner (!delay && gotp->br_startblock == DELAYSTARTBLOCK)) 297630f712c9SDave Chinner nexto = gotp->br_startoff + gotp->br_blockcount; 297730f712c9SDave Chinner else 297830f712c9SDave Chinner nexto = gotp->br_startoff; 297930f712c9SDave Chinner } else 298030f712c9SDave Chinner nexto = NULLFILEOFF; 298130f712c9SDave Chinner if (!eof && 298230f712c9SDave Chinner align_off + align_alen != orig_end && 298330f712c9SDave Chinner align_off + align_alen > nexto) 298430f712c9SDave Chinner align_off = nexto > align_alen ? nexto - align_alen : 0; 298530f712c9SDave Chinner /* 298630f712c9SDave Chinner * If we're now overlapping the next or previous extent that 298730f712c9SDave Chinner * means we can't fit an extsz piece in this hole. Just move 298830f712c9SDave Chinner * the start forward to the first valid spot and set 298930f712c9SDave Chinner * the length so we hit the end. 299030f712c9SDave Chinner */ 299130f712c9SDave Chinner if (align_off != orig_off && align_off < prevo) 299230f712c9SDave Chinner align_off = prevo; 299330f712c9SDave Chinner if (align_off + align_alen != orig_end && 299430f712c9SDave Chinner align_off + align_alen > nexto && 299530f712c9SDave Chinner nexto != NULLFILEOFF) { 299630f712c9SDave Chinner ASSERT(nexto > prevo); 299730f712c9SDave Chinner align_alen = nexto - align_off; 299830f712c9SDave Chinner } 299930f712c9SDave Chinner 300030f712c9SDave Chinner /* 300130f712c9SDave Chinner * If realtime, and the result isn't a multiple of the realtime 300230f712c9SDave Chinner * extent size we need to remove blocks until it is. 300330f712c9SDave Chinner */ 300430f712c9SDave Chinner if (rt && (temp = (align_alen % mp->m_sb.sb_rextsize))) { 300530f712c9SDave Chinner /* 300630f712c9SDave Chinner * We're not covering the original request, or 300730f712c9SDave Chinner * we won't be able to once we fix the length. 300830f712c9SDave Chinner */ 300930f712c9SDave Chinner if (orig_off < align_off || 301030f712c9SDave Chinner orig_end > align_off + align_alen || 301130f712c9SDave Chinner align_alen - temp < orig_alen) 30122451337dSDave Chinner return -EINVAL; 301330f712c9SDave Chinner /* 301430f712c9SDave Chinner * Try to fix it by moving the start up. 301530f712c9SDave Chinner */ 301630f712c9SDave Chinner if (align_off + temp <= orig_off) { 301730f712c9SDave Chinner align_alen -= temp; 301830f712c9SDave Chinner align_off += temp; 301930f712c9SDave Chinner } 302030f712c9SDave Chinner /* 302130f712c9SDave Chinner * Try to fix it by moving the end in. 302230f712c9SDave Chinner */ 302330f712c9SDave Chinner else if (align_off + align_alen - temp >= orig_end) 302430f712c9SDave Chinner align_alen -= temp; 302530f712c9SDave Chinner /* 302630f712c9SDave Chinner * Set the start to the minimum then trim the length. 302730f712c9SDave Chinner */ 302830f712c9SDave Chinner else { 302930f712c9SDave Chinner align_alen -= orig_off - align_off; 303030f712c9SDave Chinner align_off = orig_off; 303130f712c9SDave Chinner align_alen -= align_alen % mp->m_sb.sb_rextsize; 303230f712c9SDave Chinner } 303330f712c9SDave Chinner /* 303430f712c9SDave Chinner * Result doesn't cover the request, fail it. 303530f712c9SDave Chinner */ 303630f712c9SDave Chinner if (orig_off < align_off || orig_end > align_off + align_alen) 30372451337dSDave Chinner return -EINVAL; 303830f712c9SDave Chinner } else { 303930f712c9SDave Chinner ASSERT(orig_off >= align_off); 30406dea405eSDave Chinner /* see MAXEXTLEN handling above */ 30416dea405eSDave Chinner ASSERT(orig_end <= align_off + align_alen || 30426dea405eSDave Chinner align_alen + extsz > MAXEXTLEN); 304330f712c9SDave Chinner } 304430f712c9SDave Chinner 304530f712c9SDave Chinner #ifdef DEBUG 304630f712c9SDave Chinner if (!eof && gotp->br_startoff != NULLFILEOFF) 304730f712c9SDave Chinner ASSERT(align_off + align_alen <= gotp->br_startoff); 304830f712c9SDave Chinner if (prevp->br_startoff != NULLFILEOFF) 304930f712c9SDave Chinner ASSERT(align_off >= prevp->br_startoff + prevp->br_blockcount); 305030f712c9SDave Chinner #endif 305130f712c9SDave Chinner 305230f712c9SDave Chinner *lenp = align_alen; 305330f712c9SDave Chinner *offp = align_off; 305430f712c9SDave Chinner return 0; 305530f712c9SDave Chinner } 305630f712c9SDave Chinner 305730f712c9SDave Chinner #define XFS_ALLOC_GAP_UNITS 4 305830f712c9SDave Chinner 305930f712c9SDave Chinner void 306030f712c9SDave Chinner xfs_bmap_adjacent( 306130f712c9SDave Chinner struct xfs_bmalloca *ap) /* bmap alloc argument struct */ 306230f712c9SDave Chinner { 306330f712c9SDave Chinner xfs_fsblock_t adjust; /* adjustment to block numbers */ 306430f712c9SDave Chinner xfs_agnumber_t fb_agno; /* ag number of ap->firstblock */ 306530f712c9SDave Chinner xfs_mount_t *mp; /* mount point structure */ 306630f712c9SDave Chinner int nullfb; /* true if ap->firstblock isn't set */ 306730f712c9SDave Chinner int rt; /* true if inode is realtime */ 306830f712c9SDave Chinner 306930f712c9SDave Chinner #define ISVALID(x,y) \ 307030f712c9SDave Chinner (rt ? \ 307130f712c9SDave Chinner (x) < mp->m_sb.sb_rblocks : \ 307230f712c9SDave Chinner XFS_FSB_TO_AGNO(mp, x) == XFS_FSB_TO_AGNO(mp, y) && \ 307330f712c9SDave Chinner XFS_FSB_TO_AGNO(mp, x) < mp->m_sb.sb_agcount && \ 307430f712c9SDave Chinner XFS_FSB_TO_AGBNO(mp, x) < mp->m_sb.sb_agblocks) 307530f712c9SDave Chinner 307630f712c9SDave Chinner mp = ap->ip->i_mount; 307730f712c9SDave Chinner nullfb = *ap->firstblock == NULLFSBLOCK; 3078292378edSDave Chinner rt = XFS_IS_REALTIME_INODE(ap->ip) && 3079292378edSDave Chinner xfs_alloc_is_userdata(ap->datatype); 308030f712c9SDave Chinner fb_agno = nullfb ? NULLAGNUMBER : XFS_FSB_TO_AGNO(mp, *ap->firstblock); 308130f712c9SDave Chinner /* 308230f712c9SDave Chinner * If allocating at eof, and there's a previous real block, 308330f712c9SDave Chinner * try to use its last block as our starting point. 308430f712c9SDave Chinner */ 308530f712c9SDave Chinner if (ap->eof && ap->prev.br_startoff != NULLFILEOFF && 308630f712c9SDave Chinner !isnullstartblock(ap->prev.br_startblock) && 308730f712c9SDave Chinner ISVALID(ap->prev.br_startblock + ap->prev.br_blockcount, 308830f712c9SDave Chinner ap->prev.br_startblock)) { 308930f712c9SDave Chinner ap->blkno = ap->prev.br_startblock + ap->prev.br_blockcount; 309030f712c9SDave Chinner /* 309130f712c9SDave Chinner * Adjust for the gap between prevp and us. 309230f712c9SDave Chinner */ 309330f712c9SDave Chinner adjust = ap->offset - 309430f712c9SDave Chinner (ap->prev.br_startoff + ap->prev.br_blockcount); 309530f712c9SDave Chinner if (adjust && 309630f712c9SDave Chinner ISVALID(ap->blkno + adjust, ap->prev.br_startblock)) 309730f712c9SDave Chinner ap->blkno += adjust; 309830f712c9SDave Chinner } 309930f712c9SDave Chinner /* 310030f712c9SDave Chinner * If not at eof, then compare the two neighbor blocks. 310130f712c9SDave Chinner * Figure out whether either one gives us a good starting point, 310230f712c9SDave Chinner * and pick the better one. 310330f712c9SDave Chinner */ 310430f712c9SDave Chinner else if (!ap->eof) { 310530f712c9SDave Chinner xfs_fsblock_t gotbno; /* right side block number */ 310630f712c9SDave Chinner xfs_fsblock_t gotdiff=0; /* right side difference */ 310730f712c9SDave Chinner xfs_fsblock_t prevbno; /* left side block number */ 310830f712c9SDave Chinner xfs_fsblock_t prevdiff=0; /* left side difference */ 310930f712c9SDave Chinner 311030f712c9SDave Chinner /* 311130f712c9SDave Chinner * If there's a previous (left) block, select a requested 311230f712c9SDave Chinner * start block based on it. 311330f712c9SDave Chinner */ 311430f712c9SDave Chinner if (ap->prev.br_startoff != NULLFILEOFF && 311530f712c9SDave Chinner !isnullstartblock(ap->prev.br_startblock) && 311630f712c9SDave Chinner (prevbno = ap->prev.br_startblock + 311730f712c9SDave Chinner ap->prev.br_blockcount) && 311830f712c9SDave Chinner ISVALID(prevbno, ap->prev.br_startblock)) { 311930f712c9SDave Chinner /* 312030f712c9SDave Chinner * Calculate gap to end of previous block. 312130f712c9SDave Chinner */ 312230f712c9SDave Chinner adjust = prevdiff = ap->offset - 312330f712c9SDave Chinner (ap->prev.br_startoff + 312430f712c9SDave Chinner ap->prev.br_blockcount); 312530f712c9SDave Chinner /* 312630f712c9SDave Chinner * Figure the startblock based on the previous block's 312730f712c9SDave Chinner * end and the gap size. 312830f712c9SDave Chinner * Heuristic! 312930f712c9SDave Chinner * If the gap is large relative to the piece we're 313030f712c9SDave Chinner * allocating, or using it gives us an invalid block 313130f712c9SDave Chinner * number, then just use the end of the previous block. 313230f712c9SDave Chinner */ 313330f712c9SDave Chinner if (prevdiff <= XFS_ALLOC_GAP_UNITS * ap->length && 313430f712c9SDave Chinner ISVALID(prevbno + prevdiff, 313530f712c9SDave Chinner ap->prev.br_startblock)) 313630f712c9SDave Chinner prevbno += adjust; 313730f712c9SDave Chinner else 313830f712c9SDave Chinner prevdiff += adjust; 313930f712c9SDave Chinner /* 314030f712c9SDave Chinner * If the firstblock forbids it, can't use it, 314130f712c9SDave Chinner * must use default. 314230f712c9SDave Chinner */ 314330f712c9SDave Chinner if (!rt && !nullfb && 314430f712c9SDave Chinner XFS_FSB_TO_AGNO(mp, prevbno) != fb_agno) 314530f712c9SDave Chinner prevbno = NULLFSBLOCK; 314630f712c9SDave Chinner } 314730f712c9SDave Chinner /* 314830f712c9SDave Chinner * No previous block or can't follow it, just default. 314930f712c9SDave Chinner */ 315030f712c9SDave Chinner else 315130f712c9SDave Chinner prevbno = NULLFSBLOCK; 315230f712c9SDave Chinner /* 315330f712c9SDave Chinner * If there's a following (right) block, select a requested 315430f712c9SDave Chinner * start block based on it. 315530f712c9SDave Chinner */ 315630f712c9SDave Chinner if (!isnullstartblock(ap->got.br_startblock)) { 315730f712c9SDave Chinner /* 315830f712c9SDave Chinner * Calculate gap to start of next block. 315930f712c9SDave Chinner */ 316030f712c9SDave Chinner adjust = gotdiff = ap->got.br_startoff - ap->offset; 316130f712c9SDave Chinner /* 316230f712c9SDave Chinner * Figure the startblock based on the next block's 316330f712c9SDave Chinner * start and the gap size. 316430f712c9SDave Chinner */ 316530f712c9SDave Chinner gotbno = ap->got.br_startblock; 316630f712c9SDave Chinner /* 316730f712c9SDave Chinner * Heuristic! 316830f712c9SDave Chinner * If the gap is large relative to the piece we're 316930f712c9SDave Chinner * allocating, or using it gives us an invalid block 317030f712c9SDave Chinner * number, then just use the start of the next block 317130f712c9SDave Chinner * offset by our length. 317230f712c9SDave Chinner */ 317330f712c9SDave Chinner if (gotdiff <= XFS_ALLOC_GAP_UNITS * ap->length && 317430f712c9SDave Chinner ISVALID(gotbno - gotdiff, gotbno)) 317530f712c9SDave Chinner gotbno -= adjust; 317630f712c9SDave Chinner else if (ISVALID(gotbno - ap->length, gotbno)) { 317730f712c9SDave Chinner gotbno -= ap->length; 317830f712c9SDave Chinner gotdiff += adjust - ap->length; 317930f712c9SDave Chinner } else 318030f712c9SDave Chinner gotdiff += adjust; 318130f712c9SDave Chinner /* 318230f712c9SDave Chinner * If the firstblock forbids it, can't use it, 318330f712c9SDave Chinner * must use default. 318430f712c9SDave Chinner */ 318530f712c9SDave Chinner if (!rt && !nullfb && 318630f712c9SDave Chinner XFS_FSB_TO_AGNO(mp, gotbno) != fb_agno) 318730f712c9SDave Chinner gotbno = NULLFSBLOCK; 318830f712c9SDave Chinner } 318930f712c9SDave Chinner /* 319030f712c9SDave Chinner * No next block, just default. 319130f712c9SDave Chinner */ 319230f712c9SDave Chinner else 319330f712c9SDave Chinner gotbno = NULLFSBLOCK; 319430f712c9SDave Chinner /* 319530f712c9SDave Chinner * If both valid, pick the better one, else the only good 319630f712c9SDave Chinner * one, else ap->blkno is already set (to 0 or the inode block). 319730f712c9SDave Chinner */ 319830f712c9SDave Chinner if (prevbno != NULLFSBLOCK && gotbno != NULLFSBLOCK) 319930f712c9SDave Chinner ap->blkno = prevdiff <= gotdiff ? prevbno : gotbno; 320030f712c9SDave Chinner else if (prevbno != NULLFSBLOCK) 320130f712c9SDave Chinner ap->blkno = prevbno; 320230f712c9SDave Chinner else if (gotbno != NULLFSBLOCK) 320330f712c9SDave Chinner ap->blkno = gotbno; 320430f712c9SDave Chinner } 320530f712c9SDave Chinner #undef ISVALID 320630f712c9SDave Chinner } 320730f712c9SDave Chinner 320830f712c9SDave Chinner static int 320930f712c9SDave Chinner xfs_bmap_longest_free_extent( 321030f712c9SDave Chinner struct xfs_trans *tp, 321130f712c9SDave Chinner xfs_agnumber_t ag, 321230f712c9SDave Chinner xfs_extlen_t *blen, 321330f712c9SDave Chinner int *notinit) 321430f712c9SDave Chinner { 321530f712c9SDave Chinner struct xfs_mount *mp = tp->t_mountp; 321630f712c9SDave Chinner struct xfs_perag *pag; 321730f712c9SDave Chinner xfs_extlen_t longest; 321830f712c9SDave Chinner int error = 0; 321930f712c9SDave Chinner 322030f712c9SDave Chinner pag = xfs_perag_get(mp, ag); 322130f712c9SDave Chinner if (!pag->pagf_init) { 322230f712c9SDave Chinner error = xfs_alloc_pagf_init(mp, tp, ag, XFS_ALLOC_FLAG_TRYLOCK); 322330f712c9SDave Chinner if (error) 322430f712c9SDave Chinner goto out; 322530f712c9SDave Chinner 322630f712c9SDave Chinner if (!pag->pagf_init) { 322730f712c9SDave Chinner *notinit = 1; 322830f712c9SDave Chinner goto out; 322930f712c9SDave Chinner } 323030f712c9SDave Chinner } 323130f712c9SDave Chinner 3232a1f69417SEric Sandeen longest = xfs_alloc_longest_free_extent(pag, 32333fd129b6SDarrick J. Wong xfs_alloc_min_freelist(mp, pag), 32343fd129b6SDarrick J. Wong xfs_ag_resv_needed(pag, XFS_AG_RESV_NONE)); 323530f712c9SDave Chinner if (*blen < longest) 323630f712c9SDave Chinner *blen = longest; 323730f712c9SDave Chinner 323830f712c9SDave Chinner out: 323930f712c9SDave Chinner xfs_perag_put(pag); 324030f712c9SDave Chinner return error; 324130f712c9SDave Chinner } 324230f712c9SDave Chinner 324330f712c9SDave Chinner static void 324430f712c9SDave Chinner xfs_bmap_select_minlen( 324530f712c9SDave Chinner struct xfs_bmalloca *ap, 324630f712c9SDave Chinner struct xfs_alloc_arg *args, 324730f712c9SDave Chinner xfs_extlen_t *blen, 324830f712c9SDave Chinner int notinit) 324930f712c9SDave Chinner { 325030f712c9SDave Chinner if (notinit || *blen < ap->minlen) { 325130f712c9SDave Chinner /* 325230f712c9SDave Chinner * Since we did a BUF_TRYLOCK above, it is possible that 325330f712c9SDave Chinner * there is space for this request. 325430f712c9SDave Chinner */ 325530f712c9SDave Chinner args->minlen = ap->minlen; 325630f712c9SDave Chinner } else if (*blen < args->maxlen) { 325730f712c9SDave Chinner /* 325830f712c9SDave Chinner * If the best seen length is less than the request length, 325930f712c9SDave Chinner * use the best as the minimum. 326030f712c9SDave Chinner */ 326130f712c9SDave Chinner args->minlen = *blen; 326230f712c9SDave Chinner } else { 326330f712c9SDave Chinner /* 326430f712c9SDave Chinner * Otherwise we've seen an extent as big as maxlen, use that 326530f712c9SDave Chinner * as the minimum. 326630f712c9SDave Chinner */ 326730f712c9SDave Chinner args->minlen = args->maxlen; 326830f712c9SDave Chinner } 326930f712c9SDave Chinner } 327030f712c9SDave Chinner 327130f712c9SDave Chinner STATIC int 327230f712c9SDave Chinner xfs_bmap_btalloc_nullfb( 327330f712c9SDave Chinner struct xfs_bmalloca *ap, 327430f712c9SDave Chinner struct xfs_alloc_arg *args, 327530f712c9SDave Chinner xfs_extlen_t *blen) 327630f712c9SDave Chinner { 327730f712c9SDave Chinner struct xfs_mount *mp = ap->ip->i_mount; 327830f712c9SDave Chinner xfs_agnumber_t ag, startag; 327930f712c9SDave Chinner int notinit = 0; 328030f712c9SDave Chinner int error; 328130f712c9SDave Chinner 328230f712c9SDave Chinner args->type = XFS_ALLOCTYPE_START_BNO; 328330f712c9SDave Chinner args->total = ap->total; 328430f712c9SDave Chinner 328530f712c9SDave Chinner startag = ag = XFS_FSB_TO_AGNO(mp, args->fsbno); 328630f712c9SDave Chinner if (startag == NULLAGNUMBER) 328730f712c9SDave Chinner startag = ag = 0; 328830f712c9SDave Chinner 328930f712c9SDave Chinner while (*blen < args->maxlen) { 329030f712c9SDave Chinner error = xfs_bmap_longest_free_extent(args->tp, ag, blen, 329130f712c9SDave Chinner ¬init); 329230f712c9SDave Chinner if (error) 329330f712c9SDave Chinner return error; 329430f712c9SDave Chinner 329530f712c9SDave Chinner if (++ag == mp->m_sb.sb_agcount) 329630f712c9SDave Chinner ag = 0; 329730f712c9SDave Chinner if (ag == startag) 329830f712c9SDave Chinner break; 329930f712c9SDave Chinner } 330030f712c9SDave Chinner 330130f712c9SDave Chinner xfs_bmap_select_minlen(ap, args, blen, notinit); 330230f712c9SDave Chinner return 0; 330330f712c9SDave Chinner } 330430f712c9SDave Chinner 330530f712c9SDave Chinner STATIC int 330630f712c9SDave Chinner xfs_bmap_btalloc_filestreams( 330730f712c9SDave Chinner struct xfs_bmalloca *ap, 330830f712c9SDave Chinner struct xfs_alloc_arg *args, 330930f712c9SDave Chinner xfs_extlen_t *blen) 331030f712c9SDave Chinner { 331130f712c9SDave Chinner struct xfs_mount *mp = ap->ip->i_mount; 331230f712c9SDave Chinner xfs_agnumber_t ag; 331330f712c9SDave Chinner int notinit = 0; 331430f712c9SDave Chinner int error; 331530f712c9SDave Chinner 331630f712c9SDave Chinner args->type = XFS_ALLOCTYPE_NEAR_BNO; 331730f712c9SDave Chinner args->total = ap->total; 331830f712c9SDave Chinner 331930f712c9SDave Chinner ag = XFS_FSB_TO_AGNO(mp, args->fsbno); 332030f712c9SDave Chinner if (ag == NULLAGNUMBER) 332130f712c9SDave Chinner ag = 0; 332230f712c9SDave Chinner 332330f712c9SDave Chinner error = xfs_bmap_longest_free_extent(args->tp, ag, blen, ¬init); 332430f712c9SDave Chinner if (error) 332530f712c9SDave Chinner return error; 332630f712c9SDave Chinner 332730f712c9SDave Chinner if (*blen < args->maxlen) { 332830f712c9SDave Chinner error = xfs_filestream_new_ag(ap, &ag); 332930f712c9SDave Chinner if (error) 333030f712c9SDave Chinner return error; 333130f712c9SDave Chinner 333230f712c9SDave Chinner error = xfs_bmap_longest_free_extent(args->tp, ag, blen, 333330f712c9SDave Chinner ¬init); 333430f712c9SDave Chinner if (error) 333530f712c9SDave Chinner return error; 333630f712c9SDave Chinner 333730f712c9SDave Chinner } 333830f712c9SDave Chinner 333930f712c9SDave Chinner xfs_bmap_select_minlen(ap, args, blen, notinit); 334030f712c9SDave Chinner 334130f712c9SDave Chinner /* 334230f712c9SDave Chinner * Set the failure fallback case to look in the selected AG as stream 334330f712c9SDave Chinner * may have moved. 334430f712c9SDave Chinner */ 334530f712c9SDave Chinner ap->blkno = args->fsbno = XFS_AGB_TO_FSB(mp, ag, 0); 334630f712c9SDave Chinner return 0; 334730f712c9SDave Chinner } 334830f712c9SDave Chinner 3349751f3767SDarrick J. Wong /* Update all inode and quota accounting for the allocation we just did. */ 3350751f3767SDarrick J. Wong static void 3351751f3767SDarrick J. Wong xfs_bmap_btalloc_accounting( 3352751f3767SDarrick J. Wong struct xfs_bmalloca *ap, 3353751f3767SDarrick J. Wong struct xfs_alloc_arg *args) 3354751f3767SDarrick J. Wong { 33554b4c1326SDarrick J. Wong if (ap->flags & XFS_BMAPI_COWFORK) { 33564b4c1326SDarrick J. Wong /* 33574b4c1326SDarrick J. Wong * COW fork blocks are in-core only and thus are treated as 33584b4c1326SDarrick J. Wong * in-core quota reservation (like delalloc blocks) even when 33594b4c1326SDarrick J. Wong * converted to real blocks. The quota reservation is not 33604b4c1326SDarrick J. Wong * accounted to disk until blocks are remapped to the data 33614b4c1326SDarrick J. Wong * fork. So if these blocks were previously delalloc, we 33624b4c1326SDarrick J. Wong * already have quota reservation and there's nothing to do 33634b4c1326SDarrick J. Wong * yet. 33644b4c1326SDarrick J. Wong */ 33654b4c1326SDarrick J. Wong if (ap->wasdel) 33664b4c1326SDarrick J. Wong return; 33674b4c1326SDarrick J. Wong 33684b4c1326SDarrick J. Wong /* 33694b4c1326SDarrick J. Wong * Otherwise, we've allocated blocks in a hole. The transaction 33704b4c1326SDarrick J. Wong * has acquired in-core quota reservation for this extent. 33714b4c1326SDarrick J. Wong * Rather than account these as real blocks, however, we reduce 33724b4c1326SDarrick J. Wong * the transaction quota reservation based on the allocation. 33734b4c1326SDarrick J. Wong * This essentially transfers the transaction quota reservation 33744b4c1326SDarrick J. Wong * to that of a delalloc extent. 33754b4c1326SDarrick J. Wong */ 33764b4c1326SDarrick J. Wong ap->ip->i_delayed_blks += args->len; 33774b4c1326SDarrick J. Wong xfs_trans_mod_dquot_byino(ap->tp, ap->ip, XFS_TRANS_DQ_RES_BLKS, 33784b4c1326SDarrick J. Wong -(long)args->len); 33794b4c1326SDarrick J. Wong return; 33804b4c1326SDarrick J. Wong } 33814b4c1326SDarrick J. Wong 33824b4c1326SDarrick J. Wong /* data/attr fork only */ 3383751f3767SDarrick J. Wong ap->ip->i_d.di_nblocks += args->len; 3384751f3767SDarrick J. Wong xfs_trans_log_inode(ap->tp, ap->ip, XFS_ILOG_CORE); 3385751f3767SDarrick J. Wong if (ap->wasdel) 3386751f3767SDarrick J. Wong ap->ip->i_delayed_blks -= args->len; 3387751f3767SDarrick J. Wong xfs_trans_mod_dquot_byino(ap->tp, ap->ip, 3388751f3767SDarrick J. Wong ap->wasdel ? XFS_TRANS_DQ_DELBCOUNT : XFS_TRANS_DQ_BCOUNT, 3389751f3767SDarrick J. Wong args->len); 3390751f3767SDarrick J. Wong } 3391751f3767SDarrick J. Wong 339230f712c9SDave Chinner STATIC int 339330f712c9SDave Chinner xfs_bmap_btalloc( 339430f712c9SDave Chinner struct xfs_bmalloca *ap) /* bmap alloc argument struct */ 339530f712c9SDave Chinner { 339630f712c9SDave Chinner xfs_mount_t *mp; /* mount point structure */ 339730f712c9SDave Chinner xfs_alloctype_t atype = 0; /* type for allocation routines */ 3398292378edSDave Chinner xfs_extlen_t align = 0; /* minimum allocation alignment */ 339930f712c9SDave Chinner xfs_agnumber_t fb_agno; /* ag number of ap->firstblock */ 340030f712c9SDave Chinner xfs_agnumber_t ag; 340130f712c9SDave Chinner xfs_alloc_arg_t args; 34026d8a45ceSDarrick J. Wong xfs_fileoff_t orig_offset; 34036d8a45ceSDarrick J. Wong xfs_extlen_t orig_length; 340430f712c9SDave Chinner xfs_extlen_t blen; 340530f712c9SDave Chinner xfs_extlen_t nextminlen = 0; 340630f712c9SDave Chinner int nullfb; /* true if ap->firstblock isn't set */ 340730f712c9SDave Chinner int isaligned; 340830f712c9SDave Chinner int tryagain; 340930f712c9SDave Chinner int error; 341030f712c9SDave Chinner int stripe_align; 341130f712c9SDave Chinner 341230f712c9SDave Chinner ASSERT(ap->length); 34136d8a45ceSDarrick J. Wong orig_offset = ap->offset; 34146d8a45ceSDarrick J. Wong orig_length = ap->length; 341530f712c9SDave Chinner 341630f712c9SDave Chinner mp = ap->ip->i_mount; 341730f712c9SDave Chinner 341830f712c9SDave Chinner /* stripe alignment for allocation is determined by mount parameters */ 341930f712c9SDave Chinner stripe_align = 0; 342030f712c9SDave Chinner if (mp->m_swidth && (mp->m_flags & XFS_MOUNT_SWALLOC)) 342130f712c9SDave Chinner stripe_align = mp->m_swidth; 342230f712c9SDave Chinner else if (mp->m_dalign) 342330f712c9SDave Chinner stripe_align = mp->m_dalign; 342430f712c9SDave Chinner 3425f7ca3522SDarrick J. Wong if (ap->flags & XFS_BMAPI_COWFORK) 3426f7ca3522SDarrick J. Wong align = xfs_get_cowextsz_hint(ap->ip); 3427f7ca3522SDarrick J. Wong else if (xfs_alloc_is_userdata(ap->datatype)) 3428292378edSDave Chinner align = xfs_get_extsz_hint(ap->ip); 3429493611ebSChristoph Hellwig if (align) { 343030f712c9SDave Chinner error = xfs_bmap_extsize_align(mp, &ap->got, &ap->prev, 343130f712c9SDave Chinner align, 0, ap->eof, 0, ap->conv, 343230f712c9SDave Chinner &ap->offset, &ap->length); 343330f712c9SDave Chinner ASSERT(!error); 343430f712c9SDave Chinner ASSERT(ap->length); 343530f712c9SDave Chinner } 343630f712c9SDave Chinner 343730f712c9SDave Chinner 343830f712c9SDave Chinner nullfb = *ap->firstblock == NULLFSBLOCK; 343930f712c9SDave Chinner fb_agno = nullfb ? NULLAGNUMBER : XFS_FSB_TO_AGNO(mp, *ap->firstblock); 344030f712c9SDave Chinner if (nullfb) { 3441292378edSDave Chinner if (xfs_alloc_is_userdata(ap->datatype) && 3442292378edSDave Chinner xfs_inode_is_filestream(ap->ip)) { 344330f712c9SDave Chinner ag = xfs_filestream_lookup_ag(ap->ip); 344430f712c9SDave Chinner ag = (ag != NULLAGNUMBER) ? ag : 0; 344530f712c9SDave Chinner ap->blkno = XFS_AGB_TO_FSB(mp, ag, 0); 344630f712c9SDave Chinner } else { 344730f712c9SDave Chinner ap->blkno = XFS_INO_TO_FSB(mp, ap->ip->i_ino); 344830f712c9SDave Chinner } 344930f712c9SDave Chinner } else 345030f712c9SDave Chinner ap->blkno = *ap->firstblock; 345130f712c9SDave Chinner 345230f712c9SDave Chinner xfs_bmap_adjacent(ap); 345330f712c9SDave Chinner 345430f712c9SDave Chinner /* 345530f712c9SDave Chinner * If allowed, use ap->blkno; otherwise must use firstblock since 345630f712c9SDave Chinner * it's in the right allocation group. 345730f712c9SDave Chinner */ 345830f712c9SDave Chinner if (nullfb || XFS_FSB_TO_AGNO(mp, ap->blkno) == fb_agno) 345930f712c9SDave Chinner ; 346030f712c9SDave Chinner else 346130f712c9SDave Chinner ap->blkno = *ap->firstblock; 346230f712c9SDave Chinner /* 346330f712c9SDave Chinner * Normal allocation, done through xfs_alloc_vextent. 346430f712c9SDave Chinner */ 346530f712c9SDave Chinner tryagain = isaligned = 0; 346630f712c9SDave Chinner memset(&args, 0, sizeof(args)); 346730f712c9SDave Chinner args.tp = ap->tp; 346830f712c9SDave Chinner args.mp = mp; 346930f712c9SDave Chinner args.fsbno = ap->blkno; 3470340785ccSDarrick J. Wong xfs_rmap_skip_owner_update(&args.oinfo); 347130f712c9SDave Chinner 347230f712c9SDave Chinner /* Trim the allocation back to the maximum an AG can fit. */ 347352548852SDarrick J. Wong args.maxlen = MIN(ap->length, mp->m_ag_max_usable); 347430f712c9SDave Chinner args.firstblock = *ap->firstblock; 347530f712c9SDave Chinner blen = 0; 347630f712c9SDave Chinner if (nullfb) { 347730f712c9SDave Chinner /* 347830f712c9SDave Chinner * Search for an allocation group with a single extent large 347930f712c9SDave Chinner * enough for the request. If one isn't found, then adjust 348030f712c9SDave Chinner * the minimum allocation size to the largest space found. 348130f712c9SDave Chinner */ 3482292378edSDave Chinner if (xfs_alloc_is_userdata(ap->datatype) && 3483292378edSDave Chinner xfs_inode_is_filestream(ap->ip)) 348430f712c9SDave Chinner error = xfs_bmap_btalloc_filestreams(ap, &args, &blen); 348530f712c9SDave Chinner else 348630f712c9SDave Chinner error = xfs_bmap_btalloc_nullfb(ap, &args, &blen); 348730f712c9SDave Chinner if (error) 348830f712c9SDave Chinner return error; 34892c3234d1SDarrick J. Wong } else if (ap->dfops->dop_low) { 349030f712c9SDave Chinner if (xfs_inode_is_filestream(ap->ip)) 349130f712c9SDave Chinner args.type = XFS_ALLOCTYPE_FIRST_AG; 349230f712c9SDave Chinner else 349330f712c9SDave Chinner args.type = XFS_ALLOCTYPE_START_BNO; 349430f712c9SDave Chinner args.total = args.minlen = ap->minlen; 349530f712c9SDave Chinner } else { 349630f712c9SDave Chinner args.type = XFS_ALLOCTYPE_NEAR_BNO; 349730f712c9SDave Chinner args.total = ap->total; 349830f712c9SDave Chinner args.minlen = ap->minlen; 349930f712c9SDave Chinner } 350030f712c9SDave Chinner /* apply extent size hints if obtained earlier */ 3501493611ebSChristoph Hellwig if (align) { 350230f712c9SDave Chinner args.prod = align; 350330f712c9SDave Chinner if ((args.mod = (xfs_extlen_t)do_mod(ap->offset, args.prod))) 350430f712c9SDave Chinner args.mod = (xfs_extlen_t)(args.prod - args.mod); 350509cbfeafSKirill A. Shutemov } else if (mp->m_sb.sb_blocksize >= PAGE_SIZE) { 350630f712c9SDave Chinner args.prod = 1; 350730f712c9SDave Chinner args.mod = 0; 350830f712c9SDave Chinner } else { 350909cbfeafSKirill A. Shutemov args.prod = PAGE_SIZE >> mp->m_sb.sb_blocklog; 351030f712c9SDave Chinner if ((args.mod = (xfs_extlen_t)(do_mod(ap->offset, args.prod)))) 351130f712c9SDave Chinner args.mod = (xfs_extlen_t)(args.prod - args.mod); 351230f712c9SDave Chinner } 351330f712c9SDave Chinner /* 351430f712c9SDave Chinner * If we are not low on available data blocks, and the 351530f712c9SDave Chinner * underlying logical volume manager is a stripe, and 351630f712c9SDave Chinner * the file offset is zero then try to allocate data 351730f712c9SDave Chinner * blocks on stripe unit boundary. 351830f712c9SDave Chinner * NOTE: ap->aeof is only set if the allocation length 351930f712c9SDave Chinner * is >= the stripe unit and the allocation offset is 352030f712c9SDave Chinner * at the end of file. 352130f712c9SDave Chinner */ 35222c3234d1SDarrick J. Wong if (!ap->dfops->dop_low && ap->aeof) { 352330f712c9SDave Chinner if (!ap->offset) { 352430f712c9SDave Chinner args.alignment = stripe_align; 352530f712c9SDave Chinner atype = args.type; 352630f712c9SDave Chinner isaligned = 1; 352730f712c9SDave Chinner /* 352830f712c9SDave Chinner * Adjust for alignment 352930f712c9SDave Chinner */ 353030f712c9SDave Chinner if (blen > args.alignment && blen <= args.maxlen) 353130f712c9SDave Chinner args.minlen = blen - args.alignment; 353230f712c9SDave Chinner args.minalignslop = 0; 353330f712c9SDave Chinner } else { 353430f712c9SDave Chinner /* 353530f712c9SDave Chinner * First try an exact bno allocation. 353630f712c9SDave Chinner * If it fails then do a near or start bno 353730f712c9SDave Chinner * allocation with alignment turned on. 353830f712c9SDave Chinner */ 353930f712c9SDave Chinner atype = args.type; 354030f712c9SDave Chinner tryagain = 1; 354130f712c9SDave Chinner args.type = XFS_ALLOCTYPE_THIS_BNO; 354230f712c9SDave Chinner args.alignment = 1; 354330f712c9SDave Chinner /* 354430f712c9SDave Chinner * Compute the minlen+alignment for the 354530f712c9SDave Chinner * next case. Set slop so that the value 354630f712c9SDave Chinner * of minlen+alignment+slop doesn't go up 354730f712c9SDave Chinner * between the calls. 354830f712c9SDave Chinner */ 354930f712c9SDave Chinner if (blen > stripe_align && blen <= args.maxlen) 355030f712c9SDave Chinner nextminlen = blen - stripe_align; 355130f712c9SDave Chinner else 355230f712c9SDave Chinner nextminlen = args.minlen; 355330f712c9SDave Chinner if (nextminlen + stripe_align > args.minlen + 1) 355430f712c9SDave Chinner args.minalignslop = 355530f712c9SDave Chinner nextminlen + stripe_align - 355630f712c9SDave Chinner args.minlen - 1; 355730f712c9SDave Chinner else 355830f712c9SDave Chinner args.minalignslop = 0; 355930f712c9SDave Chinner } 356030f712c9SDave Chinner } else { 356130f712c9SDave Chinner args.alignment = 1; 356230f712c9SDave Chinner args.minalignslop = 0; 356330f712c9SDave Chinner } 356430f712c9SDave Chinner args.minleft = ap->minleft; 356530f712c9SDave Chinner args.wasdel = ap->wasdel; 35663fd129b6SDarrick J. Wong args.resv = XFS_AG_RESV_NONE; 3567292378edSDave Chinner args.datatype = ap->datatype; 3568292378edSDave Chinner if (ap->datatype & XFS_ALLOC_USERDATA_ZERO) 35693fbbbea3SDave Chinner args.ip = ap->ip; 35703fbbbea3SDave Chinner 35713fbbbea3SDave Chinner error = xfs_alloc_vextent(&args); 35723fbbbea3SDave Chinner if (error) 357330f712c9SDave Chinner return error; 35743fbbbea3SDave Chinner 357530f712c9SDave Chinner if (tryagain && args.fsbno == NULLFSBLOCK) { 357630f712c9SDave Chinner /* 357730f712c9SDave Chinner * Exact allocation failed. Now try with alignment 357830f712c9SDave Chinner * turned on. 357930f712c9SDave Chinner */ 358030f712c9SDave Chinner args.type = atype; 358130f712c9SDave Chinner args.fsbno = ap->blkno; 358230f712c9SDave Chinner args.alignment = stripe_align; 358330f712c9SDave Chinner args.minlen = nextminlen; 358430f712c9SDave Chinner args.minalignslop = 0; 358530f712c9SDave Chinner isaligned = 1; 358630f712c9SDave Chinner if ((error = xfs_alloc_vextent(&args))) 358730f712c9SDave Chinner return error; 358830f712c9SDave Chinner } 358930f712c9SDave Chinner if (isaligned && args.fsbno == NULLFSBLOCK) { 359030f712c9SDave Chinner /* 359130f712c9SDave Chinner * allocation failed, so turn off alignment and 359230f712c9SDave Chinner * try again. 359330f712c9SDave Chinner */ 359430f712c9SDave Chinner args.type = atype; 359530f712c9SDave Chinner args.fsbno = ap->blkno; 359630f712c9SDave Chinner args.alignment = 0; 359730f712c9SDave Chinner if ((error = xfs_alloc_vextent(&args))) 359830f712c9SDave Chinner return error; 359930f712c9SDave Chinner } 360030f712c9SDave Chinner if (args.fsbno == NULLFSBLOCK && nullfb && 360130f712c9SDave Chinner args.minlen > ap->minlen) { 360230f712c9SDave Chinner args.minlen = ap->minlen; 360330f712c9SDave Chinner args.type = XFS_ALLOCTYPE_START_BNO; 360430f712c9SDave Chinner args.fsbno = ap->blkno; 360530f712c9SDave Chinner if ((error = xfs_alloc_vextent(&args))) 360630f712c9SDave Chinner return error; 360730f712c9SDave Chinner } 360830f712c9SDave Chinner if (args.fsbno == NULLFSBLOCK && nullfb) { 360930f712c9SDave Chinner args.fsbno = 0; 361030f712c9SDave Chinner args.type = XFS_ALLOCTYPE_FIRST_AG; 361130f712c9SDave Chinner args.total = ap->minlen; 361230f712c9SDave Chinner if ((error = xfs_alloc_vextent(&args))) 361330f712c9SDave Chinner return error; 36142c3234d1SDarrick J. Wong ap->dfops->dop_low = true; 361530f712c9SDave Chinner } 361630f712c9SDave Chinner if (args.fsbno != NULLFSBLOCK) { 361730f712c9SDave Chinner /* 361830f712c9SDave Chinner * check the allocation happened at the same or higher AG than 361930f712c9SDave Chinner * the first block that was allocated. 362030f712c9SDave Chinner */ 362130f712c9SDave Chinner ASSERT(*ap->firstblock == NULLFSBLOCK || 3622410d17f6SChristoph Hellwig XFS_FSB_TO_AGNO(mp, *ap->firstblock) <= 3623410d17f6SChristoph Hellwig XFS_FSB_TO_AGNO(mp, args.fsbno)); 362430f712c9SDave Chinner 362530f712c9SDave Chinner ap->blkno = args.fsbno; 362630f712c9SDave Chinner if (*ap->firstblock == NULLFSBLOCK) 362730f712c9SDave Chinner *ap->firstblock = args.fsbno; 3628410d17f6SChristoph Hellwig ASSERT(nullfb || fb_agno <= args.agno); 362930f712c9SDave Chinner ap->length = args.len; 36306d8a45ceSDarrick J. Wong /* 36316d8a45ceSDarrick J. Wong * If the extent size hint is active, we tried to round the 36326d8a45ceSDarrick J. Wong * caller's allocation request offset down to extsz and the 36336d8a45ceSDarrick J. Wong * length up to another extsz boundary. If we found a free 36346d8a45ceSDarrick J. Wong * extent we mapped it in starting at this new offset. If the 36356d8a45ceSDarrick J. Wong * newly mapped space isn't long enough to cover any of the 36366d8a45ceSDarrick J. Wong * range of offsets that was originally requested, move the 36376d8a45ceSDarrick J. Wong * mapping up so that we can fill as much of the caller's 36386d8a45ceSDarrick J. Wong * original request as possible. Free space is apparently 36396d8a45ceSDarrick J. Wong * very fragmented so we're unlikely to be able to satisfy the 36406d8a45ceSDarrick J. Wong * hints anyway. 36416d8a45ceSDarrick J. Wong */ 36426d8a45ceSDarrick J. Wong if (ap->length <= orig_length) 36436d8a45ceSDarrick J. Wong ap->offset = orig_offset; 36446d8a45ceSDarrick J. Wong else if (ap->offset + ap->length < orig_offset + orig_length) 36456d8a45ceSDarrick J. Wong ap->offset = orig_offset + orig_length - ap->length; 3646751f3767SDarrick J. Wong xfs_bmap_btalloc_accounting(ap, &args); 364730f712c9SDave Chinner } else { 364830f712c9SDave Chinner ap->blkno = NULLFSBLOCK; 364930f712c9SDave Chinner ap->length = 0; 365030f712c9SDave Chinner } 365130f712c9SDave Chinner return 0; 365230f712c9SDave Chinner } 365330f712c9SDave Chinner 365430f712c9SDave Chinner /* 365530f712c9SDave Chinner * xfs_bmap_alloc is called by xfs_bmapi to allocate an extent for a file. 365630f712c9SDave Chinner * It figures out where to ask the underlying allocator to put the new extent. 365730f712c9SDave Chinner */ 365830f712c9SDave Chinner STATIC int 365930f712c9SDave Chinner xfs_bmap_alloc( 366030f712c9SDave Chinner struct xfs_bmalloca *ap) /* bmap alloc argument struct */ 366130f712c9SDave Chinner { 3662292378edSDave Chinner if (XFS_IS_REALTIME_INODE(ap->ip) && 3663292378edSDave Chinner xfs_alloc_is_userdata(ap->datatype)) 366430f712c9SDave Chinner return xfs_bmap_rtalloc(ap); 366530f712c9SDave Chinner return xfs_bmap_btalloc(ap); 366630f712c9SDave Chinner } 366730f712c9SDave Chinner 36680a0af28cSDarrick J. Wong /* Trim extent to fit a logical block range. */ 36690a0af28cSDarrick J. Wong void 36700a0af28cSDarrick J. Wong xfs_trim_extent( 36710a0af28cSDarrick J. Wong struct xfs_bmbt_irec *irec, 36720a0af28cSDarrick J. Wong xfs_fileoff_t bno, 36730a0af28cSDarrick J. Wong xfs_filblks_t len) 36740a0af28cSDarrick J. Wong { 36750a0af28cSDarrick J. Wong xfs_fileoff_t distance; 36760a0af28cSDarrick J. Wong xfs_fileoff_t end = bno + len; 36770a0af28cSDarrick J. Wong 36780a0af28cSDarrick J. Wong if (irec->br_startoff + irec->br_blockcount <= bno || 36790a0af28cSDarrick J. Wong irec->br_startoff >= end) { 36800a0af28cSDarrick J. Wong irec->br_blockcount = 0; 36810a0af28cSDarrick J. Wong return; 36820a0af28cSDarrick J. Wong } 36830a0af28cSDarrick J. Wong 36840a0af28cSDarrick J. Wong if (irec->br_startoff < bno) { 36850a0af28cSDarrick J. Wong distance = bno - irec->br_startoff; 36860a0af28cSDarrick J. Wong if (isnullstartblock(irec->br_startblock)) 36870a0af28cSDarrick J. Wong irec->br_startblock = DELAYSTARTBLOCK; 36880a0af28cSDarrick J. Wong if (irec->br_startblock != DELAYSTARTBLOCK && 36890a0af28cSDarrick J. Wong irec->br_startblock != HOLESTARTBLOCK) 36900a0af28cSDarrick J. Wong irec->br_startblock += distance; 36910a0af28cSDarrick J. Wong irec->br_startoff += distance; 36920a0af28cSDarrick J. Wong irec->br_blockcount -= distance; 36930a0af28cSDarrick J. Wong } 36940a0af28cSDarrick J. Wong 36950a0af28cSDarrick J. Wong if (end < irec->br_startoff + irec->br_blockcount) { 36960a0af28cSDarrick J. Wong distance = irec->br_startoff + irec->br_blockcount - end; 36970a0af28cSDarrick J. Wong irec->br_blockcount -= distance; 36980a0af28cSDarrick J. Wong } 36990a0af28cSDarrick J. Wong } 37000a0af28cSDarrick J. Wong 370140214d12SBrian Foster /* trim extent to within eof */ 370240214d12SBrian Foster void 370340214d12SBrian Foster xfs_trim_extent_eof( 370440214d12SBrian Foster struct xfs_bmbt_irec *irec, 370540214d12SBrian Foster struct xfs_inode *ip) 370640214d12SBrian Foster 370740214d12SBrian Foster { 370840214d12SBrian Foster xfs_trim_extent(irec, 0, XFS_B_TO_FSB(ip->i_mount, 370940214d12SBrian Foster i_size_read(VFS_I(ip)))); 371040214d12SBrian Foster } 371140214d12SBrian Foster 371230f712c9SDave Chinner /* 371330f712c9SDave Chinner * Trim the returned map to the required bounds 371430f712c9SDave Chinner */ 371530f712c9SDave Chinner STATIC void 371630f712c9SDave Chinner xfs_bmapi_trim_map( 371730f712c9SDave Chinner struct xfs_bmbt_irec *mval, 371830f712c9SDave Chinner struct xfs_bmbt_irec *got, 371930f712c9SDave Chinner xfs_fileoff_t *bno, 372030f712c9SDave Chinner xfs_filblks_t len, 372130f712c9SDave Chinner xfs_fileoff_t obno, 372230f712c9SDave Chinner xfs_fileoff_t end, 372330f712c9SDave Chinner int n, 372430f712c9SDave Chinner int flags) 372530f712c9SDave Chinner { 372630f712c9SDave Chinner if ((flags & XFS_BMAPI_ENTIRE) || 372730f712c9SDave Chinner got->br_startoff + got->br_blockcount <= obno) { 372830f712c9SDave Chinner *mval = *got; 372930f712c9SDave Chinner if (isnullstartblock(got->br_startblock)) 373030f712c9SDave Chinner mval->br_startblock = DELAYSTARTBLOCK; 373130f712c9SDave Chinner return; 373230f712c9SDave Chinner } 373330f712c9SDave Chinner 373430f712c9SDave Chinner if (obno > *bno) 373530f712c9SDave Chinner *bno = obno; 373630f712c9SDave Chinner ASSERT((*bno >= obno) || (n == 0)); 373730f712c9SDave Chinner ASSERT(*bno < end); 373830f712c9SDave Chinner mval->br_startoff = *bno; 373930f712c9SDave Chinner if (isnullstartblock(got->br_startblock)) 374030f712c9SDave Chinner mval->br_startblock = DELAYSTARTBLOCK; 374130f712c9SDave Chinner else 374230f712c9SDave Chinner mval->br_startblock = got->br_startblock + 374330f712c9SDave Chinner (*bno - got->br_startoff); 374430f712c9SDave Chinner /* 374530f712c9SDave Chinner * Return the minimum of what we got and what we asked for for 374630f712c9SDave Chinner * the length. We can use the len variable here because it is 374730f712c9SDave Chinner * modified below and we could have been there before coming 374830f712c9SDave Chinner * here if the first part of the allocation didn't overlap what 374930f712c9SDave Chinner * was asked for. 375030f712c9SDave Chinner */ 375130f712c9SDave Chinner mval->br_blockcount = XFS_FILBLKS_MIN(end - *bno, 375230f712c9SDave Chinner got->br_blockcount - (*bno - got->br_startoff)); 375330f712c9SDave Chinner mval->br_state = got->br_state; 375430f712c9SDave Chinner ASSERT(mval->br_blockcount <= len); 375530f712c9SDave Chinner return; 375630f712c9SDave Chinner } 375730f712c9SDave Chinner 375830f712c9SDave Chinner /* 375930f712c9SDave Chinner * Update and validate the extent map to return 376030f712c9SDave Chinner */ 376130f712c9SDave Chinner STATIC void 376230f712c9SDave Chinner xfs_bmapi_update_map( 376330f712c9SDave Chinner struct xfs_bmbt_irec **map, 376430f712c9SDave Chinner xfs_fileoff_t *bno, 376530f712c9SDave Chinner xfs_filblks_t *len, 376630f712c9SDave Chinner xfs_fileoff_t obno, 376730f712c9SDave Chinner xfs_fileoff_t end, 376830f712c9SDave Chinner int *n, 376930f712c9SDave Chinner int flags) 377030f712c9SDave Chinner { 377130f712c9SDave Chinner xfs_bmbt_irec_t *mval = *map; 377230f712c9SDave Chinner 377330f712c9SDave Chinner ASSERT((flags & XFS_BMAPI_ENTIRE) || 377430f712c9SDave Chinner ((mval->br_startoff + mval->br_blockcount) <= end)); 377530f712c9SDave Chinner ASSERT((flags & XFS_BMAPI_ENTIRE) || (mval->br_blockcount <= *len) || 377630f712c9SDave Chinner (mval->br_startoff < obno)); 377730f712c9SDave Chinner 377830f712c9SDave Chinner *bno = mval->br_startoff + mval->br_blockcount; 377930f712c9SDave Chinner *len = end - *bno; 378030f712c9SDave Chinner if (*n > 0 && mval->br_startoff == mval[-1].br_startoff) { 378130f712c9SDave Chinner /* update previous map with new information */ 378230f712c9SDave Chinner ASSERT(mval->br_startblock == mval[-1].br_startblock); 378330f712c9SDave Chinner ASSERT(mval->br_blockcount > mval[-1].br_blockcount); 378430f712c9SDave Chinner ASSERT(mval->br_state == mval[-1].br_state); 378530f712c9SDave Chinner mval[-1].br_blockcount = mval->br_blockcount; 378630f712c9SDave Chinner mval[-1].br_state = mval->br_state; 378730f712c9SDave Chinner } else if (*n > 0 && mval->br_startblock != DELAYSTARTBLOCK && 378830f712c9SDave Chinner mval[-1].br_startblock != DELAYSTARTBLOCK && 378930f712c9SDave Chinner mval[-1].br_startblock != HOLESTARTBLOCK && 379030f712c9SDave Chinner mval->br_startblock == mval[-1].br_startblock + 379130f712c9SDave Chinner mval[-1].br_blockcount && 379230f712c9SDave Chinner ((flags & XFS_BMAPI_IGSTATE) || 379330f712c9SDave Chinner mval[-1].br_state == mval->br_state)) { 379430f712c9SDave Chinner ASSERT(mval->br_startoff == 379530f712c9SDave Chinner mval[-1].br_startoff + mval[-1].br_blockcount); 379630f712c9SDave Chinner mval[-1].br_blockcount += mval->br_blockcount; 379730f712c9SDave Chinner } else if (*n > 0 && 379830f712c9SDave Chinner mval->br_startblock == DELAYSTARTBLOCK && 379930f712c9SDave Chinner mval[-1].br_startblock == DELAYSTARTBLOCK && 380030f712c9SDave Chinner mval->br_startoff == 380130f712c9SDave Chinner mval[-1].br_startoff + mval[-1].br_blockcount) { 380230f712c9SDave Chinner mval[-1].br_blockcount += mval->br_blockcount; 380330f712c9SDave Chinner mval[-1].br_state = mval->br_state; 380430f712c9SDave Chinner } else if (!((*n == 0) && 380530f712c9SDave Chinner ((mval->br_startoff + mval->br_blockcount) <= 380630f712c9SDave Chinner obno))) { 380730f712c9SDave Chinner mval++; 380830f712c9SDave Chinner (*n)++; 380930f712c9SDave Chinner } 381030f712c9SDave Chinner *map = mval; 381130f712c9SDave Chinner } 381230f712c9SDave Chinner 381330f712c9SDave Chinner /* 381430f712c9SDave Chinner * Map file blocks to filesystem blocks without allocation. 381530f712c9SDave Chinner */ 381630f712c9SDave Chinner int 381730f712c9SDave Chinner xfs_bmapi_read( 381830f712c9SDave Chinner struct xfs_inode *ip, 381930f712c9SDave Chinner xfs_fileoff_t bno, 382030f712c9SDave Chinner xfs_filblks_t len, 382130f712c9SDave Chinner struct xfs_bmbt_irec *mval, 382230f712c9SDave Chinner int *nmap, 382330f712c9SDave Chinner int flags) 382430f712c9SDave Chinner { 382530f712c9SDave Chinner struct xfs_mount *mp = ip->i_mount; 382630f712c9SDave Chinner struct xfs_ifork *ifp; 382730f712c9SDave Chinner struct xfs_bmbt_irec got; 382830f712c9SDave Chinner xfs_fileoff_t obno; 382930f712c9SDave Chinner xfs_fileoff_t end; 3830b2b1712aSChristoph Hellwig struct xfs_iext_cursor icur; 383130f712c9SDave Chinner int error; 3832334f3423SChristoph Hellwig bool eof = false; 383330f712c9SDave Chinner int n = 0; 38343993baebSDarrick J. Wong int whichfork = xfs_bmapi_whichfork(flags); 383530f712c9SDave Chinner 383630f712c9SDave Chinner ASSERT(*nmap >= 1); 383730f712c9SDave Chinner ASSERT(!(flags & ~(XFS_BMAPI_ATTRFORK|XFS_BMAPI_ENTIRE| 38383993baebSDarrick J. Wong XFS_BMAPI_IGSTATE|XFS_BMAPI_COWFORK))); 383930f712c9SDave Chinner ASSERT(xfs_isilocked(ip, XFS_ILOCK_SHARED|XFS_ILOCK_EXCL)); 384030f712c9SDave Chinner 384130f712c9SDave Chinner if (unlikely(XFS_TEST_ERROR( 384230f712c9SDave Chinner (XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS && 384330f712c9SDave Chinner XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE), 38449e24cfd0SDarrick J. Wong mp, XFS_ERRTAG_BMAPIFORMAT))) { 384530f712c9SDave Chinner XFS_ERROR_REPORT("xfs_bmapi_read", XFS_ERRLEVEL_LOW, mp); 38462451337dSDave Chinner return -EFSCORRUPTED; 384730f712c9SDave Chinner } 384830f712c9SDave Chinner 384930f712c9SDave Chinner if (XFS_FORCED_SHUTDOWN(mp)) 38502451337dSDave Chinner return -EIO; 385130f712c9SDave Chinner 3852ff6d6af2SBill O'Donnell XFS_STATS_INC(mp, xs_blk_mapr); 385330f712c9SDave Chinner 385430f712c9SDave Chinner ifp = XFS_IFORK_PTR(ip, whichfork); 385530f712c9SDave Chinner 38563993baebSDarrick J. Wong /* No CoW fork? Return a hole. */ 38573993baebSDarrick J. Wong if (whichfork == XFS_COW_FORK && !ifp) { 38583993baebSDarrick J. Wong mval->br_startoff = bno; 38593993baebSDarrick J. Wong mval->br_startblock = HOLESTARTBLOCK; 38603993baebSDarrick J. Wong mval->br_blockcount = len; 38613993baebSDarrick J. Wong mval->br_state = XFS_EXT_NORM; 38623993baebSDarrick J. Wong *nmap = 1; 38633993baebSDarrick J. Wong return 0; 38643993baebSDarrick J. Wong } 38653993baebSDarrick J. Wong 386630f712c9SDave Chinner if (!(ifp->if_flags & XFS_IFEXTENTS)) { 386730f712c9SDave Chinner error = xfs_iread_extents(NULL, ip, whichfork); 386830f712c9SDave Chinner if (error) 386930f712c9SDave Chinner return error; 387030f712c9SDave Chinner } 387130f712c9SDave Chinner 3872b2b1712aSChristoph Hellwig if (!xfs_iext_lookup_extent(ip, ifp, bno, &icur, &got)) 3873334f3423SChristoph Hellwig eof = true; 387430f712c9SDave Chinner end = bno + len; 387530f712c9SDave Chinner obno = bno; 387630f712c9SDave Chinner 387730f712c9SDave Chinner while (bno < end && n < *nmap) { 387830f712c9SDave Chinner /* Reading past eof, act as though there's a hole up to end. */ 387930f712c9SDave Chinner if (eof) 388030f712c9SDave Chinner got.br_startoff = end; 388130f712c9SDave Chinner if (got.br_startoff > bno) { 388230f712c9SDave Chinner /* Reading in a hole. */ 388330f712c9SDave Chinner mval->br_startoff = bno; 388430f712c9SDave Chinner mval->br_startblock = HOLESTARTBLOCK; 388530f712c9SDave Chinner mval->br_blockcount = 388630f712c9SDave Chinner XFS_FILBLKS_MIN(len, got.br_startoff - bno); 388730f712c9SDave Chinner mval->br_state = XFS_EXT_NORM; 388830f712c9SDave Chinner bno += mval->br_blockcount; 388930f712c9SDave Chinner len -= mval->br_blockcount; 389030f712c9SDave Chinner mval++; 389130f712c9SDave Chinner n++; 389230f712c9SDave Chinner continue; 389330f712c9SDave Chinner } 389430f712c9SDave Chinner 389530f712c9SDave Chinner /* set up the extent map to return. */ 389630f712c9SDave Chinner xfs_bmapi_trim_map(mval, &got, &bno, len, obno, end, n, flags); 389730f712c9SDave Chinner xfs_bmapi_update_map(&mval, &bno, &len, obno, end, &n, flags); 389830f712c9SDave Chinner 389930f712c9SDave Chinner /* If we're done, stop now. */ 390030f712c9SDave Chinner if (bno >= end || n >= *nmap) 390130f712c9SDave Chinner break; 390230f712c9SDave Chinner 390330f712c9SDave Chinner /* Else go on to the next record. */ 3904b2b1712aSChristoph Hellwig if (!xfs_iext_next_extent(ifp, &icur, &got)) 3905334f3423SChristoph Hellwig eof = true; 390630f712c9SDave Chinner } 390730f712c9SDave Chinner *nmap = n; 390830f712c9SDave Chinner return 0; 390930f712c9SDave Chinner } 391030f712c9SDave Chinner 3911f65e6fadSBrian Foster /* 3912f65e6fadSBrian Foster * Add a delayed allocation extent to an inode. Blocks are reserved from the 3913f65e6fadSBrian Foster * global pool and the extent inserted into the inode in-core extent tree. 3914f65e6fadSBrian Foster * 3915f65e6fadSBrian Foster * On entry, got refers to the first extent beyond the offset of the extent to 3916f65e6fadSBrian Foster * allocate or eof is specified if no such extent exists. On return, got refers 3917f65e6fadSBrian Foster * to the extent record that was inserted to the inode fork. 3918f65e6fadSBrian Foster * 3919f65e6fadSBrian Foster * Note that the allocated extent may have been merged with contiguous extents 3920f65e6fadSBrian Foster * during insertion into the inode fork. Thus, got does not reflect the current 3921f65e6fadSBrian Foster * state of the inode fork on return. If necessary, the caller can use lastx to 3922f65e6fadSBrian Foster * look up the updated record in the inode fork. 3923f65e6fadSBrian Foster */ 392451446f5bSChristoph Hellwig int 392530f712c9SDave Chinner xfs_bmapi_reserve_delalloc( 392630f712c9SDave Chinner struct xfs_inode *ip, 3927be51f811SDarrick J. Wong int whichfork, 3928974ae922SBrian Foster xfs_fileoff_t off, 392930f712c9SDave Chinner xfs_filblks_t len, 3930974ae922SBrian Foster xfs_filblks_t prealloc, 393130f712c9SDave Chinner struct xfs_bmbt_irec *got, 3932b2b1712aSChristoph Hellwig struct xfs_iext_cursor *icur, 393330f712c9SDave Chinner int eof) 393430f712c9SDave Chinner { 393530f712c9SDave Chinner struct xfs_mount *mp = ip->i_mount; 3936be51f811SDarrick J. Wong struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, whichfork); 393730f712c9SDave Chinner xfs_extlen_t alen; 393830f712c9SDave Chinner xfs_extlen_t indlen; 393930f712c9SDave Chinner int error; 3940974ae922SBrian Foster xfs_fileoff_t aoff = off; 394130f712c9SDave Chinner 3942974ae922SBrian Foster /* 3943974ae922SBrian Foster * Cap the alloc length. Keep track of prealloc so we know whether to 3944974ae922SBrian Foster * tag the inode before we return. 3945974ae922SBrian Foster */ 3946974ae922SBrian Foster alen = XFS_FILBLKS_MIN(len + prealloc, MAXEXTLEN); 394730f712c9SDave Chinner if (!eof) 394830f712c9SDave Chinner alen = XFS_FILBLKS_MIN(alen, got->br_startoff - aoff); 3949974ae922SBrian Foster if (prealloc && alen >= len) 3950974ae922SBrian Foster prealloc = alen - len; 395130f712c9SDave Chinner 395230f712c9SDave Chinner /* Figure out the extent size, adjust alen */ 39536ca30729SShan Hai if (whichfork == XFS_COW_FORK) { 395465c5f419SChristoph Hellwig struct xfs_bmbt_irec prev; 39556ca30729SShan Hai xfs_extlen_t extsz = xfs_get_cowextsz_hint(ip); 395665c5f419SChristoph Hellwig 3957b2b1712aSChristoph Hellwig if (!xfs_iext_peek_prev_extent(ifp, icur, &prev)) 395865c5f419SChristoph Hellwig prev.br_startoff = NULLFILEOFF; 395965c5f419SChristoph Hellwig 39606ca30729SShan Hai error = xfs_bmap_extsize_align(mp, got, &prev, extsz, 0, eof, 396130f712c9SDave Chinner 1, 0, &aoff, &alen); 396230f712c9SDave Chinner ASSERT(!error); 396330f712c9SDave Chinner } 396430f712c9SDave Chinner 396530f712c9SDave Chinner /* 396630f712c9SDave Chinner * Make a transaction-less quota reservation for delayed allocation 396730f712c9SDave Chinner * blocks. This number gets adjusted later. We return if we haven't 396830f712c9SDave Chinner * allocated blocks already inside this loop. 396930f712c9SDave Chinner */ 397030f712c9SDave Chinner error = xfs_trans_reserve_quota_nblks(NULL, ip, (long)alen, 0, 39716ca30729SShan Hai XFS_QMOPT_RES_REGBLKS); 397230f712c9SDave Chinner if (error) 397330f712c9SDave Chinner return error; 397430f712c9SDave Chinner 397530f712c9SDave Chinner /* 397630f712c9SDave Chinner * Split changing sb for alen and indlen since they could be coming 397730f712c9SDave Chinner * from different places. 397830f712c9SDave Chinner */ 397930f712c9SDave Chinner indlen = (xfs_extlen_t)xfs_bmap_worst_indlen(ip, alen); 398030f712c9SDave Chinner ASSERT(indlen > 0); 398130f712c9SDave Chinner 39820d485adaSDave Chinner error = xfs_mod_fdblocks(mp, -((int64_t)alen), false); 398330f712c9SDave Chinner if (error) 398430f712c9SDave Chinner goto out_unreserve_quota; 398530f712c9SDave Chinner 39860d485adaSDave Chinner error = xfs_mod_fdblocks(mp, -((int64_t)indlen), false); 398730f712c9SDave Chinner if (error) 398830f712c9SDave Chinner goto out_unreserve_blocks; 398930f712c9SDave Chinner 399030f712c9SDave Chinner 399130f712c9SDave Chinner ip->i_delayed_blks += alen; 399230f712c9SDave Chinner 399330f712c9SDave Chinner got->br_startoff = aoff; 399430f712c9SDave Chinner got->br_startblock = nullstartblock(indlen); 399530f712c9SDave Chinner got->br_blockcount = alen; 399630f712c9SDave Chinner got->br_state = XFS_EXT_NORM; 399730f712c9SDave Chinner 3998b2b1712aSChristoph Hellwig xfs_bmap_add_extent_hole_delay(ip, whichfork, icur, got); 399930f712c9SDave Chinner 4000974ae922SBrian Foster /* 4001974ae922SBrian Foster * Tag the inode if blocks were preallocated. Note that COW fork 4002974ae922SBrian Foster * preallocation can occur at the start or end of the extent, even when 4003974ae922SBrian Foster * prealloc == 0, so we must also check the aligned offset and length. 4004974ae922SBrian Foster */ 4005974ae922SBrian Foster if (whichfork == XFS_DATA_FORK && prealloc) 4006974ae922SBrian Foster xfs_inode_set_eofblocks_tag(ip); 4007974ae922SBrian Foster if (whichfork == XFS_COW_FORK && (prealloc || aoff < off || alen > len)) 4008974ae922SBrian Foster xfs_inode_set_cowblocks_tag(ip); 4009974ae922SBrian Foster 401030f712c9SDave Chinner return 0; 401130f712c9SDave Chinner 401230f712c9SDave Chinner out_unreserve_blocks: 40130d485adaSDave Chinner xfs_mod_fdblocks(mp, alen, false); 401430f712c9SDave Chinner out_unreserve_quota: 401530f712c9SDave Chinner if (XFS_IS_QUOTA_ON(mp)) 40166ca30729SShan Hai xfs_trans_unreserve_quota_nblks(NULL, ip, (long)alen, 0, 40176ca30729SShan Hai XFS_QMOPT_RES_REGBLKS); 401830f712c9SDave Chinner return error; 401930f712c9SDave Chinner } 402030f712c9SDave Chinner 40217f8a058fSDave Chinner static int 40227f8a058fSDave Chinner xfs_bmapi_allocate( 402330f712c9SDave Chinner struct xfs_bmalloca *bma) 402430f712c9SDave Chinner { 402530f712c9SDave Chinner struct xfs_mount *mp = bma->ip->i_mount; 402660b4984fSDarrick J. Wong int whichfork = xfs_bmapi_whichfork(bma->flags); 402730f712c9SDave Chinner struct xfs_ifork *ifp = XFS_IFORK_PTR(bma->ip, whichfork); 402830f712c9SDave Chinner int tmp_logflags = 0; 402930f712c9SDave Chinner int error; 403030f712c9SDave Chinner 403130f712c9SDave Chinner ASSERT(bma->length > 0); 403230f712c9SDave Chinner 403330f712c9SDave Chinner /* 403430f712c9SDave Chinner * For the wasdelay case, we could also just allocate the stuff asked 403530f712c9SDave Chinner * for in this bmap call but that wouldn't be as good. 403630f712c9SDave Chinner */ 403730f712c9SDave Chinner if (bma->wasdel) { 403830f712c9SDave Chinner bma->length = (xfs_extlen_t)bma->got.br_blockcount; 403930f712c9SDave Chinner bma->offset = bma->got.br_startoff; 4040b2b1712aSChristoph Hellwig xfs_iext_peek_prev_extent(ifp, &bma->icur, &bma->prev); 404130f712c9SDave Chinner } else { 404230f712c9SDave Chinner bma->length = XFS_FILBLKS_MIN(bma->length, MAXEXTLEN); 404330f712c9SDave Chinner if (!bma->eof) 404430f712c9SDave Chinner bma->length = XFS_FILBLKS_MIN(bma->length, 404530f712c9SDave Chinner bma->got.br_startoff - bma->offset); 404630f712c9SDave Chinner } 404730f712c9SDave Chinner 404830f712c9SDave Chinner /* 4049292378edSDave Chinner * Set the data type being allocated. For the data fork, the first data 4050292378edSDave Chinner * in the file is treated differently to all other allocations. For the 4051292378edSDave Chinner * attribute fork, we only need to ensure the allocated range is not on 4052292378edSDave Chinner * the busy list. 405330f712c9SDave Chinner */ 405430f712c9SDave Chinner if (!(bma->flags & XFS_BMAPI_METADATA)) { 4055292378edSDave Chinner bma->datatype = XFS_ALLOC_NOBUSY; 4056292378edSDave Chinner if (whichfork == XFS_DATA_FORK) { 4057292378edSDave Chinner if (bma->offset == 0) 4058292378edSDave Chinner bma->datatype |= XFS_ALLOC_INITIAL_USER_DATA; 4059292378edSDave Chinner else 4060292378edSDave Chinner bma->datatype |= XFS_ALLOC_USERDATA; 4061292378edSDave Chinner } 40623fbbbea3SDave Chinner if (bma->flags & XFS_BMAPI_ZERO) 4063292378edSDave Chinner bma->datatype |= XFS_ALLOC_USERDATA_ZERO; 406430f712c9SDave Chinner } 406530f712c9SDave Chinner 406630f712c9SDave Chinner bma->minlen = (bma->flags & XFS_BMAPI_CONTIG) ? bma->length : 1; 406730f712c9SDave Chinner 406830f712c9SDave Chinner /* 406930f712c9SDave Chinner * Only want to do the alignment at the eof if it is userdata and 407030f712c9SDave Chinner * allocation length is larger than a stripe unit. 407130f712c9SDave Chinner */ 407230f712c9SDave Chinner if (mp->m_dalign && bma->length >= mp->m_dalign && 407330f712c9SDave Chinner !(bma->flags & XFS_BMAPI_METADATA) && whichfork == XFS_DATA_FORK) { 407430f712c9SDave Chinner error = xfs_bmap_isaeof(bma, whichfork); 407530f712c9SDave Chinner if (error) 407630f712c9SDave Chinner return error; 407730f712c9SDave Chinner } 407830f712c9SDave Chinner 407930f712c9SDave Chinner error = xfs_bmap_alloc(bma); 408030f712c9SDave Chinner if (error) 408130f712c9SDave Chinner return error; 408230f712c9SDave Chinner 408330f712c9SDave Chinner if (bma->cur) 408430f712c9SDave Chinner bma->cur->bc_private.b.firstblock = *bma->firstblock; 408530f712c9SDave Chinner if (bma->blkno == NULLFSBLOCK) 408630f712c9SDave Chinner return 0; 408730f712c9SDave Chinner if ((ifp->if_flags & XFS_IFBROOT) && !bma->cur) { 408830f712c9SDave Chinner bma->cur = xfs_bmbt_init_cursor(mp, bma->tp, bma->ip, whichfork); 408930f712c9SDave Chinner bma->cur->bc_private.b.firstblock = *bma->firstblock; 40902c3234d1SDarrick J. Wong bma->cur->bc_private.b.dfops = bma->dfops; 409130f712c9SDave Chinner } 409230f712c9SDave Chinner /* 409330f712c9SDave Chinner * Bump the number of extents we've allocated 409430f712c9SDave Chinner * in this call. 409530f712c9SDave Chinner */ 409630f712c9SDave Chinner bma->nallocs++; 409730f712c9SDave Chinner 409830f712c9SDave Chinner if (bma->cur) 409930f712c9SDave Chinner bma->cur->bc_private.b.flags = 410030f712c9SDave Chinner bma->wasdel ? XFS_BTCUR_BPRV_WASDEL : 0; 410130f712c9SDave Chinner 410230f712c9SDave Chinner bma->got.br_startoff = bma->offset; 410330f712c9SDave Chinner bma->got.br_startblock = bma->blkno; 410430f712c9SDave Chinner bma->got.br_blockcount = bma->length; 410530f712c9SDave Chinner bma->got.br_state = XFS_EXT_NORM; 410630f712c9SDave Chinner 410730f712c9SDave Chinner /* 410805a630d7SDarrick J. Wong * In the data fork, a wasdelay extent has been initialized, so 410905a630d7SDarrick J. Wong * shouldn't be flagged as unwritten. 411005a630d7SDarrick J. Wong * 411105a630d7SDarrick J. Wong * For the cow fork, however, we convert delalloc reservations 411205a630d7SDarrick J. Wong * (extents allocated for speculative preallocation) to 411305a630d7SDarrick J. Wong * allocated unwritten extents, and only convert the unwritten 411405a630d7SDarrick J. Wong * extents to real extents when we're about to write the data. 411530f712c9SDave Chinner */ 411605a630d7SDarrick J. Wong if ((!bma->wasdel || (bma->flags & XFS_BMAPI_COWFORK)) && 411705a630d7SDarrick J. Wong (bma->flags & XFS_BMAPI_PREALLOC) && 411830f712c9SDave Chinner xfs_sb_version_hasextflgbit(&mp->m_sb)) 411930f712c9SDave Chinner bma->got.br_state = XFS_EXT_UNWRITTEN; 412030f712c9SDave Chinner 412130f712c9SDave Chinner if (bma->wasdel) 412260b4984fSDarrick J. Wong error = xfs_bmap_add_extent_delay_real(bma, whichfork); 412330f712c9SDave Chinner else 41246d04558fSChristoph Hellwig error = xfs_bmap_add_extent_hole_real(bma->tp, bma->ip, 4125b2b1712aSChristoph Hellwig whichfork, &bma->icur, &bma->cur, &bma->got, 41266d04558fSChristoph Hellwig bma->firstblock, bma->dfops, &bma->logflags); 412730f712c9SDave Chinner 412830f712c9SDave Chinner bma->logflags |= tmp_logflags; 412930f712c9SDave Chinner if (error) 413030f712c9SDave Chinner return error; 413130f712c9SDave Chinner 413230f712c9SDave Chinner /* 413330f712c9SDave Chinner * Update our extent pointer, given that xfs_bmap_add_extent_delay_real 413430f712c9SDave Chinner * or xfs_bmap_add_extent_hole_real might have merged it into one of 413530f712c9SDave Chinner * the neighbouring ones. 413630f712c9SDave Chinner */ 4137b2b1712aSChristoph Hellwig xfs_iext_get_extent(ifp, &bma->icur, &bma->got); 413830f712c9SDave Chinner 413930f712c9SDave Chinner ASSERT(bma->got.br_startoff <= bma->offset); 414030f712c9SDave Chinner ASSERT(bma->got.br_startoff + bma->got.br_blockcount >= 414130f712c9SDave Chinner bma->offset + bma->length); 414230f712c9SDave Chinner ASSERT(bma->got.br_state == XFS_EXT_NORM || 414330f712c9SDave Chinner bma->got.br_state == XFS_EXT_UNWRITTEN); 414430f712c9SDave Chinner return 0; 414530f712c9SDave Chinner } 414630f712c9SDave Chinner 414730f712c9SDave Chinner STATIC int 414830f712c9SDave Chinner xfs_bmapi_convert_unwritten( 414930f712c9SDave Chinner struct xfs_bmalloca *bma, 415030f712c9SDave Chinner struct xfs_bmbt_irec *mval, 415130f712c9SDave Chinner xfs_filblks_t len, 415230f712c9SDave Chinner int flags) 415330f712c9SDave Chinner { 41543993baebSDarrick J. Wong int whichfork = xfs_bmapi_whichfork(flags); 415530f712c9SDave Chinner struct xfs_ifork *ifp = XFS_IFORK_PTR(bma->ip, whichfork); 415630f712c9SDave Chinner int tmp_logflags = 0; 415730f712c9SDave Chinner int error; 415830f712c9SDave Chinner 415930f712c9SDave Chinner /* check if we need to do unwritten->real conversion */ 416030f712c9SDave Chinner if (mval->br_state == XFS_EXT_UNWRITTEN && 416130f712c9SDave Chinner (flags & XFS_BMAPI_PREALLOC)) 416230f712c9SDave Chinner return 0; 416330f712c9SDave Chinner 416430f712c9SDave Chinner /* check if we need to do real->unwritten conversion */ 416530f712c9SDave Chinner if (mval->br_state == XFS_EXT_NORM && 416630f712c9SDave Chinner (flags & (XFS_BMAPI_PREALLOC | XFS_BMAPI_CONVERT)) != 416730f712c9SDave Chinner (XFS_BMAPI_PREALLOC | XFS_BMAPI_CONVERT)) 416830f712c9SDave Chinner return 0; 416930f712c9SDave Chinner 417030f712c9SDave Chinner /* 417130f712c9SDave Chinner * Modify (by adding) the state flag, if writing. 417230f712c9SDave Chinner */ 417330f712c9SDave Chinner ASSERT(mval->br_blockcount <= len); 417430f712c9SDave Chinner if ((ifp->if_flags & XFS_IFBROOT) && !bma->cur) { 417530f712c9SDave Chinner bma->cur = xfs_bmbt_init_cursor(bma->ip->i_mount, bma->tp, 417630f712c9SDave Chinner bma->ip, whichfork); 417730f712c9SDave Chinner bma->cur->bc_private.b.firstblock = *bma->firstblock; 41782c3234d1SDarrick J. Wong bma->cur->bc_private.b.dfops = bma->dfops; 417930f712c9SDave Chinner } 418030f712c9SDave Chinner mval->br_state = (mval->br_state == XFS_EXT_UNWRITTEN) 418130f712c9SDave Chinner ? XFS_EXT_NORM : XFS_EXT_UNWRITTEN; 418230f712c9SDave Chinner 41833fbbbea3SDave Chinner /* 41843fbbbea3SDave Chinner * Before insertion into the bmbt, zero the range being converted 41853fbbbea3SDave Chinner * if required. 41863fbbbea3SDave Chinner */ 41873fbbbea3SDave Chinner if (flags & XFS_BMAPI_ZERO) { 41883fbbbea3SDave Chinner error = xfs_zero_extent(bma->ip, mval->br_startblock, 41893fbbbea3SDave Chinner mval->br_blockcount); 41903fbbbea3SDave Chinner if (error) 41913fbbbea3SDave Chinner return error; 41923fbbbea3SDave Chinner } 41933fbbbea3SDave Chinner 419405a630d7SDarrick J. Wong error = xfs_bmap_add_extent_unwritten_real(bma->tp, bma->ip, whichfork, 4195b2b1712aSChristoph Hellwig &bma->icur, &bma->cur, mval, bma->firstblock, 4196b2b1712aSChristoph Hellwig bma->dfops, &tmp_logflags); 41972e588a46SBrian Foster /* 41982e588a46SBrian Foster * Log the inode core unconditionally in the unwritten extent conversion 41992e588a46SBrian Foster * path because the conversion might not have done so (e.g., if the 42002e588a46SBrian Foster * extent count hasn't changed). We need to make sure the inode is dirty 42012e588a46SBrian Foster * in the transaction for the sake of fsync(), even if nothing has 42022e588a46SBrian Foster * changed, because fsync() will not force the log for this transaction 42032e588a46SBrian Foster * unless it sees the inode pinned. 420405a630d7SDarrick J. Wong * 420505a630d7SDarrick J. Wong * Note: If we're only converting cow fork extents, there aren't 420605a630d7SDarrick J. Wong * any on-disk updates to make, so we don't need to log anything. 42072e588a46SBrian Foster */ 420805a630d7SDarrick J. Wong if (whichfork != XFS_COW_FORK) 42092e588a46SBrian Foster bma->logflags |= tmp_logflags | XFS_ILOG_CORE; 421030f712c9SDave Chinner if (error) 421130f712c9SDave Chinner return error; 421230f712c9SDave Chinner 421330f712c9SDave Chinner /* 421430f712c9SDave Chinner * Update our extent pointer, given that 421530f712c9SDave Chinner * xfs_bmap_add_extent_unwritten_real might have merged it into one 421630f712c9SDave Chinner * of the neighbouring ones. 421730f712c9SDave Chinner */ 4218b2b1712aSChristoph Hellwig xfs_iext_get_extent(ifp, &bma->icur, &bma->got); 421930f712c9SDave Chinner 422030f712c9SDave Chinner /* 422130f712c9SDave Chinner * We may have combined previously unwritten space with written space, 422230f712c9SDave Chinner * so generate another request. 422330f712c9SDave Chinner */ 422430f712c9SDave Chinner if (mval->br_blockcount < len) 42252451337dSDave Chinner return -EAGAIN; 422630f712c9SDave Chinner return 0; 422730f712c9SDave Chinner } 422830f712c9SDave Chinner 422930f712c9SDave Chinner /* 423030f712c9SDave Chinner * Map file blocks to filesystem blocks, and allocate blocks or convert the 423130f712c9SDave Chinner * extent state if necessary. Details behaviour is controlled by the flags 423230f712c9SDave Chinner * parameter. Only allocates blocks from a single allocation group, to avoid 423330f712c9SDave Chinner * locking problems. 423430f712c9SDave Chinner * 423530f712c9SDave Chinner * The returned value in "firstblock" from the first call in a transaction 423630f712c9SDave Chinner * must be remembered and presented to subsequent calls in "firstblock". 423730f712c9SDave Chinner * An upper bound for the number of blocks to be allocated is supplied to 423830f712c9SDave Chinner * the first call in "total"; if no allocation group has that many free 423930f712c9SDave Chinner * blocks then the call will fail (return NULLFSBLOCK in "firstblock"). 424030f712c9SDave Chinner */ 424130f712c9SDave Chinner int 424230f712c9SDave Chinner xfs_bmapi_write( 424330f712c9SDave Chinner struct xfs_trans *tp, /* transaction pointer */ 424430f712c9SDave Chinner struct xfs_inode *ip, /* incore inode */ 424530f712c9SDave Chinner xfs_fileoff_t bno, /* starting file offs. mapped */ 424630f712c9SDave Chinner xfs_filblks_t len, /* length to map in file */ 424730f712c9SDave Chinner int flags, /* XFS_BMAPI_... */ 424830f712c9SDave Chinner xfs_fsblock_t *firstblock, /* first allocated block 424930f712c9SDave Chinner controls a.g. for allocs */ 425030f712c9SDave Chinner xfs_extlen_t total, /* total blocks needed */ 425130f712c9SDave Chinner struct xfs_bmbt_irec *mval, /* output: map values */ 425230f712c9SDave Chinner int *nmap, /* i/o: mval size/count */ 42532c3234d1SDarrick J. Wong struct xfs_defer_ops *dfops) /* i/o: list extents to free */ 425430f712c9SDave Chinner { 425530f712c9SDave Chinner struct xfs_mount *mp = ip->i_mount; 425630f712c9SDave Chinner struct xfs_ifork *ifp; 425730f712c9SDave Chinner struct xfs_bmalloca bma = { NULL }; /* args for xfs_bmap_alloc */ 425830f712c9SDave Chinner xfs_fileoff_t end; /* end of mapped file region */ 42592d58f6efSChristoph Hellwig bool eof = false; /* after the end of extents */ 426030f712c9SDave Chinner int error; /* error return */ 426130f712c9SDave Chinner int n; /* current extent index */ 426230f712c9SDave Chinner xfs_fileoff_t obno; /* old block number (offset) */ 426330f712c9SDave Chinner int whichfork; /* data or attr fork */ 426430f712c9SDave Chinner 426530f712c9SDave Chinner #ifdef DEBUG 426630f712c9SDave Chinner xfs_fileoff_t orig_bno; /* original block number value */ 426730f712c9SDave Chinner int orig_flags; /* original flags arg value */ 426830f712c9SDave Chinner xfs_filblks_t orig_len; /* original value of len arg */ 426930f712c9SDave Chinner struct xfs_bmbt_irec *orig_mval; /* original value of mval */ 427030f712c9SDave Chinner int orig_nmap; /* original value of *nmap */ 427130f712c9SDave Chinner 427230f712c9SDave Chinner orig_bno = bno; 427330f712c9SDave Chinner orig_len = len; 427430f712c9SDave Chinner orig_flags = flags; 427530f712c9SDave Chinner orig_mval = mval; 427630f712c9SDave Chinner orig_nmap = *nmap; 427730f712c9SDave Chinner #endif 427860b4984fSDarrick J. Wong whichfork = xfs_bmapi_whichfork(flags); 427930f712c9SDave Chinner 428030f712c9SDave Chinner ASSERT(*nmap >= 1); 428130f712c9SDave Chinner ASSERT(*nmap <= XFS_BMAP_MAX_NMAP); 428230f712c9SDave Chinner ASSERT(!(flags & XFS_BMAPI_IGSTATE)); 428305a630d7SDarrick J. Wong ASSERT(tp != NULL || 428405a630d7SDarrick J. Wong (flags & (XFS_BMAPI_CONVERT | XFS_BMAPI_COWFORK)) == 428505a630d7SDarrick J. Wong (XFS_BMAPI_CONVERT | XFS_BMAPI_COWFORK)); 428630f712c9SDave Chinner ASSERT(len > 0); 428730f712c9SDave Chinner ASSERT(XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_LOCAL); 428830f712c9SDave Chinner ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL)); 42896ebd5a44SChristoph Hellwig ASSERT(!(flags & XFS_BMAPI_REMAP)); 429030f712c9SDave Chinner 42913fbbbea3SDave Chinner /* zeroing is for currently only for data extents, not metadata */ 42923fbbbea3SDave Chinner ASSERT((flags & (XFS_BMAPI_METADATA | XFS_BMAPI_ZERO)) != 42933fbbbea3SDave Chinner (XFS_BMAPI_METADATA | XFS_BMAPI_ZERO)); 42943fbbbea3SDave Chinner /* 42953fbbbea3SDave Chinner * we can allocate unwritten extents or pre-zero allocated blocks, 42963fbbbea3SDave Chinner * but it makes no sense to do both at once. This would result in 42973fbbbea3SDave Chinner * zeroing the unwritten extent twice, but it still being an 42983fbbbea3SDave Chinner * unwritten extent.... 42993fbbbea3SDave Chinner */ 43003fbbbea3SDave Chinner ASSERT((flags & (XFS_BMAPI_PREALLOC | XFS_BMAPI_ZERO)) != 43013fbbbea3SDave Chinner (XFS_BMAPI_PREALLOC | XFS_BMAPI_ZERO)); 43023fbbbea3SDave Chinner 430330f712c9SDave Chinner if (unlikely(XFS_TEST_ERROR( 430430f712c9SDave Chinner (XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS && 430530f712c9SDave Chinner XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE), 43069e24cfd0SDarrick J. Wong mp, XFS_ERRTAG_BMAPIFORMAT))) { 430730f712c9SDave Chinner XFS_ERROR_REPORT("xfs_bmapi_write", XFS_ERRLEVEL_LOW, mp); 43082451337dSDave Chinner return -EFSCORRUPTED; 430930f712c9SDave Chinner } 431030f712c9SDave Chinner 431130f712c9SDave Chinner if (XFS_FORCED_SHUTDOWN(mp)) 43122451337dSDave Chinner return -EIO; 431330f712c9SDave Chinner 431430f712c9SDave Chinner ifp = XFS_IFORK_PTR(ip, whichfork); 431530f712c9SDave Chinner 4316ff6d6af2SBill O'Donnell XFS_STATS_INC(mp, xs_blk_mapw); 431730f712c9SDave Chinner 431830f712c9SDave Chinner if (*firstblock == NULLFSBLOCK) { 431930f712c9SDave Chinner if (XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_BTREE) 432030f712c9SDave Chinner bma.minleft = be16_to_cpu(ifp->if_broot->bb_level) + 1; 432130f712c9SDave Chinner else 432230f712c9SDave Chinner bma.minleft = 1; 432330f712c9SDave Chinner } else { 432430f712c9SDave Chinner bma.minleft = 0; 432530f712c9SDave Chinner } 432630f712c9SDave Chinner 432730f712c9SDave Chinner if (!(ifp->if_flags & XFS_IFEXTENTS)) { 432830f712c9SDave Chinner error = xfs_iread_extents(tp, ip, whichfork); 432930f712c9SDave Chinner if (error) 433030f712c9SDave Chinner goto error0; 433130f712c9SDave Chinner } 433230f712c9SDave Chinner 433330f712c9SDave Chinner n = 0; 433430f712c9SDave Chinner end = bno + len; 433530f712c9SDave Chinner obno = bno; 433630f712c9SDave Chinner 4337b2b1712aSChristoph Hellwig if (!xfs_iext_lookup_extent(ip, ifp, bno, &bma.icur, &bma.got)) 43382d58f6efSChristoph Hellwig eof = true; 4339b2b1712aSChristoph Hellwig if (!xfs_iext_peek_prev_extent(ifp, &bma.icur, &bma.prev)) 43402d58f6efSChristoph Hellwig bma.prev.br_startoff = NULLFILEOFF; 434130f712c9SDave Chinner bma.tp = tp; 434230f712c9SDave Chinner bma.ip = ip; 434330f712c9SDave Chinner bma.total = total; 4344292378edSDave Chinner bma.datatype = 0; 43452c3234d1SDarrick J. Wong bma.dfops = dfops; 434630f712c9SDave Chinner bma.firstblock = firstblock; 434730f712c9SDave Chinner 434830f712c9SDave Chinner while (bno < end && n < *nmap) { 4349d2b3964aSChristoph Hellwig bool need_alloc = false, wasdelay = false; 435030f712c9SDave Chinner 4351be78ff0eSDarrick J. Wong /* in hole or beyond EOF? */ 4352d2b3964aSChristoph Hellwig if (eof || bma.got.br_startoff > bno) { 4353be78ff0eSDarrick J. Wong /* 4354be78ff0eSDarrick J. Wong * CoW fork conversions should /never/ hit EOF or 4355be78ff0eSDarrick J. Wong * holes. There should always be something for us 4356be78ff0eSDarrick J. Wong * to work on. 4357be78ff0eSDarrick J. Wong */ 4358be78ff0eSDarrick J. Wong ASSERT(!((flags & XFS_BMAPI_CONVERT) && 4359be78ff0eSDarrick J. Wong (flags & XFS_BMAPI_COWFORK))); 4360be78ff0eSDarrick J. Wong 4361d2b3964aSChristoph Hellwig if (flags & XFS_BMAPI_DELALLOC) { 4362d2b3964aSChristoph Hellwig /* 4363d2b3964aSChristoph Hellwig * For the COW fork we can reasonably get a 4364d2b3964aSChristoph Hellwig * request for converting an extent that races 4365d2b3964aSChristoph Hellwig * with other threads already having converted 4366d2b3964aSChristoph Hellwig * part of it, as there converting COW to 4367d2b3964aSChristoph Hellwig * regular blocks is not protected using the 4368d2b3964aSChristoph Hellwig * IOLOCK. 4369d2b3964aSChristoph Hellwig */ 4370d2b3964aSChristoph Hellwig ASSERT(flags & XFS_BMAPI_COWFORK); 4371d2b3964aSChristoph Hellwig if (!(flags & XFS_BMAPI_COWFORK)) { 4372d2b3964aSChristoph Hellwig error = -EIO; 4373d2b3964aSChristoph Hellwig goto error0; 4374d2b3964aSChristoph Hellwig } 4375d2b3964aSChristoph Hellwig 4376d2b3964aSChristoph Hellwig if (eof || bno >= end) 4377d2b3964aSChristoph Hellwig break; 4378d2b3964aSChristoph Hellwig } else { 4379d2b3964aSChristoph Hellwig need_alloc = true; 4380d2b3964aSChristoph Hellwig } 43816ebd5a44SChristoph Hellwig } else if (isnullstartblock(bma.got.br_startblock)) { 4382d2b3964aSChristoph Hellwig wasdelay = true; 4383d2b3964aSChristoph Hellwig } 4384f65306eaSDarrick J. Wong 4385f65306eaSDarrick J. Wong /* 438630f712c9SDave Chinner * First, deal with the hole before the allocated space 438730f712c9SDave Chinner * that we found, if any. 438830f712c9SDave Chinner */ 4389b121459cSChristoph Hellwig if ((need_alloc || wasdelay) && 4390b121459cSChristoph Hellwig !(flags & XFS_BMAPI_CONVERT_ONLY)) { 439130f712c9SDave Chinner bma.eof = eof; 439230f712c9SDave Chinner bma.conv = !!(flags & XFS_BMAPI_CONVERT); 439330f712c9SDave Chinner bma.wasdel = wasdelay; 439430f712c9SDave Chinner bma.offset = bno; 439530f712c9SDave Chinner bma.flags = flags; 439630f712c9SDave Chinner 439730f712c9SDave Chinner /* 439830f712c9SDave Chinner * There's a 32/64 bit type mismatch between the 439930f712c9SDave Chinner * allocation length request (which can be 64 bits in 440030f712c9SDave Chinner * length) and the bma length request, which is 440130f712c9SDave Chinner * xfs_extlen_t and therefore 32 bits. Hence we have to 440230f712c9SDave Chinner * check for 32-bit overflows and handle them here. 440330f712c9SDave Chinner */ 440430f712c9SDave Chinner if (len > (xfs_filblks_t)MAXEXTLEN) 440530f712c9SDave Chinner bma.length = MAXEXTLEN; 440630f712c9SDave Chinner else 440730f712c9SDave Chinner bma.length = len; 440830f712c9SDave Chinner 440930f712c9SDave Chinner ASSERT(len > 0); 441030f712c9SDave Chinner ASSERT(bma.length > 0); 441130f712c9SDave Chinner error = xfs_bmapi_allocate(&bma); 441230f712c9SDave Chinner if (error) 441330f712c9SDave Chinner goto error0; 441430f712c9SDave Chinner if (bma.blkno == NULLFSBLOCK) 441530f712c9SDave Chinner break; 4416174edb0eSDarrick J. Wong 4417174edb0eSDarrick J. Wong /* 4418174edb0eSDarrick J. Wong * If this is a CoW allocation, record the data in 4419174edb0eSDarrick J. Wong * the refcount btree for orphan recovery. 4420174edb0eSDarrick J. Wong */ 4421174edb0eSDarrick J. Wong if (whichfork == XFS_COW_FORK) { 4422174edb0eSDarrick J. Wong error = xfs_refcount_alloc_cow_extent(mp, dfops, 4423174edb0eSDarrick J. Wong bma.blkno, bma.length); 4424174edb0eSDarrick J. Wong if (error) 4425174edb0eSDarrick J. Wong goto error0; 4426174edb0eSDarrick J. Wong } 442730f712c9SDave Chinner } 442830f712c9SDave Chinner 442930f712c9SDave Chinner /* Deal with the allocated space we found. */ 443030f712c9SDave Chinner xfs_bmapi_trim_map(mval, &bma.got, &bno, len, obno, 443130f712c9SDave Chinner end, n, flags); 443230f712c9SDave Chinner 443330f712c9SDave Chinner /* Execute unwritten extent conversion if necessary */ 443430f712c9SDave Chinner error = xfs_bmapi_convert_unwritten(&bma, mval, len, flags); 44352451337dSDave Chinner if (error == -EAGAIN) 443630f712c9SDave Chinner continue; 443730f712c9SDave Chinner if (error) 443830f712c9SDave Chinner goto error0; 443930f712c9SDave Chinner 444030f712c9SDave Chinner /* update the extent map to return */ 444130f712c9SDave Chinner xfs_bmapi_update_map(&mval, &bno, &len, obno, end, &n, flags); 444230f712c9SDave Chinner 444330f712c9SDave Chinner /* 444430f712c9SDave Chinner * If we're done, stop now. Stop when we've allocated 444530f712c9SDave Chinner * XFS_BMAP_MAX_NMAP extents no matter what. Otherwise 444630f712c9SDave Chinner * the transaction may get too big. 444730f712c9SDave Chinner */ 444830f712c9SDave Chinner if (bno >= end || n >= *nmap || bma.nallocs >= *nmap) 444930f712c9SDave Chinner break; 445030f712c9SDave Chinner 445130f712c9SDave Chinner /* Else go on to the next record. */ 445230f712c9SDave Chinner bma.prev = bma.got; 4453b2b1712aSChristoph Hellwig if (!xfs_iext_next_extent(ifp, &bma.icur, &bma.got)) 44542d58f6efSChristoph Hellwig eof = true; 445530f712c9SDave Chinner } 445630f712c9SDave Chinner *nmap = n; 445730f712c9SDave Chinner 445830f712c9SDave Chinner /* 445930f712c9SDave Chinner * Transform from btree to extents, give it cur. 446030f712c9SDave Chinner */ 446130f712c9SDave Chinner if (xfs_bmap_wants_extents(ip, whichfork)) { 446230f712c9SDave Chinner int tmp_logflags = 0; 446330f712c9SDave Chinner 446430f712c9SDave Chinner ASSERT(bma.cur); 446530f712c9SDave Chinner error = xfs_bmap_btree_to_extents(tp, ip, bma.cur, 446630f712c9SDave Chinner &tmp_logflags, whichfork); 446730f712c9SDave Chinner bma.logflags |= tmp_logflags; 446830f712c9SDave Chinner if (error) 446930f712c9SDave Chinner goto error0; 447030f712c9SDave Chinner } 447130f712c9SDave Chinner 447230f712c9SDave Chinner ASSERT(XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE || 447330f712c9SDave Chinner XFS_IFORK_NEXTENTS(ip, whichfork) > 447430f712c9SDave Chinner XFS_IFORK_MAXEXT(ip, whichfork)); 447530f712c9SDave Chinner error = 0; 447630f712c9SDave Chinner error0: 447730f712c9SDave Chinner /* 447830f712c9SDave Chinner * Log everything. Do this after conversion, there's no point in 447930f712c9SDave Chinner * logging the extent records if we've converted to btree format. 448030f712c9SDave Chinner */ 448130f712c9SDave Chinner if ((bma.logflags & xfs_ilog_fext(whichfork)) && 448230f712c9SDave Chinner XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS) 448330f712c9SDave Chinner bma.logflags &= ~xfs_ilog_fext(whichfork); 448430f712c9SDave Chinner else if ((bma.logflags & xfs_ilog_fbroot(whichfork)) && 448530f712c9SDave Chinner XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE) 448630f712c9SDave Chinner bma.logflags &= ~xfs_ilog_fbroot(whichfork); 448730f712c9SDave Chinner /* 448830f712c9SDave Chinner * Log whatever the flags say, even if error. Otherwise we might miss 448930f712c9SDave Chinner * detecting a case where the data is changed, there's an error, 449030f712c9SDave Chinner * and it's not logged so we don't shutdown when we should. 449130f712c9SDave Chinner */ 449230f712c9SDave Chinner if (bma.logflags) 449330f712c9SDave Chinner xfs_trans_log_inode(tp, ip, bma.logflags); 449430f712c9SDave Chinner 449530f712c9SDave Chinner if (bma.cur) { 449630f712c9SDave Chinner if (!error) { 449730f712c9SDave Chinner ASSERT(*firstblock == NULLFSBLOCK || 4498410d17f6SChristoph Hellwig XFS_FSB_TO_AGNO(mp, *firstblock) <= 449930f712c9SDave Chinner XFS_FSB_TO_AGNO(mp, 4500410d17f6SChristoph Hellwig bma.cur->bc_private.b.firstblock)); 450130f712c9SDave Chinner *firstblock = bma.cur->bc_private.b.firstblock; 450230f712c9SDave Chinner } 450330f712c9SDave Chinner xfs_btree_del_cursor(bma.cur, 450430f712c9SDave Chinner error ? XFS_BTREE_ERROR : XFS_BTREE_NOERROR); 450530f712c9SDave Chinner } 450630f712c9SDave Chinner if (!error) 450730f712c9SDave Chinner xfs_bmap_validate_ret(orig_bno, orig_len, orig_flags, orig_mval, 450830f712c9SDave Chinner orig_nmap, *nmap); 450930f712c9SDave Chinner return error; 451030f712c9SDave Chinner } 451130f712c9SDave Chinner 45126ebd5a44SChristoph Hellwig static int 45136ebd5a44SChristoph Hellwig xfs_bmapi_remap( 45146ebd5a44SChristoph Hellwig struct xfs_trans *tp, 45156ebd5a44SChristoph Hellwig struct xfs_inode *ip, 45166ebd5a44SChristoph Hellwig xfs_fileoff_t bno, 45176ebd5a44SChristoph Hellwig xfs_filblks_t len, 45186ebd5a44SChristoph Hellwig xfs_fsblock_t startblock, 45196ebd5a44SChristoph Hellwig struct xfs_defer_ops *dfops) 45206ebd5a44SChristoph Hellwig { 45216ebd5a44SChristoph Hellwig struct xfs_mount *mp = ip->i_mount; 45226ebd5a44SChristoph Hellwig struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, XFS_DATA_FORK); 45236ebd5a44SChristoph Hellwig struct xfs_btree_cur *cur = NULL; 45246ebd5a44SChristoph Hellwig xfs_fsblock_t firstblock = NULLFSBLOCK; 45256ebd5a44SChristoph Hellwig struct xfs_bmbt_irec got; 4526b2b1712aSChristoph Hellwig struct xfs_iext_cursor icur; 45276ebd5a44SChristoph Hellwig int logflags = 0, error; 45286ebd5a44SChristoph Hellwig 45296ebd5a44SChristoph Hellwig ASSERT(len > 0); 45306ebd5a44SChristoph Hellwig ASSERT(len <= (xfs_filblks_t)MAXEXTLEN); 45316ebd5a44SChristoph Hellwig ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL)); 45326ebd5a44SChristoph Hellwig 45336ebd5a44SChristoph Hellwig if (unlikely(XFS_TEST_ERROR( 45346ebd5a44SChristoph Hellwig (XFS_IFORK_FORMAT(ip, XFS_DATA_FORK) != XFS_DINODE_FMT_EXTENTS && 45356ebd5a44SChristoph Hellwig XFS_IFORK_FORMAT(ip, XFS_DATA_FORK) != XFS_DINODE_FMT_BTREE), 45369e24cfd0SDarrick J. Wong mp, XFS_ERRTAG_BMAPIFORMAT))) { 45376ebd5a44SChristoph Hellwig XFS_ERROR_REPORT("xfs_bmapi_remap", XFS_ERRLEVEL_LOW, mp); 45386ebd5a44SChristoph Hellwig return -EFSCORRUPTED; 45396ebd5a44SChristoph Hellwig } 45406ebd5a44SChristoph Hellwig 45416ebd5a44SChristoph Hellwig if (XFS_FORCED_SHUTDOWN(mp)) 45426ebd5a44SChristoph Hellwig return -EIO; 45436ebd5a44SChristoph Hellwig 45446ebd5a44SChristoph Hellwig if (!(ifp->if_flags & XFS_IFEXTENTS)) { 45456ebd5a44SChristoph Hellwig error = xfs_iread_extents(NULL, ip, XFS_DATA_FORK); 45466ebd5a44SChristoph Hellwig if (error) 45476ebd5a44SChristoph Hellwig return error; 45486ebd5a44SChristoph Hellwig } 45496ebd5a44SChristoph Hellwig 4550b2b1712aSChristoph Hellwig if (xfs_iext_lookup_extent(ip, ifp, bno, &icur, &got)) { 45516ebd5a44SChristoph Hellwig /* make sure we only reflink into a hole. */ 45526ebd5a44SChristoph Hellwig ASSERT(got.br_startoff > bno); 45536ebd5a44SChristoph Hellwig ASSERT(got.br_startoff - bno >= len); 45546ebd5a44SChristoph Hellwig } 45556ebd5a44SChristoph Hellwig 4556bf8eadbaSChristoph Hellwig ip->i_d.di_nblocks += len; 4557bf8eadbaSChristoph Hellwig xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE); 45586ebd5a44SChristoph Hellwig 45596ebd5a44SChristoph Hellwig if (ifp->if_flags & XFS_IFBROOT) { 45606ebd5a44SChristoph Hellwig cur = xfs_bmbt_init_cursor(mp, tp, ip, XFS_DATA_FORK); 45616ebd5a44SChristoph Hellwig cur->bc_private.b.firstblock = firstblock; 45626ebd5a44SChristoph Hellwig cur->bc_private.b.dfops = dfops; 45636ebd5a44SChristoph Hellwig cur->bc_private.b.flags = 0; 45646ebd5a44SChristoph Hellwig } 45656ebd5a44SChristoph Hellwig 45666ebd5a44SChristoph Hellwig got.br_startoff = bno; 45676ebd5a44SChristoph Hellwig got.br_startblock = startblock; 45686ebd5a44SChristoph Hellwig got.br_blockcount = len; 45696ebd5a44SChristoph Hellwig got.br_state = XFS_EXT_NORM; 45706ebd5a44SChristoph Hellwig 4571b2b1712aSChristoph Hellwig error = xfs_bmap_add_extent_hole_real(tp, ip, XFS_DATA_FORK, &icur, 4572b2b1712aSChristoph Hellwig &cur, &got, &firstblock, dfops, &logflags); 45736ebd5a44SChristoph Hellwig if (error) 45746ebd5a44SChristoph Hellwig goto error0; 45756ebd5a44SChristoph Hellwig 45766ebd5a44SChristoph Hellwig if (xfs_bmap_wants_extents(ip, XFS_DATA_FORK)) { 45776ebd5a44SChristoph Hellwig int tmp_logflags = 0; 45786ebd5a44SChristoph Hellwig 45796ebd5a44SChristoph Hellwig error = xfs_bmap_btree_to_extents(tp, ip, cur, 45806ebd5a44SChristoph Hellwig &tmp_logflags, XFS_DATA_FORK); 45816ebd5a44SChristoph Hellwig logflags |= tmp_logflags; 45826ebd5a44SChristoph Hellwig } 45836ebd5a44SChristoph Hellwig 45846ebd5a44SChristoph Hellwig error0: 45856ebd5a44SChristoph Hellwig if (ip->i_d.di_format != XFS_DINODE_FMT_EXTENTS) 45866ebd5a44SChristoph Hellwig logflags &= ~XFS_ILOG_DEXT; 45876ebd5a44SChristoph Hellwig else if (ip->i_d.di_format != XFS_DINODE_FMT_BTREE) 45886ebd5a44SChristoph Hellwig logflags &= ~XFS_ILOG_DBROOT; 45896ebd5a44SChristoph Hellwig 45906ebd5a44SChristoph Hellwig if (logflags) 45916ebd5a44SChristoph Hellwig xfs_trans_log_inode(tp, ip, logflags); 45926ebd5a44SChristoph Hellwig if (cur) { 45936ebd5a44SChristoph Hellwig xfs_btree_del_cursor(cur, 45946ebd5a44SChristoph Hellwig error ? XFS_BTREE_ERROR : XFS_BTREE_NOERROR); 45956ebd5a44SChristoph Hellwig } 45966ebd5a44SChristoph Hellwig return error; 45976ebd5a44SChristoph Hellwig } 45986ebd5a44SChristoph Hellwig 459930f712c9SDave Chinner /* 4600a9bd24acSBrian Foster * When a delalloc extent is split (e.g., due to a hole punch), the original 4601a9bd24acSBrian Foster * indlen reservation must be shared across the two new extents that are left 4602a9bd24acSBrian Foster * behind. 4603a9bd24acSBrian Foster * 4604a9bd24acSBrian Foster * Given the original reservation and the worst case indlen for the two new 4605a9bd24acSBrian Foster * extents (as calculated by xfs_bmap_worst_indlen()), split the original 4606d34999c9SBrian Foster * reservation fairly across the two new extents. If necessary, steal available 4607d34999c9SBrian Foster * blocks from a deleted extent to make up a reservation deficiency (e.g., if 4608d34999c9SBrian Foster * ores == 1). The number of stolen blocks is returned. The availability and 4609d34999c9SBrian Foster * subsequent accounting of stolen blocks is the responsibility of the caller. 4610a9bd24acSBrian Foster */ 4611d34999c9SBrian Foster static xfs_filblks_t 4612a9bd24acSBrian Foster xfs_bmap_split_indlen( 4613a9bd24acSBrian Foster xfs_filblks_t ores, /* original res. */ 4614a9bd24acSBrian Foster xfs_filblks_t *indlen1, /* ext1 worst indlen */ 4615d34999c9SBrian Foster xfs_filblks_t *indlen2, /* ext2 worst indlen */ 4616d34999c9SBrian Foster xfs_filblks_t avail) /* stealable blocks */ 4617a9bd24acSBrian Foster { 4618a9bd24acSBrian Foster xfs_filblks_t len1 = *indlen1; 4619a9bd24acSBrian Foster xfs_filblks_t len2 = *indlen2; 4620a9bd24acSBrian Foster xfs_filblks_t nres = len1 + len2; /* new total res. */ 4621d34999c9SBrian Foster xfs_filblks_t stolen = 0; 462275d65361SBrian Foster xfs_filblks_t resfactor; 4623a9bd24acSBrian Foster 4624a9bd24acSBrian Foster /* 4625d34999c9SBrian Foster * Steal as many blocks as we can to try and satisfy the worst case 4626d34999c9SBrian Foster * indlen for both new extents. 4627d34999c9SBrian Foster */ 462875d65361SBrian Foster if (ores < nres && avail) 462975d65361SBrian Foster stolen = XFS_FILBLKS_MIN(nres - ores, avail); 463075d65361SBrian Foster ores += stolen; 463175d65361SBrian Foster 463275d65361SBrian Foster /* nothing else to do if we've satisfied the new reservation */ 463375d65361SBrian Foster if (ores >= nres) 463475d65361SBrian Foster return stolen; 4635d34999c9SBrian Foster 4636d34999c9SBrian Foster /* 463775d65361SBrian Foster * We can't meet the total required reservation for the two extents. 463875d65361SBrian Foster * Calculate the percent of the overall shortage between both extents 463975d65361SBrian Foster * and apply this percentage to each of the requested indlen values. 464075d65361SBrian Foster * This distributes the shortage fairly and reduces the chances that one 464175d65361SBrian Foster * of the two extents is left with nothing when extents are repeatedly 464275d65361SBrian Foster * split. 4643a9bd24acSBrian Foster */ 464475d65361SBrian Foster resfactor = (ores * 100); 464575d65361SBrian Foster do_div(resfactor, nres); 464675d65361SBrian Foster len1 *= resfactor; 464775d65361SBrian Foster do_div(len1, 100); 464875d65361SBrian Foster len2 *= resfactor; 464975d65361SBrian Foster do_div(len2, 100); 465075d65361SBrian Foster ASSERT(len1 + len2 <= ores); 465175d65361SBrian Foster ASSERT(len1 < *indlen1 && len2 < *indlen2); 465275d65361SBrian Foster 465375d65361SBrian Foster /* 465475d65361SBrian Foster * Hand out the remainder to each extent. If one of the two reservations 465575d65361SBrian Foster * is zero, we want to make sure that one gets a block first. The loop 465675d65361SBrian Foster * below starts with len1, so hand len2 a block right off the bat if it 465775d65361SBrian Foster * is zero. 465875d65361SBrian Foster */ 465975d65361SBrian Foster ores -= (len1 + len2); 466075d65361SBrian Foster ASSERT((*indlen1 - len1) + (*indlen2 - len2) >= ores); 466175d65361SBrian Foster if (ores && !len2 && *indlen2) { 466275d65361SBrian Foster len2++; 466375d65361SBrian Foster ores--; 4664a9bd24acSBrian Foster } 466575d65361SBrian Foster while (ores) { 466675d65361SBrian Foster if (len1 < *indlen1) { 466775d65361SBrian Foster len1++; 466875d65361SBrian Foster ores--; 466975d65361SBrian Foster } 467075d65361SBrian Foster if (!ores) 4671a9bd24acSBrian Foster break; 467275d65361SBrian Foster if (len2 < *indlen2) { 467375d65361SBrian Foster len2++; 467475d65361SBrian Foster ores--; 4675a9bd24acSBrian Foster } 4676a9bd24acSBrian Foster } 4677a9bd24acSBrian Foster 4678a9bd24acSBrian Foster *indlen1 = len1; 4679a9bd24acSBrian Foster *indlen2 = len2; 4680d34999c9SBrian Foster 4681d34999c9SBrian Foster return stolen; 4682a9bd24acSBrian Foster } 4683a9bd24acSBrian Foster 4684fa5c836cSChristoph Hellwig int 4685fa5c836cSChristoph Hellwig xfs_bmap_del_extent_delay( 4686fa5c836cSChristoph Hellwig struct xfs_inode *ip, 4687fa5c836cSChristoph Hellwig int whichfork, 4688b2b1712aSChristoph Hellwig struct xfs_iext_cursor *icur, 4689fa5c836cSChristoph Hellwig struct xfs_bmbt_irec *got, 4690fa5c836cSChristoph Hellwig struct xfs_bmbt_irec *del) 4691fa5c836cSChristoph Hellwig { 4692fa5c836cSChristoph Hellwig struct xfs_mount *mp = ip->i_mount; 4693fa5c836cSChristoph Hellwig struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, whichfork); 4694fa5c836cSChristoph Hellwig struct xfs_bmbt_irec new; 4695fa5c836cSChristoph Hellwig int64_t da_old, da_new, da_diff = 0; 4696fa5c836cSChristoph Hellwig xfs_fileoff_t del_endoff, got_endoff; 4697fa5c836cSChristoph Hellwig xfs_filblks_t got_indlen, new_indlen, stolen; 4698060ea65bSChristoph Hellwig int state = xfs_bmap_fork_to_state(whichfork); 4699060ea65bSChristoph Hellwig int error = 0; 4700fa5c836cSChristoph Hellwig bool isrt; 4701fa5c836cSChristoph Hellwig 4702fa5c836cSChristoph Hellwig XFS_STATS_INC(mp, xs_del_exlist); 4703fa5c836cSChristoph Hellwig 4704fa5c836cSChristoph Hellwig isrt = (whichfork == XFS_DATA_FORK) && XFS_IS_REALTIME_INODE(ip); 4705fa5c836cSChristoph Hellwig del_endoff = del->br_startoff + del->br_blockcount; 4706fa5c836cSChristoph Hellwig got_endoff = got->br_startoff + got->br_blockcount; 4707fa5c836cSChristoph Hellwig da_old = startblockval(got->br_startblock); 4708fa5c836cSChristoph Hellwig da_new = 0; 4709fa5c836cSChristoph Hellwig 4710fa5c836cSChristoph Hellwig ASSERT(del->br_blockcount > 0); 4711fa5c836cSChristoph Hellwig ASSERT(got->br_startoff <= del->br_startoff); 4712fa5c836cSChristoph Hellwig ASSERT(got_endoff >= del_endoff); 4713fa5c836cSChristoph Hellwig 4714fa5c836cSChristoph Hellwig if (isrt) { 47154f1adf33SEric Sandeen uint64_t rtexts = XFS_FSB_TO_B(mp, del->br_blockcount); 4716fa5c836cSChristoph Hellwig 4717fa5c836cSChristoph Hellwig do_div(rtexts, mp->m_sb.sb_rextsize); 4718fa5c836cSChristoph Hellwig xfs_mod_frextents(mp, rtexts); 4719fa5c836cSChristoph Hellwig } 4720fa5c836cSChristoph Hellwig 4721fa5c836cSChristoph Hellwig /* 4722fa5c836cSChristoph Hellwig * Update the inode delalloc counter now and wait to update the 4723fa5c836cSChristoph Hellwig * sb counters as we might have to borrow some blocks for the 4724fa5c836cSChristoph Hellwig * indirect block accounting. 4725fa5c836cSChristoph Hellwig */ 47264fd29ec4SDarrick J. Wong error = xfs_trans_reserve_quota_nblks(NULL, ip, 47274fd29ec4SDarrick J. Wong -((long)del->br_blockcount), 0, 4728fa5c836cSChristoph Hellwig isrt ? XFS_QMOPT_RES_RTBLKS : XFS_QMOPT_RES_REGBLKS); 47294fd29ec4SDarrick J. Wong if (error) 47304fd29ec4SDarrick J. Wong return error; 4731fa5c836cSChristoph Hellwig ip->i_delayed_blks -= del->br_blockcount; 4732fa5c836cSChristoph Hellwig 4733fa5c836cSChristoph Hellwig if (got->br_startoff == del->br_startoff) 47340173c689SChristoph Hellwig state |= BMAP_LEFT_FILLING; 4735fa5c836cSChristoph Hellwig if (got_endoff == del_endoff) 47360173c689SChristoph Hellwig state |= BMAP_RIGHT_FILLING; 4737fa5c836cSChristoph Hellwig 47380173c689SChristoph Hellwig switch (state & (BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING)) { 47390173c689SChristoph Hellwig case BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING: 4740fa5c836cSChristoph Hellwig /* 4741fa5c836cSChristoph Hellwig * Matches the whole extent. Delete the entry. 4742fa5c836cSChristoph Hellwig */ 4743c38ccf59SChristoph Hellwig xfs_iext_remove(ip, icur, state); 4744b2b1712aSChristoph Hellwig xfs_iext_prev(ifp, icur); 4745fa5c836cSChristoph Hellwig break; 47460173c689SChristoph Hellwig case BMAP_LEFT_FILLING: 4747fa5c836cSChristoph Hellwig /* 4748fa5c836cSChristoph Hellwig * Deleting the first part of the extent. 4749fa5c836cSChristoph Hellwig */ 4750fa5c836cSChristoph Hellwig got->br_startoff = del_endoff; 4751fa5c836cSChristoph Hellwig got->br_blockcount -= del->br_blockcount; 4752fa5c836cSChristoph Hellwig da_new = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(ip, 4753fa5c836cSChristoph Hellwig got->br_blockcount), da_old); 4754fa5c836cSChristoph Hellwig got->br_startblock = nullstartblock((int)da_new); 4755b2b1712aSChristoph Hellwig xfs_iext_update_extent(ip, state, icur, got); 4756fa5c836cSChristoph Hellwig break; 47570173c689SChristoph Hellwig case BMAP_RIGHT_FILLING: 4758fa5c836cSChristoph Hellwig /* 4759fa5c836cSChristoph Hellwig * Deleting the last part of the extent. 4760fa5c836cSChristoph Hellwig */ 4761fa5c836cSChristoph Hellwig got->br_blockcount = got->br_blockcount - del->br_blockcount; 4762fa5c836cSChristoph Hellwig da_new = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(ip, 4763fa5c836cSChristoph Hellwig got->br_blockcount), da_old); 4764fa5c836cSChristoph Hellwig got->br_startblock = nullstartblock((int)da_new); 4765b2b1712aSChristoph Hellwig xfs_iext_update_extent(ip, state, icur, got); 4766fa5c836cSChristoph Hellwig break; 4767fa5c836cSChristoph Hellwig case 0: 4768fa5c836cSChristoph Hellwig /* 4769fa5c836cSChristoph Hellwig * Deleting the middle of the extent. 4770fa5c836cSChristoph Hellwig * 4771fa5c836cSChristoph Hellwig * Distribute the original indlen reservation across the two new 4772fa5c836cSChristoph Hellwig * extents. Steal blocks from the deleted extent if necessary. 4773fa5c836cSChristoph Hellwig * Stealing blocks simply fudges the fdblocks accounting below. 4774fa5c836cSChristoph Hellwig * Warn if either of the new indlen reservations is zero as this 4775fa5c836cSChristoph Hellwig * can lead to delalloc problems. 4776fa5c836cSChristoph Hellwig */ 4777fa5c836cSChristoph Hellwig got->br_blockcount = del->br_startoff - got->br_startoff; 4778fa5c836cSChristoph Hellwig got_indlen = xfs_bmap_worst_indlen(ip, got->br_blockcount); 4779fa5c836cSChristoph Hellwig 4780fa5c836cSChristoph Hellwig new.br_blockcount = got_endoff - del_endoff; 4781fa5c836cSChristoph Hellwig new_indlen = xfs_bmap_worst_indlen(ip, new.br_blockcount); 4782fa5c836cSChristoph Hellwig 4783fa5c836cSChristoph Hellwig WARN_ON_ONCE(!got_indlen || !new_indlen); 4784fa5c836cSChristoph Hellwig stolen = xfs_bmap_split_indlen(da_old, &got_indlen, &new_indlen, 4785fa5c836cSChristoph Hellwig del->br_blockcount); 4786fa5c836cSChristoph Hellwig 4787fa5c836cSChristoph Hellwig got->br_startblock = nullstartblock((int)got_indlen); 4788fa5c836cSChristoph Hellwig 4789fa5c836cSChristoph Hellwig new.br_startoff = del_endoff; 4790fa5c836cSChristoph Hellwig new.br_state = got->br_state; 4791fa5c836cSChristoph Hellwig new.br_startblock = nullstartblock((int)new_indlen); 4792fa5c836cSChristoph Hellwig 4793b2b1712aSChristoph Hellwig xfs_iext_update_extent(ip, state, icur, got); 4794b2b1712aSChristoph Hellwig xfs_iext_next(ifp, icur); 47950254c2f2SChristoph Hellwig xfs_iext_insert(ip, icur, &new, state); 4796fa5c836cSChristoph Hellwig 4797fa5c836cSChristoph Hellwig da_new = got_indlen + new_indlen - stolen; 4798fa5c836cSChristoph Hellwig del->br_blockcount -= stolen; 4799fa5c836cSChristoph Hellwig break; 4800fa5c836cSChristoph Hellwig } 4801fa5c836cSChristoph Hellwig 4802fa5c836cSChristoph Hellwig ASSERT(da_old >= da_new); 4803fa5c836cSChristoph Hellwig da_diff = da_old - da_new; 4804fa5c836cSChristoph Hellwig if (!isrt) 4805fa5c836cSChristoph Hellwig da_diff += del->br_blockcount; 4806fa5c836cSChristoph Hellwig if (da_diff) 4807fa5c836cSChristoph Hellwig xfs_mod_fdblocks(mp, da_diff, false); 4808fa5c836cSChristoph Hellwig return error; 4809fa5c836cSChristoph Hellwig } 4810fa5c836cSChristoph Hellwig 4811fa5c836cSChristoph Hellwig void 4812fa5c836cSChristoph Hellwig xfs_bmap_del_extent_cow( 4813fa5c836cSChristoph Hellwig struct xfs_inode *ip, 4814b2b1712aSChristoph Hellwig struct xfs_iext_cursor *icur, 4815fa5c836cSChristoph Hellwig struct xfs_bmbt_irec *got, 4816fa5c836cSChristoph Hellwig struct xfs_bmbt_irec *del) 4817fa5c836cSChristoph Hellwig { 4818fa5c836cSChristoph Hellwig struct xfs_mount *mp = ip->i_mount; 4819fa5c836cSChristoph Hellwig struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, XFS_COW_FORK); 4820fa5c836cSChristoph Hellwig struct xfs_bmbt_irec new; 4821fa5c836cSChristoph Hellwig xfs_fileoff_t del_endoff, got_endoff; 4822fa5c836cSChristoph Hellwig int state = BMAP_COWFORK; 4823fa5c836cSChristoph Hellwig 4824fa5c836cSChristoph Hellwig XFS_STATS_INC(mp, xs_del_exlist); 4825fa5c836cSChristoph Hellwig 4826fa5c836cSChristoph Hellwig del_endoff = del->br_startoff + del->br_blockcount; 4827fa5c836cSChristoph Hellwig got_endoff = got->br_startoff + got->br_blockcount; 4828fa5c836cSChristoph Hellwig 4829fa5c836cSChristoph Hellwig ASSERT(del->br_blockcount > 0); 4830fa5c836cSChristoph Hellwig ASSERT(got->br_startoff <= del->br_startoff); 4831fa5c836cSChristoph Hellwig ASSERT(got_endoff >= del_endoff); 4832fa5c836cSChristoph Hellwig ASSERT(!isnullstartblock(got->br_startblock)); 4833fa5c836cSChristoph Hellwig 4834fa5c836cSChristoph Hellwig if (got->br_startoff == del->br_startoff) 48350173c689SChristoph Hellwig state |= BMAP_LEFT_FILLING; 4836fa5c836cSChristoph Hellwig if (got_endoff == del_endoff) 48370173c689SChristoph Hellwig state |= BMAP_RIGHT_FILLING; 4838fa5c836cSChristoph Hellwig 48390173c689SChristoph Hellwig switch (state & (BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING)) { 48400173c689SChristoph Hellwig case BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING: 4841fa5c836cSChristoph Hellwig /* 4842fa5c836cSChristoph Hellwig * Matches the whole extent. Delete the entry. 4843fa5c836cSChristoph Hellwig */ 4844c38ccf59SChristoph Hellwig xfs_iext_remove(ip, icur, state); 4845b2b1712aSChristoph Hellwig xfs_iext_prev(ifp, icur); 4846fa5c836cSChristoph Hellwig break; 48470173c689SChristoph Hellwig case BMAP_LEFT_FILLING: 4848fa5c836cSChristoph Hellwig /* 4849fa5c836cSChristoph Hellwig * Deleting the first part of the extent. 4850fa5c836cSChristoph Hellwig */ 4851fa5c836cSChristoph Hellwig got->br_startoff = del_endoff; 4852fa5c836cSChristoph Hellwig got->br_blockcount -= del->br_blockcount; 4853fa5c836cSChristoph Hellwig got->br_startblock = del->br_startblock + del->br_blockcount; 4854b2b1712aSChristoph Hellwig xfs_iext_update_extent(ip, state, icur, got); 4855fa5c836cSChristoph Hellwig break; 48560173c689SChristoph Hellwig case BMAP_RIGHT_FILLING: 4857fa5c836cSChristoph Hellwig /* 4858fa5c836cSChristoph Hellwig * Deleting the last part of the extent. 4859fa5c836cSChristoph Hellwig */ 4860fa5c836cSChristoph Hellwig got->br_blockcount -= del->br_blockcount; 4861b2b1712aSChristoph Hellwig xfs_iext_update_extent(ip, state, icur, got); 4862fa5c836cSChristoph Hellwig break; 4863fa5c836cSChristoph Hellwig case 0: 4864fa5c836cSChristoph Hellwig /* 4865fa5c836cSChristoph Hellwig * Deleting the middle of the extent. 4866fa5c836cSChristoph Hellwig */ 4867fa5c836cSChristoph Hellwig got->br_blockcount = del->br_startoff - got->br_startoff; 4868fa5c836cSChristoph Hellwig 4869fa5c836cSChristoph Hellwig new.br_startoff = del_endoff; 4870fa5c836cSChristoph Hellwig new.br_blockcount = got_endoff - del_endoff; 4871fa5c836cSChristoph Hellwig new.br_state = got->br_state; 4872fa5c836cSChristoph Hellwig new.br_startblock = del->br_startblock + del->br_blockcount; 4873fa5c836cSChristoph Hellwig 4874b2b1712aSChristoph Hellwig xfs_iext_update_extent(ip, state, icur, got); 4875b2b1712aSChristoph Hellwig xfs_iext_next(ifp, icur); 48760254c2f2SChristoph Hellwig xfs_iext_insert(ip, icur, &new, state); 4877fa5c836cSChristoph Hellwig break; 4878fa5c836cSChristoph Hellwig } 48794b4c1326SDarrick J. Wong ip->i_delayed_blks -= del->br_blockcount; 4880fa5c836cSChristoph Hellwig } 4881fa5c836cSChristoph Hellwig 4882a9bd24acSBrian Foster /* 488330f712c9SDave Chinner * Called by xfs_bmapi to update file extent records and the btree 4884e1d7553fSChristoph Hellwig * after removing space. 488530f712c9SDave Chinner */ 488630f712c9SDave Chinner STATIC int /* error */ 4887e1d7553fSChristoph Hellwig xfs_bmap_del_extent_real( 488830f712c9SDave Chinner xfs_inode_t *ip, /* incore inode pointer */ 488930f712c9SDave Chinner xfs_trans_t *tp, /* current transaction pointer */ 4890b2b1712aSChristoph Hellwig struct xfs_iext_cursor *icur, 48912c3234d1SDarrick J. Wong struct xfs_defer_ops *dfops, /* list of extents to be freed */ 489230f712c9SDave Chinner xfs_btree_cur_t *cur, /* if null, not a btree */ 489330f712c9SDave Chinner xfs_bmbt_irec_t *del, /* data to remove from extents */ 489430f712c9SDave Chinner int *logflagsp, /* inode logging flags */ 48954847acf8SDarrick J. Wong int whichfork, /* data or attr fork */ 48964847acf8SDarrick J. Wong int bflags) /* bmapi flags */ 489730f712c9SDave Chinner { 489830f712c9SDave Chinner xfs_fsblock_t del_endblock=0; /* first block past del */ 489930f712c9SDave Chinner xfs_fileoff_t del_endoff; /* first offset past del */ 490030f712c9SDave Chinner int do_fx; /* free extent at end of routine */ 490130f712c9SDave Chinner int error; /* error return value */ 49021b24b633SChristoph Hellwig int flags = 0;/* inode logging flags */ 490348fd52b1SChristoph Hellwig struct xfs_bmbt_irec got; /* current extent entry */ 490430f712c9SDave Chinner xfs_fileoff_t got_endoff; /* first offset past got */ 490530f712c9SDave Chinner int i; /* temp state */ 490630f712c9SDave Chinner xfs_ifork_t *ifp; /* inode fork pointer */ 490730f712c9SDave Chinner xfs_mount_t *mp; /* mount structure */ 490830f712c9SDave Chinner xfs_filblks_t nblks; /* quota/sb block count */ 490930f712c9SDave Chinner xfs_bmbt_irec_t new; /* new record to be inserted */ 491030f712c9SDave Chinner /* REFERENCED */ 491130f712c9SDave Chinner uint qfield; /* quota field to update */ 4912060ea65bSChristoph Hellwig int state = xfs_bmap_fork_to_state(whichfork); 491348fd52b1SChristoph Hellwig struct xfs_bmbt_irec old; 491430f712c9SDave Chinner 4915ff6d6af2SBill O'Donnell mp = ip->i_mount; 4916ff6d6af2SBill O'Donnell XFS_STATS_INC(mp, xs_del_exlist); 491730f712c9SDave Chinner 491830f712c9SDave Chinner ifp = XFS_IFORK_PTR(ip, whichfork); 491930f712c9SDave Chinner ASSERT(del->br_blockcount > 0); 4920b2b1712aSChristoph Hellwig xfs_iext_get_extent(ifp, icur, &got); 492130f712c9SDave Chinner ASSERT(got.br_startoff <= del->br_startoff); 492230f712c9SDave Chinner del_endoff = del->br_startoff + del->br_blockcount; 492330f712c9SDave Chinner got_endoff = got.br_startoff + got.br_blockcount; 492430f712c9SDave Chinner ASSERT(got_endoff >= del_endoff); 4925e1d7553fSChristoph Hellwig ASSERT(!isnullstartblock(got.br_startblock)); 492630f712c9SDave Chinner qfield = 0; 492730f712c9SDave Chinner error = 0; 4928e1d7553fSChristoph Hellwig 49291b24b633SChristoph Hellwig /* 49301b24b633SChristoph Hellwig * If it's the case where the directory code is running with no block 49311b24b633SChristoph Hellwig * reservation, and the deleted block is in the middle of its extent, 49321b24b633SChristoph Hellwig * and the resulting insert of an extent would cause transformation to 49331b24b633SChristoph Hellwig * btree format, then reject it. The calling code will then swap blocks 49341b24b633SChristoph Hellwig * around instead. We have to do this now, rather than waiting for the 49351b24b633SChristoph Hellwig * conversion to btree format, since the transaction will be dirty then. 49361b24b633SChristoph Hellwig */ 49371b24b633SChristoph Hellwig if (tp->t_blk_res == 0 && 49381b24b633SChristoph Hellwig XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_EXTENTS && 49391b24b633SChristoph Hellwig XFS_IFORK_NEXTENTS(ip, whichfork) >= 49401b24b633SChristoph Hellwig XFS_IFORK_MAXEXT(ip, whichfork) && 49411b24b633SChristoph Hellwig del->br_startoff > got.br_startoff && del_endoff < got_endoff) 49421b24b633SChristoph Hellwig return -ENOSPC; 49431b24b633SChristoph Hellwig 49441b24b633SChristoph Hellwig flags = XFS_ILOG_CORE; 494530f712c9SDave Chinner if (whichfork == XFS_DATA_FORK && XFS_IS_REALTIME_INODE(ip)) { 494630f712c9SDave Chinner xfs_fsblock_t bno; 494730f712c9SDave Chinner xfs_filblks_t len; 494830f712c9SDave Chinner 4949e1d7553fSChristoph Hellwig ASSERT(do_mod(del->br_blockcount, mp->m_sb.sb_rextsize) == 0); 4950e1d7553fSChristoph Hellwig ASSERT(do_mod(del->br_startblock, mp->m_sb.sb_rextsize) == 0); 495130f712c9SDave Chinner bno = del->br_startblock; 495230f712c9SDave Chinner len = del->br_blockcount; 495330f712c9SDave Chinner do_div(bno, mp->m_sb.sb_rextsize); 495430f712c9SDave Chinner do_div(len, mp->m_sb.sb_rextsize); 495530f712c9SDave Chinner error = xfs_rtfree_extent(tp, bno, (xfs_extlen_t)len); 495630f712c9SDave Chinner if (error) 495730f712c9SDave Chinner goto done; 495830f712c9SDave Chinner do_fx = 0; 495930f712c9SDave Chinner nblks = len * mp->m_sb.sb_rextsize; 496030f712c9SDave Chinner qfield = XFS_TRANS_DQ_RTBCOUNT; 4961e1d7553fSChristoph Hellwig } else { 496230f712c9SDave Chinner do_fx = 1; 496330f712c9SDave Chinner nblks = del->br_blockcount; 496430f712c9SDave Chinner qfield = XFS_TRANS_DQ_BCOUNT; 496530f712c9SDave Chinner } 4966e1d7553fSChristoph Hellwig 496730f712c9SDave Chinner del_endblock = del->br_startblock + del->br_blockcount; 496830f712c9SDave Chinner if (cur) { 4969e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(cur, &got, &i); 4970e1d7553fSChristoph Hellwig if (error) 497130f712c9SDave Chinner goto done; 4972c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 497330f712c9SDave Chinner } 4974340785ccSDarrick J. Wong 4975491f6f8aSChristoph Hellwig if (got.br_startoff == del->br_startoff) 4976491f6f8aSChristoph Hellwig state |= BMAP_LEFT_FILLING; 4977491f6f8aSChristoph Hellwig if (got_endoff == del_endoff) 4978491f6f8aSChristoph Hellwig state |= BMAP_RIGHT_FILLING; 4979491f6f8aSChristoph Hellwig 4980491f6f8aSChristoph Hellwig switch (state & (BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING)) { 4981491f6f8aSChristoph Hellwig case BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING: 498230f712c9SDave Chinner /* 498330f712c9SDave Chinner * Matches the whole extent. Delete the entry. 498430f712c9SDave Chinner */ 4985c38ccf59SChristoph Hellwig xfs_iext_remove(ip, icur, state); 4986b2b1712aSChristoph Hellwig xfs_iext_prev(ifp, icur); 498730f712c9SDave Chinner XFS_IFORK_NEXT_SET(ip, whichfork, 498830f712c9SDave Chinner XFS_IFORK_NEXTENTS(ip, whichfork) - 1); 498930f712c9SDave Chinner flags |= XFS_ILOG_CORE; 499030f712c9SDave Chinner if (!cur) { 499130f712c9SDave Chinner flags |= xfs_ilog_fext(whichfork); 499230f712c9SDave Chinner break; 499330f712c9SDave Chinner } 499430f712c9SDave Chinner if ((error = xfs_btree_delete(cur, &i))) 499530f712c9SDave Chinner goto done; 4996c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 499730f712c9SDave Chinner break; 4998491f6f8aSChristoph Hellwig case BMAP_LEFT_FILLING: 499930f712c9SDave Chinner /* 500030f712c9SDave Chinner * Deleting the first part of the extent. 500130f712c9SDave Chinner */ 500248fd52b1SChristoph Hellwig got.br_startoff = del_endoff; 500348fd52b1SChristoph Hellwig got.br_startblock = del_endblock; 500448fd52b1SChristoph Hellwig got.br_blockcount -= del->br_blockcount; 5005b2b1712aSChristoph Hellwig xfs_iext_update_extent(ip, state, icur, &got); 500630f712c9SDave Chinner if (!cur) { 500730f712c9SDave Chinner flags |= xfs_ilog_fext(whichfork); 500830f712c9SDave Chinner break; 500930f712c9SDave Chinner } 5010a67d00a5SChristoph Hellwig error = xfs_bmbt_update(cur, &got); 501148fd52b1SChristoph Hellwig if (error) 501230f712c9SDave Chinner goto done; 501330f712c9SDave Chinner break; 5014491f6f8aSChristoph Hellwig case BMAP_RIGHT_FILLING: 501530f712c9SDave Chinner /* 501630f712c9SDave Chinner * Deleting the last part of the extent. 501730f712c9SDave Chinner */ 501848fd52b1SChristoph Hellwig got.br_blockcount -= del->br_blockcount; 5019b2b1712aSChristoph Hellwig xfs_iext_update_extent(ip, state, icur, &got); 502030f712c9SDave Chinner if (!cur) { 502130f712c9SDave Chinner flags |= xfs_ilog_fext(whichfork); 502230f712c9SDave Chinner break; 502330f712c9SDave Chinner } 5024a67d00a5SChristoph Hellwig error = xfs_bmbt_update(cur, &got); 502548fd52b1SChristoph Hellwig if (error) 502630f712c9SDave Chinner goto done; 502730f712c9SDave Chinner break; 502830f712c9SDave Chinner case 0: 502930f712c9SDave Chinner /* 503030f712c9SDave Chinner * Deleting the middle of the extent. 503130f712c9SDave Chinner */ 503248fd52b1SChristoph Hellwig old = got; 5033ca5d8e5bSChristoph Hellwig 503448fd52b1SChristoph Hellwig got.br_blockcount = del->br_startoff - got.br_startoff; 5035b2b1712aSChristoph Hellwig xfs_iext_update_extent(ip, state, icur, &got); 503648fd52b1SChristoph Hellwig 503730f712c9SDave Chinner new.br_startoff = del_endoff; 503848fd52b1SChristoph Hellwig new.br_blockcount = got_endoff - del_endoff; 503930f712c9SDave Chinner new.br_state = got.br_state; 504030f712c9SDave Chinner new.br_startblock = del_endblock; 504148fd52b1SChristoph Hellwig 504230f712c9SDave Chinner flags |= XFS_ILOG_CORE; 504330f712c9SDave Chinner if (cur) { 5044a67d00a5SChristoph Hellwig error = xfs_bmbt_update(cur, &got); 5045e1d7553fSChristoph Hellwig if (error) 504630f712c9SDave Chinner goto done; 5047e1d7553fSChristoph Hellwig error = xfs_btree_increment(cur, 0, &i); 5048e1d7553fSChristoph Hellwig if (error) 504930f712c9SDave Chinner goto done; 505030f712c9SDave Chinner cur->bc_rec.b = new; 505130f712c9SDave Chinner error = xfs_btree_insert(cur, &i); 50522451337dSDave Chinner if (error && error != -ENOSPC) 505330f712c9SDave Chinner goto done; 505430f712c9SDave Chinner /* 5055e1d7553fSChristoph Hellwig * If get no-space back from btree insert, it tried a 5056e1d7553fSChristoph Hellwig * split, and we have a zero block reservation. Fix up 5057e1d7553fSChristoph Hellwig * our state and return the error. 505830f712c9SDave Chinner */ 50592451337dSDave Chinner if (error == -ENOSPC) { 506030f712c9SDave Chinner /* 5061e1d7553fSChristoph Hellwig * Reset the cursor, don't trust it after any 5062e1d7553fSChristoph Hellwig * insert operation. 506330f712c9SDave Chinner */ 5064e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(cur, &got, &i); 5065e1d7553fSChristoph Hellwig if (error) 506630f712c9SDave Chinner goto done; 5067e1d7553fSChristoph Hellwig XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 506830f712c9SDave Chinner /* 506930f712c9SDave Chinner * Update the btree record back 507030f712c9SDave Chinner * to the original value. 507130f712c9SDave Chinner */ 5072a67d00a5SChristoph Hellwig error = xfs_bmbt_update(cur, &old); 5073e1d7553fSChristoph Hellwig if (error) 507430f712c9SDave Chinner goto done; 507530f712c9SDave Chinner /* 507630f712c9SDave Chinner * Reset the extent record back 507730f712c9SDave Chinner * to the original value. 507830f712c9SDave Chinner */ 5079b2b1712aSChristoph Hellwig xfs_iext_update_extent(ip, state, icur, &old); 508030f712c9SDave Chinner flags = 0; 50812451337dSDave Chinner error = -ENOSPC; 508230f712c9SDave Chinner goto done; 508330f712c9SDave Chinner } 5084c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 508530f712c9SDave Chinner } else 508630f712c9SDave Chinner flags |= xfs_ilog_fext(whichfork); 508730f712c9SDave Chinner XFS_IFORK_NEXT_SET(ip, whichfork, 508830f712c9SDave Chinner XFS_IFORK_NEXTENTS(ip, whichfork) + 1); 5089b2b1712aSChristoph Hellwig xfs_iext_next(ifp, icur); 50900254c2f2SChristoph Hellwig xfs_iext_insert(ip, icur, &new, state); 509130f712c9SDave Chinner break; 509230f712c9SDave Chinner } 50939c194644SDarrick J. Wong 50949c194644SDarrick J. Wong /* remove reverse mapping */ 50959c194644SDarrick J. Wong error = xfs_rmap_unmap_extent(mp, dfops, ip, whichfork, del); 50969c194644SDarrick J. Wong if (error) 50979c194644SDarrick J. Wong goto done; 50989c194644SDarrick J. Wong 509930f712c9SDave Chinner /* 510030f712c9SDave Chinner * If we need to, add to list of extents to delete. 510130f712c9SDave Chinner */ 51024847acf8SDarrick J. Wong if (do_fx && !(bflags & XFS_BMAPI_REMAP)) { 510362aab20fSDarrick J. Wong if (xfs_is_reflink_inode(ip) && whichfork == XFS_DATA_FORK) { 510462aab20fSDarrick J. Wong error = xfs_refcount_decrease_extent(mp, dfops, del); 510562aab20fSDarrick J. Wong if (error) 510662aab20fSDarrick J. Wong goto done; 510762aab20fSDarrick J. Wong } else 51082c3234d1SDarrick J. Wong xfs_bmap_add_free(mp, dfops, del->br_startblock, 5109340785ccSDarrick J. Wong del->br_blockcount, NULL); 511062aab20fSDarrick J. Wong } 511162aab20fSDarrick J. Wong 511230f712c9SDave Chinner /* 511330f712c9SDave Chinner * Adjust inode # blocks in the file. 511430f712c9SDave Chinner */ 511530f712c9SDave Chinner if (nblks) 511630f712c9SDave Chinner ip->i_d.di_nblocks -= nblks; 511730f712c9SDave Chinner /* 511830f712c9SDave Chinner * Adjust quota data. 511930f712c9SDave Chinner */ 51204847acf8SDarrick J. Wong if (qfield && !(bflags & XFS_BMAPI_REMAP)) 512130f712c9SDave Chinner xfs_trans_mod_dquot_byino(tp, ip, qfield, (long)-nblks); 512230f712c9SDave Chinner 512330f712c9SDave Chinner done: 512430f712c9SDave Chinner *logflagsp = flags; 512530f712c9SDave Chinner return error; 512630f712c9SDave Chinner } 512730f712c9SDave Chinner 512830f712c9SDave Chinner /* 512930f712c9SDave Chinner * Unmap (remove) blocks from a file. 513030f712c9SDave Chinner * If nexts is nonzero then the number of extents to remove is limited to 513130f712c9SDave Chinner * that value. If not all extents in the block range can be removed then 513230f712c9SDave Chinner * *done is set. 513330f712c9SDave Chinner */ 513430f712c9SDave Chinner int /* error */ 51354453593bSDarrick J. Wong __xfs_bunmapi( 513630f712c9SDave Chinner xfs_trans_t *tp, /* transaction pointer */ 513730f712c9SDave Chinner struct xfs_inode *ip, /* incore inode */ 51388280f6edSChristoph Hellwig xfs_fileoff_t start, /* first file offset deleted */ 51394453593bSDarrick J. Wong xfs_filblks_t *rlen, /* i/o: amount remaining */ 514030f712c9SDave Chinner int flags, /* misc flags */ 514130f712c9SDave Chinner xfs_extnum_t nexts, /* number of extents max */ 514230f712c9SDave Chinner xfs_fsblock_t *firstblock, /* first allocated block 514330f712c9SDave Chinner controls a.g. for allocs */ 51444453593bSDarrick J. Wong struct xfs_defer_ops *dfops) /* i/o: deferred updates */ 514530f712c9SDave Chinner { 514630f712c9SDave Chinner xfs_btree_cur_t *cur; /* bmap btree cursor */ 514730f712c9SDave Chinner xfs_bmbt_irec_t del; /* extent being deleted */ 514830f712c9SDave Chinner int error; /* error return value */ 514930f712c9SDave Chinner xfs_extnum_t extno; /* extent number in list */ 515030f712c9SDave Chinner xfs_bmbt_irec_t got; /* current extent record */ 515130f712c9SDave Chinner xfs_ifork_t *ifp; /* inode fork pointer */ 515230f712c9SDave Chinner int isrt; /* freeing in rt area */ 515330f712c9SDave Chinner int logflags; /* transaction logging flags */ 515430f712c9SDave Chinner xfs_extlen_t mod; /* rt extent offset */ 515530f712c9SDave Chinner xfs_mount_t *mp; /* mount structure */ 515630f712c9SDave Chinner int tmp_logflags; /* partial logging flags */ 515730f712c9SDave Chinner int wasdel; /* was a delayed alloc extent */ 515830f712c9SDave Chinner int whichfork; /* data or attribute fork */ 515930f712c9SDave Chinner xfs_fsblock_t sum; 51604453593bSDarrick J. Wong xfs_filblks_t len = *rlen; /* length to unmap in file */ 5161e1a4e37cSDarrick J. Wong xfs_fileoff_t max_len; 51625b094d6dSChristoph Hellwig xfs_agnumber_t prev_agno = NULLAGNUMBER, agno; 51638280f6edSChristoph Hellwig xfs_fileoff_t end; 5164b2b1712aSChristoph Hellwig struct xfs_iext_cursor icur; 5165b2b1712aSChristoph Hellwig bool done = false; 516630f712c9SDave Chinner 51678280f6edSChristoph Hellwig trace_xfs_bunmap(ip, start, len, flags, _RET_IP_); 516830f712c9SDave Chinner 51693993baebSDarrick J. Wong whichfork = xfs_bmapi_whichfork(flags); 51703993baebSDarrick J. Wong ASSERT(whichfork != XFS_COW_FORK); 517130f712c9SDave Chinner ifp = XFS_IFORK_PTR(ip, whichfork); 517230f712c9SDave Chinner if (unlikely( 517330f712c9SDave Chinner XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS && 517430f712c9SDave Chinner XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE)) { 517530f712c9SDave Chinner XFS_ERROR_REPORT("xfs_bunmapi", XFS_ERRLEVEL_LOW, 517630f712c9SDave Chinner ip->i_mount); 51772451337dSDave Chinner return -EFSCORRUPTED; 517830f712c9SDave Chinner } 517930f712c9SDave Chinner mp = ip->i_mount; 518030f712c9SDave Chinner if (XFS_FORCED_SHUTDOWN(mp)) 51812451337dSDave Chinner return -EIO; 518230f712c9SDave Chinner 518330f712c9SDave Chinner ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL)); 518430f712c9SDave Chinner ASSERT(len > 0); 518530f712c9SDave Chinner ASSERT(nexts >= 0); 518630f712c9SDave Chinner 5187e1a4e37cSDarrick J. Wong /* 5188e1a4e37cSDarrick J. Wong * Guesstimate how many blocks we can unmap without running the risk of 5189e1a4e37cSDarrick J. Wong * blowing out the transaction with a mix of EFIs and reflink 5190e1a4e37cSDarrick J. Wong * adjustments. 5191e1a4e37cSDarrick J. Wong */ 51928c57b886SDarrick J. Wong if (tp && xfs_is_reflink_inode(ip) && whichfork == XFS_DATA_FORK) 5193e1a4e37cSDarrick J. Wong max_len = min(len, xfs_refcount_max_unmap(tp->t_log_res)); 5194e1a4e37cSDarrick J. Wong else 5195e1a4e37cSDarrick J. Wong max_len = len; 5196e1a4e37cSDarrick J. Wong 519730f712c9SDave Chinner if (!(ifp->if_flags & XFS_IFEXTENTS) && 519830f712c9SDave Chinner (error = xfs_iread_extents(tp, ip, whichfork))) 519930f712c9SDave Chinner return error; 52005d829300SEric Sandeen if (xfs_iext_count(ifp) == 0) { 52014453593bSDarrick J. Wong *rlen = 0; 520230f712c9SDave Chinner return 0; 520330f712c9SDave Chinner } 5204ff6d6af2SBill O'Donnell XFS_STATS_INC(mp, xs_blk_unmap); 520530f712c9SDave Chinner isrt = (whichfork == XFS_DATA_FORK) && XFS_IS_REALTIME_INODE(ip); 5206dc56015fSChristoph Hellwig end = start + len; 520730f712c9SDave Chinner 5208b2b1712aSChristoph Hellwig if (!xfs_iext_lookup_extent_before(ip, ifp, &end, &icur, &got)) { 5209dc56015fSChristoph Hellwig *rlen = 0; 5210dc56015fSChristoph Hellwig return 0; 521130f712c9SDave Chinner } 5212dc56015fSChristoph Hellwig end--; 52137efc7945SChristoph Hellwig 521430f712c9SDave Chinner logflags = 0; 521530f712c9SDave Chinner if (ifp->if_flags & XFS_IFBROOT) { 521630f712c9SDave Chinner ASSERT(XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_BTREE); 521730f712c9SDave Chinner cur = xfs_bmbt_init_cursor(mp, tp, ip, whichfork); 521830f712c9SDave Chinner cur->bc_private.b.firstblock = *firstblock; 52192c3234d1SDarrick J. Wong cur->bc_private.b.dfops = dfops; 522030f712c9SDave Chinner cur->bc_private.b.flags = 0; 522130f712c9SDave Chinner } else 522230f712c9SDave Chinner cur = NULL; 522330f712c9SDave Chinner 522430f712c9SDave Chinner if (isrt) { 522530f712c9SDave Chinner /* 522630f712c9SDave Chinner * Synchronize by locking the bitmap inode. 522730f712c9SDave Chinner */ 5228f4a0660dSDarrick J. Wong xfs_ilock(mp->m_rbmip, XFS_ILOCK_EXCL|XFS_ILOCK_RTBITMAP); 522930f712c9SDave Chinner xfs_trans_ijoin(tp, mp->m_rbmip, XFS_ILOCK_EXCL); 5230f4a0660dSDarrick J. Wong xfs_ilock(mp->m_rsumip, XFS_ILOCK_EXCL|XFS_ILOCK_RTSUM); 5231f4a0660dSDarrick J. Wong xfs_trans_ijoin(tp, mp->m_rsumip, XFS_ILOCK_EXCL); 523230f712c9SDave Chinner } 523330f712c9SDave Chinner 523430f712c9SDave Chinner extno = 0; 5235b2b1712aSChristoph Hellwig while (end != (xfs_fileoff_t)-1 && end >= start && 5236e1a4e37cSDarrick J. Wong (nexts == 0 || extno < nexts) && max_len > 0) { 523730f712c9SDave Chinner /* 52388280f6edSChristoph Hellwig * Is the found extent after a hole in which end lives? 523930f712c9SDave Chinner * Just back up to the previous extent, if so. 524030f712c9SDave Chinner */ 5241b2b1712aSChristoph Hellwig if (got.br_startoff > end && 5242b2b1712aSChristoph Hellwig !xfs_iext_prev_extent(ifp, &icur, &got)) { 5243b2b1712aSChristoph Hellwig done = true; 524430f712c9SDave Chinner break; 524530f712c9SDave Chinner } 524630f712c9SDave Chinner /* 524730f712c9SDave Chinner * Is the last block of this extent before the range 524830f712c9SDave Chinner * we're supposed to delete? If so, we're done. 524930f712c9SDave Chinner */ 52508280f6edSChristoph Hellwig end = XFS_FILEOFF_MIN(end, 525130f712c9SDave Chinner got.br_startoff + got.br_blockcount - 1); 52528280f6edSChristoph Hellwig if (end < start) 525330f712c9SDave Chinner break; 525430f712c9SDave Chinner /* 525530f712c9SDave Chinner * Then deal with the (possibly delayed) allocated space 525630f712c9SDave Chinner * we found. 525730f712c9SDave Chinner */ 525830f712c9SDave Chinner del = got; 525930f712c9SDave Chinner wasdel = isnullstartblock(del.br_startblock); 52605b094d6dSChristoph Hellwig 52615b094d6dSChristoph Hellwig /* 52625b094d6dSChristoph Hellwig * Make sure we don't touch multiple AGF headers out of order 52635b094d6dSChristoph Hellwig * in a single transaction, as that could cause AB-BA deadlocks. 52645b094d6dSChristoph Hellwig */ 52655b094d6dSChristoph Hellwig if (!wasdel) { 52665b094d6dSChristoph Hellwig agno = XFS_FSB_TO_AGNO(mp, del.br_startblock); 52675b094d6dSChristoph Hellwig if (prev_agno != NULLAGNUMBER && prev_agno > agno) 52685b094d6dSChristoph Hellwig break; 52695b094d6dSChristoph Hellwig prev_agno = agno; 52705b094d6dSChristoph Hellwig } 527130f712c9SDave Chinner if (got.br_startoff < start) { 527230f712c9SDave Chinner del.br_startoff = start; 527330f712c9SDave Chinner del.br_blockcount -= start - got.br_startoff; 527430f712c9SDave Chinner if (!wasdel) 527530f712c9SDave Chinner del.br_startblock += start - got.br_startoff; 527630f712c9SDave Chinner } 52778280f6edSChristoph Hellwig if (del.br_startoff + del.br_blockcount > end + 1) 52788280f6edSChristoph Hellwig del.br_blockcount = end + 1 - del.br_startoff; 5279e1a4e37cSDarrick J. Wong 5280e1a4e37cSDarrick J. Wong /* How much can we safely unmap? */ 5281e1a4e37cSDarrick J. Wong if (max_len < del.br_blockcount) { 5282e1a4e37cSDarrick J. Wong del.br_startoff += del.br_blockcount - max_len; 5283e1a4e37cSDarrick J. Wong if (!wasdel) 5284e1a4e37cSDarrick J. Wong del.br_startblock += del.br_blockcount - max_len; 5285e1a4e37cSDarrick J. Wong del.br_blockcount = max_len; 5286e1a4e37cSDarrick J. Wong } 5287e1a4e37cSDarrick J. Wong 528830f712c9SDave Chinner sum = del.br_startblock + del.br_blockcount; 528930f712c9SDave Chinner if (isrt && 529030f712c9SDave Chinner (mod = do_mod(sum, mp->m_sb.sb_rextsize))) { 529130f712c9SDave Chinner /* 529230f712c9SDave Chinner * Realtime extent not lined up at the end. 529330f712c9SDave Chinner * The extent could have been split into written 529430f712c9SDave Chinner * and unwritten pieces, or we could just be 529530f712c9SDave Chinner * unmapping part of it. But we can't really 529630f712c9SDave Chinner * get rid of part of a realtime extent. 529730f712c9SDave Chinner */ 529830f712c9SDave Chinner if (del.br_state == XFS_EXT_UNWRITTEN || 529930f712c9SDave Chinner !xfs_sb_version_hasextflgbit(&mp->m_sb)) { 530030f712c9SDave Chinner /* 530130f712c9SDave Chinner * This piece is unwritten, or we're not 530230f712c9SDave Chinner * using unwritten extents. Skip over it. 530330f712c9SDave Chinner */ 53048280f6edSChristoph Hellwig ASSERT(end >= mod); 53058280f6edSChristoph Hellwig end -= mod > del.br_blockcount ? 530630f712c9SDave Chinner del.br_blockcount : mod; 5307b2b1712aSChristoph Hellwig if (end < got.br_startoff && 5308b2b1712aSChristoph Hellwig !xfs_iext_prev_extent(ifp, &icur, &got)) { 5309b2b1712aSChristoph Hellwig done = true; 5310b2b1712aSChristoph Hellwig break; 531130f712c9SDave Chinner } 531230f712c9SDave Chinner continue; 531330f712c9SDave Chinner } 531430f712c9SDave Chinner /* 531530f712c9SDave Chinner * It's written, turn it unwritten. 531630f712c9SDave Chinner * This is better than zeroing it. 531730f712c9SDave Chinner */ 531830f712c9SDave Chinner ASSERT(del.br_state == XFS_EXT_NORM); 5319a7e5d03bSChristoph Hellwig ASSERT(tp->t_blk_res > 0); 532030f712c9SDave Chinner /* 532130f712c9SDave Chinner * If this spans a realtime extent boundary, 532230f712c9SDave Chinner * chop it back to the start of the one we end at. 532330f712c9SDave Chinner */ 532430f712c9SDave Chinner if (del.br_blockcount > mod) { 532530f712c9SDave Chinner del.br_startoff += del.br_blockcount - mod; 532630f712c9SDave Chinner del.br_startblock += del.br_blockcount - mod; 532730f712c9SDave Chinner del.br_blockcount = mod; 532830f712c9SDave Chinner } 532930f712c9SDave Chinner del.br_state = XFS_EXT_UNWRITTEN; 533030f712c9SDave Chinner error = xfs_bmap_add_extent_unwritten_real(tp, ip, 5331b2b1712aSChristoph Hellwig whichfork, &icur, &cur, &del, 533205a630d7SDarrick J. Wong firstblock, dfops, &logflags); 533330f712c9SDave Chinner if (error) 533430f712c9SDave Chinner goto error0; 533530f712c9SDave Chinner goto nodelete; 533630f712c9SDave Chinner } 533730f712c9SDave Chinner if (isrt && (mod = do_mod(del.br_startblock, mp->m_sb.sb_rextsize))) { 533830f712c9SDave Chinner /* 533930f712c9SDave Chinner * Realtime extent is lined up at the end but not 534030f712c9SDave Chinner * at the front. We'll get rid of full extents if 534130f712c9SDave Chinner * we can. 534230f712c9SDave Chinner */ 534330f712c9SDave Chinner mod = mp->m_sb.sb_rextsize - mod; 534430f712c9SDave Chinner if (del.br_blockcount > mod) { 534530f712c9SDave Chinner del.br_blockcount -= mod; 534630f712c9SDave Chinner del.br_startoff += mod; 534730f712c9SDave Chinner del.br_startblock += mod; 534830f712c9SDave Chinner } else if ((del.br_startoff == start && 534930f712c9SDave Chinner (del.br_state == XFS_EXT_UNWRITTEN || 5350a7e5d03bSChristoph Hellwig tp->t_blk_res == 0)) || 535130f712c9SDave Chinner !xfs_sb_version_hasextflgbit(&mp->m_sb)) { 535230f712c9SDave Chinner /* 535330f712c9SDave Chinner * Can't make it unwritten. There isn't 535430f712c9SDave Chinner * a full extent here so just skip it. 535530f712c9SDave Chinner */ 53568280f6edSChristoph Hellwig ASSERT(end >= del.br_blockcount); 53578280f6edSChristoph Hellwig end -= del.br_blockcount; 5358b2b1712aSChristoph Hellwig if (got.br_startoff > end && 5359b2b1712aSChristoph Hellwig !xfs_iext_prev_extent(ifp, &icur, &got)) { 5360b2b1712aSChristoph Hellwig done = true; 5361b2b1712aSChristoph Hellwig break; 5362b2b1712aSChristoph Hellwig } 536330f712c9SDave Chinner continue; 536430f712c9SDave Chinner } else if (del.br_state == XFS_EXT_UNWRITTEN) { 53657efc7945SChristoph Hellwig struct xfs_bmbt_irec prev; 53667efc7945SChristoph Hellwig 536730f712c9SDave Chinner /* 536830f712c9SDave Chinner * This one is already unwritten. 536930f712c9SDave Chinner * It must have a written left neighbor. 537030f712c9SDave Chinner * Unwrite the killed part of that one and 537130f712c9SDave Chinner * try again. 537230f712c9SDave Chinner */ 5373b2b1712aSChristoph Hellwig if (!xfs_iext_prev_extent(ifp, &icur, &prev)) 5374b2b1712aSChristoph Hellwig ASSERT(0); 537530f712c9SDave Chinner ASSERT(prev.br_state == XFS_EXT_NORM); 537630f712c9SDave Chinner ASSERT(!isnullstartblock(prev.br_startblock)); 537730f712c9SDave Chinner ASSERT(del.br_startblock == 537830f712c9SDave Chinner prev.br_startblock + prev.br_blockcount); 537930f712c9SDave Chinner if (prev.br_startoff < start) { 538030f712c9SDave Chinner mod = start - prev.br_startoff; 538130f712c9SDave Chinner prev.br_blockcount -= mod; 538230f712c9SDave Chinner prev.br_startblock += mod; 538330f712c9SDave Chinner prev.br_startoff = start; 538430f712c9SDave Chinner } 538530f712c9SDave Chinner prev.br_state = XFS_EXT_UNWRITTEN; 538630f712c9SDave Chinner error = xfs_bmap_add_extent_unwritten_real(tp, 5387b2b1712aSChristoph Hellwig ip, whichfork, &icur, &cur, 538805a630d7SDarrick J. Wong &prev, firstblock, dfops, 538905a630d7SDarrick J. Wong &logflags); 539030f712c9SDave Chinner if (error) 539130f712c9SDave Chinner goto error0; 539230f712c9SDave Chinner goto nodelete; 539330f712c9SDave Chinner } else { 539430f712c9SDave Chinner ASSERT(del.br_state == XFS_EXT_NORM); 539530f712c9SDave Chinner del.br_state = XFS_EXT_UNWRITTEN; 539630f712c9SDave Chinner error = xfs_bmap_add_extent_unwritten_real(tp, 5397b2b1712aSChristoph Hellwig ip, whichfork, &icur, &cur, 539805a630d7SDarrick J. Wong &del, firstblock, dfops, 539905a630d7SDarrick J. Wong &logflags); 540030f712c9SDave Chinner if (error) 540130f712c9SDave Chinner goto error0; 540230f712c9SDave Chinner goto nodelete; 540330f712c9SDave Chinner } 540430f712c9SDave Chinner } 540530f712c9SDave Chinner 5406e1d7553fSChristoph Hellwig if (wasdel) { 5407b2b1712aSChristoph Hellwig error = xfs_bmap_del_extent_delay(ip, whichfork, &icur, 5408e1d7553fSChristoph Hellwig &got, &del); 5409e1d7553fSChristoph Hellwig } else { 5410b2b1712aSChristoph Hellwig error = xfs_bmap_del_extent_real(ip, tp, &icur, dfops, 5411e1d7553fSChristoph Hellwig cur, &del, &tmp_logflags, whichfork, 5412e1d7553fSChristoph Hellwig flags); 541330f712c9SDave Chinner logflags |= tmp_logflags; 5414e1d7553fSChristoph Hellwig } 5415e1d7553fSChristoph Hellwig 541630f712c9SDave Chinner if (error) 541730f712c9SDave Chinner goto error0; 5418b2706a05SBrian Foster 5419e1a4e37cSDarrick J. Wong max_len -= del.br_blockcount; 54208280f6edSChristoph Hellwig end = del.br_startoff - 1; 542130f712c9SDave Chinner nodelete: 542230f712c9SDave Chinner /* 542330f712c9SDave Chinner * If not done go on to the next (previous) record. 542430f712c9SDave Chinner */ 54258280f6edSChristoph Hellwig if (end != (xfs_fileoff_t)-1 && end >= start) { 5426b2b1712aSChristoph Hellwig if (!xfs_iext_get_extent(ifp, &icur, &got) || 5427b2b1712aSChristoph Hellwig (got.br_startoff > end && 5428b2b1712aSChristoph Hellwig !xfs_iext_prev_extent(ifp, &icur, &got))) { 5429b2b1712aSChristoph Hellwig done = true; 5430b2b1712aSChristoph Hellwig break; 543130f712c9SDave Chinner } 543230f712c9SDave Chinner extno++; 543330f712c9SDave Chinner } 543430f712c9SDave Chinner } 5435b2b1712aSChristoph Hellwig if (done || end == (xfs_fileoff_t)-1 || end < start) 54364453593bSDarrick J. Wong *rlen = 0; 54374453593bSDarrick J. Wong else 54388280f6edSChristoph Hellwig *rlen = end - start + 1; 543930f712c9SDave Chinner 544030f712c9SDave Chinner /* 544130f712c9SDave Chinner * Convert to a btree if necessary. 544230f712c9SDave Chinner */ 544330f712c9SDave Chinner if (xfs_bmap_needs_btree(ip, whichfork)) { 544430f712c9SDave Chinner ASSERT(cur == NULL); 54452c3234d1SDarrick J. Wong error = xfs_bmap_extents_to_btree(tp, ip, firstblock, dfops, 544630f712c9SDave Chinner &cur, 0, &tmp_logflags, whichfork); 544730f712c9SDave Chinner logflags |= tmp_logflags; 544830f712c9SDave Chinner if (error) 544930f712c9SDave Chinner goto error0; 545030f712c9SDave Chinner } 545130f712c9SDave Chinner /* 545230f712c9SDave Chinner * transform from btree to extents, give it cur 545330f712c9SDave Chinner */ 545430f712c9SDave Chinner else if (xfs_bmap_wants_extents(ip, whichfork)) { 545530f712c9SDave Chinner ASSERT(cur != NULL); 545630f712c9SDave Chinner error = xfs_bmap_btree_to_extents(tp, ip, cur, &tmp_logflags, 545730f712c9SDave Chinner whichfork); 545830f712c9SDave Chinner logflags |= tmp_logflags; 545930f712c9SDave Chinner if (error) 546030f712c9SDave Chinner goto error0; 546130f712c9SDave Chinner } 546230f712c9SDave Chinner /* 546330f712c9SDave Chinner * transform from extents to local? 546430f712c9SDave Chinner */ 546530f712c9SDave Chinner error = 0; 546630f712c9SDave Chinner error0: 546730f712c9SDave Chinner /* 546830f712c9SDave Chinner * Log everything. Do this after conversion, there's no point in 546930f712c9SDave Chinner * logging the extent records if we've converted to btree format. 547030f712c9SDave Chinner */ 547130f712c9SDave Chinner if ((logflags & xfs_ilog_fext(whichfork)) && 547230f712c9SDave Chinner XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS) 547330f712c9SDave Chinner logflags &= ~xfs_ilog_fext(whichfork); 547430f712c9SDave Chinner else if ((logflags & xfs_ilog_fbroot(whichfork)) && 547530f712c9SDave Chinner XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE) 547630f712c9SDave Chinner logflags &= ~xfs_ilog_fbroot(whichfork); 547730f712c9SDave Chinner /* 547830f712c9SDave Chinner * Log inode even in the error case, if the transaction 547930f712c9SDave Chinner * is dirty we'll need to shut down the filesystem. 548030f712c9SDave Chinner */ 548130f712c9SDave Chinner if (logflags) 548230f712c9SDave Chinner xfs_trans_log_inode(tp, ip, logflags); 548330f712c9SDave Chinner if (cur) { 548430f712c9SDave Chinner if (!error) { 548530f712c9SDave Chinner *firstblock = cur->bc_private.b.firstblock; 548630f712c9SDave Chinner cur->bc_private.b.allocated = 0; 548730f712c9SDave Chinner } 548830f712c9SDave Chinner xfs_btree_del_cursor(cur, 548930f712c9SDave Chinner error ? XFS_BTREE_ERROR : XFS_BTREE_NOERROR); 549030f712c9SDave Chinner } 549130f712c9SDave Chinner return error; 549230f712c9SDave Chinner } 549330f712c9SDave Chinner 54944453593bSDarrick J. Wong /* Unmap a range of a file. */ 54954453593bSDarrick J. Wong int 54964453593bSDarrick J. Wong xfs_bunmapi( 54974453593bSDarrick J. Wong xfs_trans_t *tp, 54984453593bSDarrick J. Wong struct xfs_inode *ip, 54994453593bSDarrick J. Wong xfs_fileoff_t bno, 55004453593bSDarrick J. Wong xfs_filblks_t len, 55014453593bSDarrick J. Wong int flags, 55024453593bSDarrick J. Wong xfs_extnum_t nexts, 55034453593bSDarrick J. Wong xfs_fsblock_t *firstblock, 55044453593bSDarrick J. Wong struct xfs_defer_ops *dfops, 55054453593bSDarrick J. Wong int *done) 55064453593bSDarrick J. Wong { 55074453593bSDarrick J. Wong int error; 55084453593bSDarrick J. Wong 55094453593bSDarrick J. Wong error = __xfs_bunmapi(tp, ip, bno, &len, flags, nexts, firstblock, 55104453593bSDarrick J. Wong dfops); 55114453593bSDarrick J. Wong *done = (len == 0); 55124453593bSDarrick J. Wong return error; 55134453593bSDarrick J. Wong } 55144453593bSDarrick J. Wong 551530f712c9SDave Chinner /* 5516ddb19e31SBrian Foster * Determine whether an extent shift can be accomplished by a merge with the 5517ddb19e31SBrian Foster * extent that precedes the target hole of the shift. 5518ddb19e31SBrian Foster */ 5519ddb19e31SBrian Foster STATIC bool 5520ddb19e31SBrian Foster xfs_bmse_can_merge( 5521ddb19e31SBrian Foster struct xfs_bmbt_irec *left, /* preceding extent */ 5522ddb19e31SBrian Foster struct xfs_bmbt_irec *got, /* current extent to shift */ 5523ddb19e31SBrian Foster xfs_fileoff_t shift) /* shift fsb */ 5524ddb19e31SBrian Foster { 5525ddb19e31SBrian Foster xfs_fileoff_t startoff; 5526ddb19e31SBrian Foster 5527ddb19e31SBrian Foster startoff = got->br_startoff - shift; 5528ddb19e31SBrian Foster 5529ddb19e31SBrian Foster /* 5530ddb19e31SBrian Foster * The extent, once shifted, must be adjacent in-file and on-disk with 5531ddb19e31SBrian Foster * the preceding extent. 5532ddb19e31SBrian Foster */ 5533ddb19e31SBrian Foster if ((left->br_startoff + left->br_blockcount != startoff) || 5534ddb19e31SBrian Foster (left->br_startblock + left->br_blockcount != got->br_startblock) || 5535ddb19e31SBrian Foster (left->br_state != got->br_state) || 5536ddb19e31SBrian Foster (left->br_blockcount + got->br_blockcount > MAXEXTLEN)) 5537ddb19e31SBrian Foster return false; 5538ddb19e31SBrian Foster 5539ddb19e31SBrian Foster return true; 5540ddb19e31SBrian Foster } 5541ddb19e31SBrian Foster 5542ddb19e31SBrian Foster /* 5543ddb19e31SBrian Foster * A bmap extent shift adjusts the file offset of an extent to fill a preceding 5544ddb19e31SBrian Foster * hole in the file. If an extent shift would result in the extent being fully 5545ddb19e31SBrian Foster * adjacent to the extent that currently precedes the hole, we can merge with 5546ddb19e31SBrian Foster * the preceding extent rather than do the shift. 5547ddb19e31SBrian Foster * 5548ddb19e31SBrian Foster * This function assumes the caller has verified a shift-by-merge is possible 5549ddb19e31SBrian Foster * with the provided extents via xfs_bmse_can_merge(). 5550ddb19e31SBrian Foster */ 5551ddb19e31SBrian Foster STATIC int 5552ddb19e31SBrian Foster xfs_bmse_merge( 5553ddb19e31SBrian Foster struct xfs_inode *ip, 5554ddb19e31SBrian Foster int whichfork, 5555ddb19e31SBrian Foster xfs_fileoff_t shift, /* shift fsb */ 5556b2b1712aSChristoph Hellwig struct xfs_iext_cursor *icur, 55574da6b514SChristoph Hellwig struct xfs_bmbt_irec *got, /* extent to shift */ 55584da6b514SChristoph Hellwig struct xfs_bmbt_irec *left, /* preceding extent */ 5559ddb19e31SBrian Foster struct xfs_btree_cur *cur, 55604da6b514SChristoph Hellwig int *logflags, /* output */ 55614da6b514SChristoph Hellwig struct xfs_defer_ops *dfops) 5562ddb19e31SBrian Foster { 55634da6b514SChristoph Hellwig struct xfs_bmbt_irec new; 5564ddb19e31SBrian Foster xfs_filblks_t blockcount; 5565ddb19e31SBrian Foster int error, i; 55665fb5aeeeSEric Sandeen struct xfs_mount *mp = ip->i_mount; 5567ddb19e31SBrian Foster 55684da6b514SChristoph Hellwig blockcount = left->br_blockcount + got->br_blockcount; 5569ddb19e31SBrian Foster 5570ddb19e31SBrian Foster ASSERT(xfs_isilocked(ip, XFS_IOLOCK_EXCL)); 5571ddb19e31SBrian Foster ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL)); 55724da6b514SChristoph Hellwig ASSERT(xfs_bmse_can_merge(left, got, shift)); 5573ddb19e31SBrian Foster 55744da6b514SChristoph Hellwig new = *left; 55754da6b514SChristoph Hellwig new.br_blockcount = blockcount; 5576ddb19e31SBrian Foster 5577ddb19e31SBrian Foster /* 5578ddb19e31SBrian Foster * Update the on-disk extent count, the btree if necessary and log the 5579ddb19e31SBrian Foster * inode. 5580ddb19e31SBrian Foster */ 5581ddb19e31SBrian Foster XFS_IFORK_NEXT_SET(ip, whichfork, 5582ddb19e31SBrian Foster XFS_IFORK_NEXTENTS(ip, whichfork) - 1); 5583ddb19e31SBrian Foster *logflags |= XFS_ILOG_CORE; 5584ddb19e31SBrian Foster if (!cur) { 5585ddb19e31SBrian Foster *logflags |= XFS_ILOG_DEXT; 55864da6b514SChristoph Hellwig goto done; 5587ddb19e31SBrian Foster } 5588ddb19e31SBrian Foster 5589ddb19e31SBrian Foster /* lookup and remove the extent to merge */ 5590e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(cur, got, &i); 5591ddb19e31SBrian Foster if (error) 55924db431f5SDave Chinner return error; 55935fb5aeeeSEric Sandeen XFS_WANT_CORRUPTED_RETURN(mp, i == 1); 5594ddb19e31SBrian Foster 5595ddb19e31SBrian Foster error = xfs_btree_delete(cur, &i); 5596ddb19e31SBrian Foster if (error) 55974db431f5SDave Chinner return error; 55985fb5aeeeSEric Sandeen XFS_WANT_CORRUPTED_RETURN(mp, i == 1); 5599ddb19e31SBrian Foster 5600ddb19e31SBrian Foster /* lookup and update size of the previous extent */ 5601e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(cur, left, &i); 5602ddb19e31SBrian Foster if (error) 56034db431f5SDave Chinner return error; 56045fb5aeeeSEric Sandeen XFS_WANT_CORRUPTED_RETURN(mp, i == 1); 5605ddb19e31SBrian Foster 5606a67d00a5SChristoph Hellwig error = xfs_bmbt_update(cur, &new); 56074da6b514SChristoph Hellwig if (error) 56084da6b514SChristoph Hellwig return error; 5609ddb19e31SBrian Foster 56104da6b514SChristoph Hellwig done: 5611c38ccf59SChristoph Hellwig xfs_iext_remove(ip, icur, 0); 5612b2b1712aSChristoph Hellwig xfs_iext_prev(XFS_IFORK_PTR(ip, whichfork), icur); 5613b2b1712aSChristoph Hellwig xfs_iext_update_extent(ip, xfs_bmap_fork_to_state(whichfork), icur, 5614b2b1712aSChristoph Hellwig &new); 56154da6b514SChristoph Hellwig 56164cc1ee5eSDarrick J. Wong /* update reverse mapping. rmap functions merge the rmaps for us */ 56174da6b514SChristoph Hellwig error = xfs_rmap_unmap_extent(mp, dfops, ip, whichfork, got); 56184da6b514SChristoph Hellwig if (error) 56194da6b514SChristoph Hellwig return error; 56204cc1ee5eSDarrick J. Wong memcpy(&new, got, sizeof(new)); 56214cc1ee5eSDarrick J. Wong new.br_startoff = left->br_startoff + left->br_blockcount; 56224da6b514SChristoph Hellwig return xfs_rmap_map_extent(mp, dfops, ip, whichfork, &new); 5623ddb19e31SBrian Foster } 5624ddb19e31SBrian Foster 5625bf806280SChristoph Hellwig static int 5626bf806280SChristoph Hellwig xfs_bmap_shift_update_extent( 5627a979bdfeSBrian Foster struct xfs_inode *ip, 5628a979bdfeSBrian Foster int whichfork, 5629b2b1712aSChristoph Hellwig struct xfs_iext_cursor *icur, 56304da6b514SChristoph Hellwig struct xfs_bmbt_irec *got, 5631a979bdfeSBrian Foster struct xfs_btree_cur *cur, 5632a904b1caSNamjae Jeon int *logflags, 5633bf806280SChristoph Hellwig struct xfs_defer_ops *dfops, 5634bf806280SChristoph Hellwig xfs_fileoff_t startoff) 5635a979bdfeSBrian Foster { 5636bf806280SChristoph Hellwig struct xfs_mount *mp = ip->i_mount; 563711f75b3bSChristoph Hellwig struct xfs_bmbt_irec prev = *got; 5638bf806280SChristoph Hellwig int error, i; 5639a979bdfeSBrian Foster 5640a979bdfeSBrian Foster *logflags |= XFS_ILOG_CORE; 5641a979bdfeSBrian Foster 564211f75b3bSChristoph Hellwig got->br_startoff = startoff; 56434da6b514SChristoph Hellwig 56444da6b514SChristoph Hellwig if (cur) { 564511f75b3bSChristoph Hellwig error = xfs_bmbt_lookup_eq(cur, &prev, &i); 5646a979bdfeSBrian Foster if (error) 5647a979bdfeSBrian Foster return error; 56485fb5aeeeSEric Sandeen XFS_WANT_CORRUPTED_RETURN(mp, i == 1); 5649a979bdfeSBrian Foster 565011f75b3bSChristoph Hellwig error = xfs_bmbt_update(cur, got); 56519c194644SDarrick J. Wong if (error) 56529c194644SDarrick J. Wong return error; 56534da6b514SChristoph Hellwig } else { 56544da6b514SChristoph Hellwig *logflags |= XFS_ILOG_DEXT; 56554da6b514SChristoph Hellwig } 56569c194644SDarrick J. Wong 5657b2b1712aSChristoph Hellwig xfs_iext_update_extent(ip, xfs_bmap_fork_to_state(whichfork), icur, 5658b2b1712aSChristoph Hellwig got); 56594da6b514SChristoph Hellwig 56609c194644SDarrick J. Wong /* update reverse mapping */ 566111f75b3bSChristoph Hellwig error = xfs_rmap_unmap_extent(mp, dfops, ip, whichfork, &prev); 56629c194644SDarrick J. Wong if (error) 56639c194644SDarrick J. Wong return error; 566411f75b3bSChristoph Hellwig return xfs_rmap_map_extent(mp, dfops, ip, whichfork, got); 5665a979bdfeSBrian Foster } 5666a979bdfeSBrian Foster 566730f712c9SDave Chinner int 5668ecfea3f0SChristoph Hellwig xfs_bmap_collapse_extents( 566930f712c9SDave Chinner struct xfs_trans *tp, 567030f712c9SDave Chinner struct xfs_inode *ip, 5671a904b1caSNamjae Jeon xfs_fileoff_t *next_fsb, 567230f712c9SDave Chinner xfs_fileoff_t offset_shift_fsb, 5673ecfea3f0SChristoph Hellwig bool *done, 567430f712c9SDave Chinner xfs_fsblock_t *firstblock, 5675ecfea3f0SChristoph Hellwig struct xfs_defer_ops *dfops) 567630f712c9SDave Chinner { 5677ecfea3f0SChristoph Hellwig int whichfork = XFS_DATA_FORK; 5678ecfea3f0SChristoph Hellwig struct xfs_mount *mp = ip->i_mount; 5679ecfea3f0SChristoph Hellwig struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, whichfork); 5680ca446d88SBrian Foster struct xfs_btree_cur *cur = NULL; 5681bf806280SChristoph Hellwig struct xfs_bmbt_irec got, prev; 5682b2b1712aSChristoph Hellwig struct xfs_iext_cursor icur; 5683bf806280SChristoph Hellwig xfs_fileoff_t new_startoff; 568430f712c9SDave Chinner int error = 0; 5685ca446d88SBrian Foster int logflags = 0; 568630f712c9SDave Chinner 568730f712c9SDave Chinner if (unlikely(XFS_TEST_ERROR( 568830f712c9SDave Chinner (XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS && 568930f712c9SDave Chinner XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE), 56909e24cfd0SDarrick J. Wong mp, XFS_ERRTAG_BMAPIFORMAT))) { 5691ecfea3f0SChristoph Hellwig XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_LOW, mp); 56922451337dSDave Chinner return -EFSCORRUPTED; 569330f712c9SDave Chinner } 569430f712c9SDave Chinner 569530f712c9SDave Chinner if (XFS_FORCED_SHUTDOWN(mp)) 56962451337dSDave Chinner return -EIO; 569730f712c9SDave Chinner 5698ecfea3f0SChristoph Hellwig ASSERT(xfs_isilocked(ip, XFS_IOLOCK_EXCL | XFS_ILOCK_EXCL)); 569930f712c9SDave Chinner 570030f712c9SDave Chinner if (!(ifp->if_flags & XFS_IFEXTENTS)) { 570130f712c9SDave Chinner error = xfs_iread_extents(tp, ip, whichfork); 570230f712c9SDave Chinner if (error) 570330f712c9SDave Chinner return error; 570430f712c9SDave Chinner } 570530f712c9SDave Chinner 5706ddb19e31SBrian Foster if (ifp->if_flags & XFS_IFBROOT) { 5707ddb19e31SBrian Foster cur = xfs_bmbt_init_cursor(mp, tp, ip, whichfork); 5708ddb19e31SBrian Foster cur->bc_private.b.firstblock = *firstblock; 57092c3234d1SDarrick J. Wong cur->bc_private.b.dfops = dfops; 5710ddb19e31SBrian Foster cur->bc_private.b.flags = 0; 5711ddb19e31SBrian Foster } 5712ddb19e31SBrian Foster 5713b2b1712aSChristoph Hellwig if (!xfs_iext_lookup_extent(ip, ifp, *next_fsb, &icur, &got)) { 5714ecfea3f0SChristoph Hellwig *done = true; 5715ecfea3f0SChristoph Hellwig goto del_cursor; 5716ecfea3f0SChristoph Hellwig } 5717d41c6172SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, !isnullstartblock(got.br_startblock), 5718d41c6172SEric Sandeen del_cursor); 5719ecfea3f0SChristoph Hellwig 5720bf806280SChristoph Hellwig new_startoff = got.br_startoff - offset_shift_fsb; 5721b2b1712aSChristoph Hellwig if (xfs_iext_peek_prev_extent(ifp, &icur, &prev)) { 5722bf806280SChristoph Hellwig if (new_startoff < prev.br_startoff + prev.br_blockcount) { 5723bf806280SChristoph Hellwig error = -EINVAL; 5724bf806280SChristoph Hellwig goto del_cursor; 5725bf806280SChristoph Hellwig } 5726bf806280SChristoph Hellwig 5727bf806280SChristoph Hellwig if (xfs_bmse_can_merge(&prev, &got, offset_shift_fsb)) { 5728bf806280SChristoph Hellwig error = xfs_bmse_merge(ip, whichfork, offset_shift_fsb, 5729b2b1712aSChristoph Hellwig &icur, &got, &prev, cur, &logflags, 5730b2b1712aSChristoph Hellwig dfops); 5731ecfea3f0SChristoph Hellwig if (error) 5732ecfea3f0SChristoph Hellwig goto del_cursor; 5733bf806280SChristoph Hellwig goto done; 5734bf806280SChristoph Hellwig } 5735bf806280SChristoph Hellwig } else { 5736bf806280SChristoph Hellwig if (got.br_startoff < offset_shift_fsb) { 5737bf806280SChristoph Hellwig error = -EINVAL; 5738bf806280SChristoph Hellwig goto del_cursor; 5739bf806280SChristoph Hellwig } 5740bf806280SChristoph Hellwig } 5741bf806280SChristoph Hellwig 5742b2b1712aSChristoph Hellwig error = xfs_bmap_shift_update_extent(ip, whichfork, &icur, &got, cur, 5743b2b1712aSChristoph Hellwig &logflags, dfops, new_startoff); 5744bf806280SChristoph Hellwig if (error) 5745bf806280SChristoph Hellwig goto del_cursor; 574640591bdbSChristoph Hellwig 574742630361SChristoph Hellwig done: 5748b2b1712aSChristoph Hellwig if (!xfs_iext_next_extent(ifp, &icur, &got)) { 5749ecfea3f0SChristoph Hellwig *done = true; 5750ecfea3f0SChristoph Hellwig goto del_cursor; 5751ecfea3f0SChristoph Hellwig } 5752ecfea3f0SChristoph Hellwig 5753ecfea3f0SChristoph Hellwig *next_fsb = got.br_startoff; 5754ecfea3f0SChristoph Hellwig del_cursor: 5755ecfea3f0SChristoph Hellwig if (cur) 5756ecfea3f0SChristoph Hellwig xfs_btree_del_cursor(cur, 5757ecfea3f0SChristoph Hellwig error ? XFS_BTREE_ERROR : XFS_BTREE_NOERROR); 5758ecfea3f0SChristoph Hellwig if (logflags) 5759ecfea3f0SChristoph Hellwig xfs_trans_log_inode(tp, ip, logflags); 5760ecfea3f0SChristoph Hellwig return error; 5761ecfea3f0SChristoph Hellwig } 5762ecfea3f0SChristoph Hellwig 5763ecfea3f0SChristoph Hellwig int 5764ecfea3f0SChristoph Hellwig xfs_bmap_insert_extents( 5765ecfea3f0SChristoph Hellwig struct xfs_trans *tp, 5766ecfea3f0SChristoph Hellwig struct xfs_inode *ip, 5767ecfea3f0SChristoph Hellwig xfs_fileoff_t *next_fsb, 5768ecfea3f0SChristoph Hellwig xfs_fileoff_t offset_shift_fsb, 5769ecfea3f0SChristoph Hellwig bool *done, 5770ecfea3f0SChristoph Hellwig xfs_fileoff_t stop_fsb, 5771ecfea3f0SChristoph Hellwig xfs_fsblock_t *firstblock, 5772ecfea3f0SChristoph Hellwig struct xfs_defer_ops *dfops) 5773ecfea3f0SChristoph Hellwig { 5774ecfea3f0SChristoph Hellwig int whichfork = XFS_DATA_FORK; 5775ecfea3f0SChristoph Hellwig struct xfs_mount *mp = ip->i_mount; 5776ecfea3f0SChristoph Hellwig struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, whichfork); 5777ecfea3f0SChristoph Hellwig struct xfs_btree_cur *cur = NULL; 57785936dc54SChristoph Hellwig struct xfs_bmbt_irec got, next; 5779b2b1712aSChristoph Hellwig struct xfs_iext_cursor icur; 5780bf806280SChristoph Hellwig xfs_fileoff_t new_startoff; 5781ecfea3f0SChristoph Hellwig int error = 0; 5782ecfea3f0SChristoph Hellwig int logflags = 0; 5783ecfea3f0SChristoph Hellwig 5784ecfea3f0SChristoph Hellwig if (unlikely(XFS_TEST_ERROR( 5785ecfea3f0SChristoph Hellwig (XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS && 5786ecfea3f0SChristoph Hellwig XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE), 5787ecfea3f0SChristoph Hellwig mp, XFS_ERRTAG_BMAPIFORMAT))) { 5788ecfea3f0SChristoph Hellwig XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_LOW, mp); 5789ecfea3f0SChristoph Hellwig return -EFSCORRUPTED; 5790ecfea3f0SChristoph Hellwig } 5791ecfea3f0SChristoph Hellwig 5792ecfea3f0SChristoph Hellwig if (XFS_FORCED_SHUTDOWN(mp)) 5793ecfea3f0SChristoph Hellwig return -EIO; 5794ecfea3f0SChristoph Hellwig 5795ecfea3f0SChristoph Hellwig ASSERT(xfs_isilocked(ip, XFS_IOLOCK_EXCL | XFS_ILOCK_EXCL)); 5796ecfea3f0SChristoph Hellwig 5797ecfea3f0SChristoph Hellwig if (!(ifp->if_flags & XFS_IFEXTENTS)) { 5798ecfea3f0SChristoph Hellwig error = xfs_iread_extents(tp, ip, whichfork); 5799ecfea3f0SChristoph Hellwig if (error) 5800ecfea3f0SChristoph Hellwig return error; 5801ecfea3f0SChristoph Hellwig } 5802ecfea3f0SChristoph Hellwig 5803ecfea3f0SChristoph Hellwig if (ifp->if_flags & XFS_IFBROOT) { 5804ecfea3f0SChristoph Hellwig cur = xfs_bmbt_init_cursor(mp, tp, ip, whichfork); 5805ecfea3f0SChristoph Hellwig cur->bc_private.b.firstblock = *firstblock; 5806ecfea3f0SChristoph Hellwig cur->bc_private.b.dfops = dfops; 5807ecfea3f0SChristoph Hellwig cur->bc_private.b.flags = 0; 5808ecfea3f0SChristoph Hellwig } 5809ecfea3f0SChristoph Hellwig 5810a904b1caSNamjae Jeon if (*next_fsb == NULLFSBLOCK) { 5811b2b1712aSChristoph Hellwig xfs_iext_last(ifp, &icur); 5812b2b1712aSChristoph Hellwig if (!xfs_iext_get_extent(ifp, &icur, &got) || 58135936dc54SChristoph Hellwig stop_fsb > got.br_startoff) { 5814ecfea3f0SChristoph Hellwig *done = true; 5815a904b1caSNamjae Jeon goto del_cursor; 5816a904b1caSNamjae Jeon } 581705b7c8abSChristoph Hellwig } else { 5818b2b1712aSChristoph Hellwig if (!xfs_iext_lookup_extent(ip, ifp, *next_fsb, &icur, &got)) { 5819ecfea3f0SChristoph Hellwig *done = true; 5820a904b1caSNamjae Jeon goto del_cursor; 5821a904b1caSNamjae Jeon } 582205b7c8abSChristoph Hellwig } 5823d41c6172SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, !isnullstartblock(got.br_startblock), 5824d41c6172SEric Sandeen del_cursor); 5825a904b1caSNamjae Jeon 58265936dc54SChristoph Hellwig if (stop_fsb >= got.br_startoff + got.br_blockcount) { 5827a904b1caSNamjae Jeon error = -EIO; 5828a904b1caSNamjae Jeon goto del_cursor; 5829a904b1caSNamjae Jeon } 5830a904b1caSNamjae Jeon 5831bf806280SChristoph Hellwig new_startoff = got.br_startoff + offset_shift_fsb; 5832b2b1712aSChristoph Hellwig if (xfs_iext_peek_next_extent(ifp, &icur, &next)) { 5833bf806280SChristoph Hellwig if (new_startoff + got.br_blockcount > next.br_startoff) { 5834bf806280SChristoph Hellwig error = -EINVAL; 5835bf806280SChristoph Hellwig goto del_cursor; 5836bf806280SChristoph Hellwig } 5837bf806280SChristoph Hellwig 5838bf806280SChristoph Hellwig /* 5839bf806280SChristoph Hellwig * Unlike a left shift (which involves a hole punch), a right 5840bf806280SChristoph Hellwig * shift does not modify extent neighbors in any way. We should 5841bf806280SChristoph Hellwig * never find mergeable extents in this scenario. Check anyways 5842bf806280SChristoph Hellwig * and warn if we encounter two extents that could be one. 5843bf806280SChristoph Hellwig */ 5844bf806280SChristoph Hellwig if (xfs_bmse_can_merge(&got, &next, offset_shift_fsb)) 5845bf806280SChristoph Hellwig WARN_ON_ONCE(1); 5846bf806280SChristoph Hellwig } 5847bf806280SChristoph Hellwig 5848b2b1712aSChristoph Hellwig error = xfs_bmap_shift_update_extent(ip, whichfork, &icur, &got, cur, 5849b2b1712aSChristoph Hellwig &logflags, dfops, new_startoff); 5850ddb19e31SBrian Foster if (error) 5851ddb19e31SBrian Foster goto del_cursor; 58525936dc54SChristoph Hellwig 5853b2b1712aSChristoph Hellwig if (!xfs_iext_prev_extent(ifp, &icur, &got) || 58545936dc54SChristoph Hellwig stop_fsb >= got.br_startoff + got.br_blockcount) { 5855ecfea3f0SChristoph Hellwig *done = true; 58566b18af0dSChristoph Hellwig goto del_cursor; 5857a904b1caSNamjae Jeon } 585830f712c9SDave Chinner 58592c845f5aSBrian Foster *next_fsb = got.br_startoff; 586030f712c9SDave Chinner del_cursor: 586130f712c9SDave Chinner if (cur) 586230f712c9SDave Chinner xfs_btree_del_cursor(cur, 586330f712c9SDave Chinner error ? XFS_BTREE_ERROR : XFS_BTREE_NOERROR); 5864ca446d88SBrian Foster if (logflags) 586530f712c9SDave Chinner xfs_trans_log_inode(tp, ip, logflags); 586630f712c9SDave Chinner return error; 586730f712c9SDave Chinner } 5868a904b1caSNamjae Jeon 5869a904b1caSNamjae Jeon /* 5870b2b1712aSChristoph Hellwig * Splits an extent into two extents at split_fsb block such that it is the 5871b2b1712aSChristoph Hellwig * first block of the current_ext. @ext is a target extent to be split. 5872b2b1712aSChristoph Hellwig * @split_fsb is a block where the extents is split. If split_fsb lies in a 5873b2b1712aSChristoph Hellwig * hole or the first block of extents, just return 0. 5874a904b1caSNamjae Jeon */ 5875a904b1caSNamjae Jeon STATIC int 5876a904b1caSNamjae Jeon xfs_bmap_split_extent_at( 5877a904b1caSNamjae Jeon struct xfs_trans *tp, 5878a904b1caSNamjae Jeon struct xfs_inode *ip, 5879a904b1caSNamjae Jeon xfs_fileoff_t split_fsb, 5880a904b1caSNamjae Jeon xfs_fsblock_t *firstfsb, 58812c3234d1SDarrick J. Wong struct xfs_defer_ops *dfops) 5882a904b1caSNamjae Jeon { 5883a904b1caSNamjae Jeon int whichfork = XFS_DATA_FORK; 5884a904b1caSNamjae Jeon struct xfs_btree_cur *cur = NULL; 5885a904b1caSNamjae Jeon struct xfs_bmbt_irec got; 5886a904b1caSNamjae Jeon struct xfs_bmbt_irec new; /* split extent */ 5887a904b1caSNamjae Jeon struct xfs_mount *mp = ip->i_mount; 5888a904b1caSNamjae Jeon struct xfs_ifork *ifp; 5889a904b1caSNamjae Jeon xfs_fsblock_t gotblkcnt; /* new block count for got */ 5890b2b1712aSChristoph Hellwig struct xfs_iext_cursor icur; 5891a904b1caSNamjae Jeon int error = 0; 5892a904b1caSNamjae Jeon int logflags = 0; 5893a904b1caSNamjae Jeon int i = 0; 5894a904b1caSNamjae Jeon 5895a904b1caSNamjae Jeon if (unlikely(XFS_TEST_ERROR( 5896a904b1caSNamjae Jeon (XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS && 5897a904b1caSNamjae Jeon XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE), 58989e24cfd0SDarrick J. Wong mp, XFS_ERRTAG_BMAPIFORMAT))) { 5899a904b1caSNamjae Jeon XFS_ERROR_REPORT("xfs_bmap_split_extent_at", 5900a904b1caSNamjae Jeon XFS_ERRLEVEL_LOW, mp); 5901a904b1caSNamjae Jeon return -EFSCORRUPTED; 5902a904b1caSNamjae Jeon } 5903a904b1caSNamjae Jeon 5904a904b1caSNamjae Jeon if (XFS_FORCED_SHUTDOWN(mp)) 5905a904b1caSNamjae Jeon return -EIO; 5906a904b1caSNamjae Jeon 5907a904b1caSNamjae Jeon ifp = XFS_IFORK_PTR(ip, whichfork); 5908a904b1caSNamjae Jeon if (!(ifp->if_flags & XFS_IFEXTENTS)) { 5909a904b1caSNamjae Jeon /* Read in all the extents */ 5910a904b1caSNamjae Jeon error = xfs_iread_extents(tp, ip, whichfork); 5911a904b1caSNamjae Jeon if (error) 5912a904b1caSNamjae Jeon return error; 5913a904b1caSNamjae Jeon } 5914a904b1caSNamjae Jeon 5915a904b1caSNamjae Jeon /* 59164c35445bSChristoph Hellwig * If there are not extents, or split_fsb lies in a hole we are done. 5917a904b1caSNamjae Jeon */ 5918b2b1712aSChristoph Hellwig if (!xfs_iext_lookup_extent(ip, ifp, split_fsb, &icur, &got) || 59194c35445bSChristoph Hellwig got.br_startoff >= split_fsb) 5920a904b1caSNamjae Jeon return 0; 5921a904b1caSNamjae Jeon 5922a904b1caSNamjae Jeon gotblkcnt = split_fsb - got.br_startoff; 5923a904b1caSNamjae Jeon new.br_startoff = split_fsb; 5924a904b1caSNamjae Jeon new.br_startblock = got.br_startblock + gotblkcnt; 5925a904b1caSNamjae Jeon new.br_blockcount = got.br_blockcount - gotblkcnt; 5926a904b1caSNamjae Jeon new.br_state = got.br_state; 5927a904b1caSNamjae Jeon 5928a904b1caSNamjae Jeon if (ifp->if_flags & XFS_IFBROOT) { 5929a904b1caSNamjae Jeon cur = xfs_bmbt_init_cursor(mp, tp, ip, whichfork); 5930a904b1caSNamjae Jeon cur->bc_private.b.firstblock = *firstfsb; 59312c3234d1SDarrick J. Wong cur->bc_private.b.dfops = dfops; 5932a904b1caSNamjae Jeon cur->bc_private.b.flags = 0; 5933e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(cur, &got, &i); 5934a904b1caSNamjae Jeon if (error) 5935a904b1caSNamjae Jeon goto del_cursor; 5936a904b1caSNamjae Jeon XFS_WANT_CORRUPTED_GOTO(mp, i == 1, del_cursor); 5937a904b1caSNamjae Jeon } 5938a904b1caSNamjae Jeon 5939a904b1caSNamjae Jeon got.br_blockcount = gotblkcnt; 5940b2b1712aSChristoph Hellwig xfs_iext_update_extent(ip, xfs_bmap_fork_to_state(whichfork), &icur, 5941b2b1712aSChristoph Hellwig &got); 5942a904b1caSNamjae Jeon 5943a904b1caSNamjae Jeon logflags = XFS_ILOG_CORE; 5944a904b1caSNamjae Jeon if (cur) { 5945a67d00a5SChristoph Hellwig error = xfs_bmbt_update(cur, &got); 5946a904b1caSNamjae Jeon if (error) 5947a904b1caSNamjae Jeon goto del_cursor; 5948a904b1caSNamjae Jeon } else 5949a904b1caSNamjae Jeon logflags |= XFS_ILOG_DEXT; 5950a904b1caSNamjae Jeon 5951a904b1caSNamjae Jeon /* Add new extent */ 5952b2b1712aSChristoph Hellwig xfs_iext_next(ifp, &icur); 59530254c2f2SChristoph Hellwig xfs_iext_insert(ip, &icur, &new, 0); 5954a904b1caSNamjae Jeon XFS_IFORK_NEXT_SET(ip, whichfork, 5955a904b1caSNamjae Jeon XFS_IFORK_NEXTENTS(ip, whichfork) + 1); 5956a904b1caSNamjae Jeon 5957a904b1caSNamjae Jeon if (cur) { 5958e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(cur, &new, &i); 5959a904b1caSNamjae Jeon if (error) 5960a904b1caSNamjae Jeon goto del_cursor; 5961a904b1caSNamjae Jeon XFS_WANT_CORRUPTED_GOTO(mp, i == 0, del_cursor); 5962a904b1caSNamjae Jeon error = xfs_btree_insert(cur, &i); 5963a904b1caSNamjae Jeon if (error) 5964a904b1caSNamjae Jeon goto del_cursor; 5965a904b1caSNamjae Jeon XFS_WANT_CORRUPTED_GOTO(mp, i == 1, del_cursor); 5966a904b1caSNamjae Jeon } 5967a904b1caSNamjae Jeon 5968a904b1caSNamjae Jeon /* 5969a904b1caSNamjae Jeon * Convert to a btree if necessary. 5970a904b1caSNamjae Jeon */ 5971a904b1caSNamjae Jeon if (xfs_bmap_needs_btree(ip, whichfork)) { 5972a904b1caSNamjae Jeon int tmp_logflags; /* partial log flag return val */ 5973a904b1caSNamjae Jeon 5974a904b1caSNamjae Jeon ASSERT(cur == NULL); 59752c3234d1SDarrick J. Wong error = xfs_bmap_extents_to_btree(tp, ip, firstfsb, dfops, 5976a904b1caSNamjae Jeon &cur, 0, &tmp_logflags, whichfork); 5977a904b1caSNamjae Jeon logflags |= tmp_logflags; 5978a904b1caSNamjae Jeon } 5979a904b1caSNamjae Jeon 5980a904b1caSNamjae Jeon del_cursor: 5981a904b1caSNamjae Jeon if (cur) { 5982a904b1caSNamjae Jeon cur->bc_private.b.allocated = 0; 5983a904b1caSNamjae Jeon xfs_btree_del_cursor(cur, 5984a904b1caSNamjae Jeon error ? XFS_BTREE_ERROR : XFS_BTREE_NOERROR); 5985a904b1caSNamjae Jeon } 5986a904b1caSNamjae Jeon 5987a904b1caSNamjae Jeon if (logflags) 5988a904b1caSNamjae Jeon xfs_trans_log_inode(tp, ip, logflags); 5989a904b1caSNamjae Jeon return error; 5990a904b1caSNamjae Jeon } 5991a904b1caSNamjae Jeon 5992a904b1caSNamjae Jeon int 5993a904b1caSNamjae Jeon xfs_bmap_split_extent( 5994a904b1caSNamjae Jeon struct xfs_inode *ip, 5995a904b1caSNamjae Jeon xfs_fileoff_t split_fsb) 5996a904b1caSNamjae Jeon { 5997a904b1caSNamjae Jeon struct xfs_mount *mp = ip->i_mount; 5998a904b1caSNamjae Jeon struct xfs_trans *tp; 59992c3234d1SDarrick J. Wong struct xfs_defer_ops dfops; 6000a904b1caSNamjae Jeon xfs_fsblock_t firstfsb; 6001a904b1caSNamjae Jeon int error; 6002a904b1caSNamjae Jeon 6003253f4911SChristoph Hellwig error = xfs_trans_alloc(mp, &M_RES(mp)->tr_write, 6004253f4911SChristoph Hellwig XFS_DIOSTRAT_SPACE_RES(mp, 0), 0, 0, &tp); 6005253f4911SChristoph Hellwig if (error) 6006a904b1caSNamjae Jeon return error; 6007a904b1caSNamjae Jeon 6008a904b1caSNamjae Jeon xfs_ilock(ip, XFS_ILOCK_EXCL); 6009a904b1caSNamjae Jeon xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL); 6010a904b1caSNamjae Jeon 60112c3234d1SDarrick J. Wong xfs_defer_init(&dfops, &firstfsb); 6012a904b1caSNamjae Jeon 6013a904b1caSNamjae Jeon error = xfs_bmap_split_extent_at(tp, ip, split_fsb, 60142c3234d1SDarrick J. Wong &firstfsb, &dfops); 6015a904b1caSNamjae Jeon if (error) 6016a904b1caSNamjae Jeon goto out; 6017a904b1caSNamjae Jeon 60188ad7c629SChristoph Hellwig error = xfs_defer_finish(&tp, &dfops); 6019a904b1caSNamjae Jeon if (error) 6020a904b1caSNamjae Jeon goto out; 6021a904b1caSNamjae Jeon 602270393313SChristoph Hellwig return xfs_trans_commit(tp); 6023a904b1caSNamjae Jeon 6024a904b1caSNamjae Jeon out: 60252c3234d1SDarrick J. Wong xfs_defer_cancel(&dfops); 60264906e215SChristoph Hellwig xfs_trans_cancel(tp); 6027a904b1caSNamjae Jeon return error; 6028a904b1caSNamjae Jeon } 60299f3afb57SDarrick J. Wong 60309f3afb57SDarrick J. Wong /* Deferred mapping is only for real extents in the data fork. */ 60319f3afb57SDarrick J. Wong static bool 60329f3afb57SDarrick J. Wong xfs_bmap_is_update_needed( 60339f3afb57SDarrick J. Wong struct xfs_bmbt_irec *bmap) 60349f3afb57SDarrick J. Wong { 60359f3afb57SDarrick J. Wong return bmap->br_startblock != HOLESTARTBLOCK && 60369f3afb57SDarrick J. Wong bmap->br_startblock != DELAYSTARTBLOCK; 60379f3afb57SDarrick J. Wong } 60389f3afb57SDarrick J. Wong 60399f3afb57SDarrick J. Wong /* Record a bmap intent. */ 60409f3afb57SDarrick J. Wong static int 60419f3afb57SDarrick J. Wong __xfs_bmap_add( 60429f3afb57SDarrick J. Wong struct xfs_mount *mp, 60439f3afb57SDarrick J. Wong struct xfs_defer_ops *dfops, 60449f3afb57SDarrick J. Wong enum xfs_bmap_intent_type type, 60459f3afb57SDarrick J. Wong struct xfs_inode *ip, 60469f3afb57SDarrick J. Wong int whichfork, 60479f3afb57SDarrick J. Wong struct xfs_bmbt_irec *bmap) 60489f3afb57SDarrick J. Wong { 60499f3afb57SDarrick J. Wong int error; 60509f3afb57SDarrick J. Wong struct xfs_bmap_intent *bi; 60519f3afb57SDarrick J. Wong 60529f3afb57SDarrick J. Wong trace_xfs_bmap_defer(mp, 60539f3afb57SDarrick J. Wong XFS_FSB_TO_AGNO(mp, bmap->br_startblock), 60549f3afb57SDarrick J. Wong type, 60559f3afb57SDarrick J. Wong XFS_FSB_TO_AGBNO(mp, bmap->br_startblock), 60569f3afb57SDarrick J. Wong ip->i_ino, whichfork, 60579f3afb57SDarrick J. Wong bmap->br_startoff, 60589f3afb57SDarrick J. Wong bmap->br_blockcount, 60599f3afb57SDarrick J. Wong bmap->br_state); 60609f3afb57SDarrick J. Wong 60619f3afb57SDarrick J. Wong bi = kmem_alloc(sizeof(struct xfs_bmap_intent), KM_SLEEP | KM_NOFS); 60629f3afb57SDarrick J. Wong INIT_LIST_HEAD(&bi->bi_list); 60639f3afb57SDarrick J. Wong bi->bi_type = type; 60649f3afb57SDarrick J. Wong bi->bi_owner = ip; 60659f3afb57SDarrick J. Wong bi->bi_whichfork = whichfork; 60669f3afb57SDarrick J. Wong bi->bi_bmap = *bmap; 60679f3afb57SDarrick J. Wong 6068882d8785SChristoph Hellwig error = xfs_defer_ijoin(dfops, bi->bi_owner); 60699f3afb57SDarrick J. Wong if (error) { 60709f3afb57SDarrick J. Wong kmem_free(bi); 60719f3afb57SDarrick J. Wong return error; 60729f3afb57SDarrick J. Wong } 60739f3afb57SDarrick J. Wong 60749f3afb57SDarrick J. Wong xfs_defer_add(dfops, XFS_DEFER_OPS_TYPE_BMAP, &bi->bi_list); 60759f3afb57SDarrick J. Wong return 0; 60769f3afb57SDarrick J. Wong } 60779f3afb57SDarrick J. Wong 60789f3afb57SDarrick J. Wong /* Map an extent into a file. */ 60799f3afb57SDarrick J. Wong int 60809f3afb57SDarrick J. Wong xfs_bmap_map_extent( 60819f3afb57SDarrick J. Wong struct xfs_mount *mp, 60829f3afb57SDarrick J. Wong struct xfs_defer_ops *dfops, 60839f3afb57SDarrick J. Wong struct xfs_inode *ip, 60849f3afb57SDarrick J. Wong struct xfs_bmbt_irec *PREV) 60859f3afb57SDarrick J. Wong { 60869f3afb57SDarrick J. Wong if (!xfs_bmap_is_update_needed(PREV)) 60879f3afb57SDarrick J. Wong return 0; 60889f3afb57SDarrick J. Wong 60899f3afb57SDarrick J. Wong return __xfs_bmap_add(mp, dfops, XFS_BMAP_MAP, ip, 60909f3afb57SDarrick J. Wong XFS_DATA_FORK, PREV); 60919f3afb57SDarrick J. Wong } 60929f3afb57SDarrick J. Wong 60939f3afb57SDarrick J. Wong /* Unmap an extent out of a file. */ 60949f3afb57SDarrick J. Wong int 60959f3afb57SDarrick J. Wong xfs_bmap_unmap_extent( 60969f3afb57SDarrick J. Wong struct xfs_mount *mp, 60979f3afb57SDarrick J. Wong struct xfs_defer_ops *dfops, 60989f3afb57SDarrick J. Wong struct xfs_inode *ip, 60999f3afb57SDarrick J. Wong struct xfs_bmbt_irec *PREV) 61009f3afb57SDarrick J. Wong { 61019f3afb57SDarrick J. Wong if (!xfs_bmap_is_update_needed(PREV)) 61029f3afb57SDarrick J. Wong return 0; 61039f3afb57SDarrick J. Wong 61049f3afb57SDarrick J. Wong return __xfs_bmap_add(mp, dfops, XFS_BMAP_UNMAP, ip, 61059f3afb57SDarrick J. Wong XFS_DATA_FORK, PREV); 61069f3afb57SDarrick J. Wong } 61079f3afb57SDarrick J. Wong 61089f3afb57SDarrick J. Wong /* 61099f3afb57SDarrick J. Wong * Process one of the deferred bmap operations. We pass back the 61109f3afb57SDarrick J. Wong * btree cursor to maintain our lock on the bmapbt between calls. 61119f3afb57SDarrick J. Wong */ 61129f3afb57SDarrick J. Wong int 61139f3afb57SDarrick J. Wong xfs_bmap_finish_one( 61149f3afb57SDarrick J. Wong struct xfs_trans *tp, 61159f3afb57SDarrick J. Wong struct xfs_defer_ops *dfops, 61169f3afb57SDarrick J. Wong struct xfs_inode *ip, 61179f3afb57SDarrick J. Wong enum xfs_bmap_intent_type type, 61189f3afb57SDarrick J. Wong int whichfork, 61199f3afb57SDarrick J. Wong xfs_fileoff_t startoff, 61209f3afb57SDarrick J. Wong xfs_fsblock_t startblock, 6121e1a4e37cSDarrick J. Wong xfs_filblks_t *blockcount, 61229f3afb57SDarrick J. Wong xfs_exntst_t state) 61239f3afb57SDarrick J. Wong { 6124e1a4e37cSDarrick J. Wong xfs_fsblock_t firstfsb; 6125e1a4e37cSDarrick J. Wong int error = 0; 61269f3afb57SDarrick J. Wong 61274c1a67bdSDarrick J. Wong /* 61284c1a67bdSDarrick J. Wong * firstfsb is tied to the transaction lifetime and is used to 61294c1a67bdSDarrick J. Wong * ensure correct AG locking order and schedule work item 61304c1a67bdSDarrick J. Wong * continuations. XFS_BUI_MAX_FAST_EXTENTS (== 1) restricts us 61314c1a67bdSDarrick J. Wong * to only making one bmap call per transaction, so it should 61324c1a67bdSDarrick J. Wong * be safe to have it as a local variable here. 61334c1a67bdSDarrick J. Wong */ 61344c1a67bdSDarrick J. Wong firstfsb = NULLFSBLOCK; 61354c1a67bdSDarrick J. Wong 61369f3afb57SDarrick J. Wong trace_xfs_bmap_deferred(tp->t_mountp, 61379f3afb57SDarrick J. Wong XFS_FSB_TO_AGNO(tp->t_mountp, startblock), type, 61389f3afb57SDarrick J. Wong XFS_FSB_TO_AGBNO(tp->t_mountp, startblock), 6139e1a4e37cSDarrick J. Wong ip->i_ino, whichfork, startoff, *blockcount, state); 61409f3afb57SDarrick J. Wong 614139e07daaSChristoph Hellwig if (WARN_ON_ONCE(whichfork != XFS_DATA_FORK)) 61429f3afb57SDarrick J. Wong return -EFSCORRUPTED; 61439f3afb57SDarrick J. Wong 61449f3afb57SDarrick J. Wong if (XFS_TEST_ERROR(false, tp->t_mountp, 61459e24cfd0SDarrick J. Wong XFS_ERRTAG_BMAP_FINISH_ONE)) 61469f3afb57SDarrick J. Wong return -EIO; 61479f3afb57SDarrick J. Wong 61489f3afb57SDarrick J. Wong switch (type) { 61499f3afb57SDarrick J. Wong case XFS_BMAP_MAP: 6150e1a4e37cSDarrick J. Wong error = xfs_bmapi_remap(tp, ip, startoff, *blockcount, 61516ebd5a44SChristoph Hellwig startblock, dfops); 6152e1a4e37cSDarrick J. Wong *blockcount = 0; 61539f3afb57SDarrick J. Wong break; 61549f3afb57SDarrick J. Wong case XFS_BMAP_UNMAP: 6155e1a4e37cSDarrick J. Wong error = __xfs_bunmapi(tp, ip, startoff, blockcount, 6156e1a4e37cSDarrick J. Wong XFS_BMAPI_REMAP, 1, &firstfsb, dfops); 61579f3afb57SDarrick J. Wong break; 61589f3afb57SDarrick J. Wong default: 61599f3afb57SDarrick J. Wong ASSERT(0); 61609f3afb57SDarrick J. Wong error = -EFSCORRUPTED; 61619f3afb57SDarrick J. Wong } 61629f3afb57SDarrick J. Wong 61639f3afb57SDarrick J. Wong return error; 61649f3afb57SDarrick J. Wong } 616530b0984dSDarrick J. Wong 616630b0984dSDarrick J. Wong /* Check that an inode's extent does not have invalid flags or bad ranges. */ 616730b0984dSDarrick J. Wong xfs_failaddr_t 616830b0984dSDarrick J. Wong xfs_bmap_validate_extent( 616930b0984dSDarrick J. Wong struct xfs_inode *ip, 617030b0984dSDarrick J. Wong int whichfork, 617130b0984dSDarrick J. Wong struct xfs_bmbt_irec *irec) 617230b0984dSDarrick J. Wong { 617330b0984dSDarrick J. Wong struct xfs_mount *mp = ip->i_mount; 617430b0984dSDarrick J. Wong xfs_fsblock_t endfsb; 617530b0984dSDarrick J. Wong bool isrt; 617630b0984dSDarrick J. Wong 617730b0984dSDarrick J. Wong isrt = XFS_IS_REALTIME_INODE(ip); 617830b0984dSDarrick J. Wong endfsb = irec->br_startblock + irec->br_blockcount - 1; 617930b0984dSDarrick J. Wong if (isrt) { 618030b0984dSDarrick J. Wong if (!xfs_verify_rtbno(mp, irec->br_startblock)) 618130b0984dSDarrick J. Wong return __this_address; 618230b0984dSDarrick J. Wong if (!xfs_verify_rtbno(mp, endfsb)) 618330b0984dSDarrick J. Wong return __this_address; 618430b0984dSDarrick J. Wong } else { 618530b0984dSDarrick J. Wong if (!xfs_verify_fsbno(mp, irec->br_startblock)) 618630b0984dSDarrick J. Wong return __this_address; 618730b0984dSDarrick J. Wong if (!xfs_verify_fsbno(mp, endfsb)) 618830b0984dSDarrick J. Wong return __this_address; 618930b0984dSDarrick J. Wong if (XFS_FSB_TO_AGNO(mp, irec->br_startblock) != 619030b0984dSDarrick J. Wong XFS_FSB_TO_AGNO(mp, endfsb)) 619130b0984dSDarrick J. Wong return __this_address; 619230b0984dSDarrick J. Wong } 619330b0984dSDarrick J. Wong if (irec->br_state != XFS_EXT_NORM) { 619430b0984dSDarrick J. Wong if (whichfork != XFS_DATA_FORK) 619530b0984dSDarrick J. Wong return __this_address; 619630b0984dSDarrick J. Wong if (!xfs_sb_version_hasextflgbit(&mp->m_sb)) 619730b0984dSDarrick J. Wong return __this_address; 619830b0984dSDarrick J. Wong } 619930b0984dSDarrick J. Wong return NULL; 620030b0984dSDarrick J. Wong } 6201