10b61f8a4SDave Chinner // SPDX-License-Identifier: GPL-2.0 230f712c9SDave Chinner /* 330f712c9SDave Chinner * Copyright (c) 2000-2006 Silicon Graphics, Inc. 430f712c9SDave Chinner * All Rights Reserved. 530f712c9SDave Chinner */ 630f712c9SDave Chinner #include "xfs.h" 730f712c9SDave Chinner #include "xfs_fs.h" 830f712c9SDave Chinner #include "xfs_shared.h" 930f712c9SDave Chinner #include "xfs_format.h" 1030f712c9SDave Chinner #include "xfs_log_format.h" 1130f712c9SDave Chinner #include "xfs_trans_resv.h" 1230f712c9SDave Chinner #include "xfs_bit.h" 1330f712c9SDave Chinner #include "xfs_sb.h" 1430f712c9SDave Chinner #include "xfs_mount.h" 153ab78df2SDarrick J. Wong #include "xfs_defer.h" 1630f712c9SDave Chinner #include "xfs_da_format.h" 1730f712c9SDave Chinner #include "xfs_da_btree.h" 1830f712c9SDave Chinner #include "xfs_dir2.h" 1930f712c9SDave Chinner #include "xfs_inode.h" 2030f712c9SDave Chinner #include "xfs_btree.h" 2130f712c9SDave Chinner #include "xfs_trans.h" 2230f712c9SDave Chinner #include "xfs_inode_item.h" 2330f712c9SDave Chinner #include "xfs_extfree_item.h" 2430f712c9SDave Chinner #include "xfs_alloc.h" 2530f712c9SDave Chinner #include "xfs_bmap.h" 2630f712c9SDave Chinner #include "xfs_bmap_util.h" 2730f712c9SDave Chinner #include "xfs_bmap_btree.h" 2830f712c9SDave Chinner #include "xfs_rtalloc.h" 29e9e899a2SDarrick J. Wong #include "xfs_errortag.h" 3030f712c9SDave Chinner #include "xfs_error.h" 3130f712c9SDave Chinner #include "xfs_quota.h" 3230f712c9SDave Chinner #include "xfs_trans_space.h" 3330f712c9SDave Chinner #include "xfs_buf_item.h" 3430f712c9SDave Chinner #include "xfs_trace.h" 3530f712c9SDave Chinner #include "xfs_symlink.h" 3630f712c9SDave Chinner #include "xfs_attr_leaf.h" 3730f712c9SDave Chinner #include "xfs_filestream.h" 38340785ccSDarrick J. Wong #include "xfs_rmap.h" 393fd129b6SDarrick J. Wong #include "xfs_ag_resv.h" 4062aab20fSDarrick J. Wong #include "xfs_refcount.h" 41974ae922SBrian Foster #include "xfs_icache.h" 4230f712c9SDave Chinner 4330f712c9SDave Chinner 4430f712c9SDave Chinner kmem_zone_t *xfs_bmap_free_item_zone; 4530f712c9SDave Chinner 4630f712c9SDave Chinner /* 4730f712c9SDave Chinner * Miscellaneous helper functions 4830f712c9SDave Chinner */ 4930f712c9SDave Chinner 5030f712c9SDave Chinner /* 5130f712c9SDave Chinner * Compute and fill in the value of the maximum depth of a bmap btree 5230f712c9SDave Chinner * in this filesystem. Done once, during mount. 5330f712c9SDave Chinner */ 5430f712c9SDave Chinner void 5530f712c9SDave Chinner xfs_bmap_compute_maxlevels( 5630f712c9SDave Chinner xfs_mount_t *mp, /* file system mount structure */ 5730f712c9SDave Chinner int whichfork) /* data or attr fork */ 5830f712c9SDave Chinner { 5930f712c9SDave Chinner int level; /* btree level */ 6030f712c9SDave Chinner uint maxblocks; /* max blocks at this level */ 6130f712c9SDave Chinner uint maxleafents; /* max leaf entries possible */ 6230f712c9SDave Chinner int maxrootrecs; /* max records in root block */ 6330f712c9SDave Chinner int minleafrecs; /* min records in leaf block */ 6430f712c9SDave Chinner int minnoderecs; /* min records in node block */ 6530f712c9SDave Chinner int sz; /* root block size */ 6630f712c9SDave Chinner 6730f712c9SDave Chinner /* 6830f712c9SDave Chinner * The maximum number of extents in a file, hence the maximum 6930f712c9SDave Chinner * number of leaf entries, is controlled by the type of di_nextents 7030f712c9SDave Chinner * (a signed 32-bit number, xfs_extnum_t), or by di_anextents 7130f712c9SDave Chinner * (a signed 16-bit number, xfs_aextnum_t). 7230f712c9SDave Chinner * 7330f712c9SDave Chinner * Note that we can no longer assume that if we are in ATTR1 that 7430f712c9SDave Chinner * the fork offset of all the inodes will be 7530f712c9SDave Chinner * (xfs_default_attroffset(ip) >> 3) because we could have mounted 7630f712c9SDave Chinner * with ATTR2 and then mounted back with ATTR1, keeping the 7730f712c9SDave Chinner * di_forkoff's fixed but probably at various positions. Therefore, 7830f712c9SDave Chinner * for both ATTR1 and ATTR2 we have to assume the worst case scenario 7930f712c9SDave Chinner * of a minimum size available. 8030f712c9SDave Chinner */ 8130f712c9SDave Chinner if (whichfork == XFS_DATA_FORK) { 8230f712c9SDave Chinner maxleafents = MAXEXTNUM; 8330f712c9SDave Chinner sz = XFS_BMDR_SPACE_CALC(MINDBTPTRS); 8430f712c9SDave Chinner } else { 8530f712c9SDave Chinner maxleafents = MAXAEXTNUM; 8630f712c9SDave Chinner sz = XFS_BMDR_SPACE_CALC(MINABTPTRS); 8730f712c9SDave Chinner } 8830f712c9SDave Chinner maxrootrecs = xfs_bmdr_maxrecs(sz, 0); 8930f712c9SDave Chinner minleafrecs = mp->m_bmap_dmnr[0]; 9030f712c9SDave Chinner minnoderecs = mp->m_bmap_dmnr[1]; 9130f712c9SDave Chinner maxblocks = (maxleafents + minleafrecs - 1) / minleafrecs; 9230f712c9SDave Chinner for (level = 1; maxblocks > 1; level++) { 9330f712c9SDave Chinner if (maxblocks <= maxrootrecs) 9430f712c9SDave Chinner maxblocks = 1; 9530f712c9SDave Chinner else 9630f712c9SDave Chinner maxblocks = (maxblocks + minnoderecs - 1) / minnoderecs; 9730f712c9SDave Chinner } 9830f712c9SDave Chinner mp->m_bm_maxlevels[whichfork] = level; 9930f712c9SDave Chinner } 10030f712c9SDave Chinner 10130f712c9SDave Chinner STATIC int /* error */ 10230f712c9SDave Chinner xfs_bmbt_lookup_eq( 10330f712c9SDave Chinner struct xfs_btree_cur *cur, 104e16cf9b0SChristoph Hellwig struct xfs_bmbt_irec *irec, 10530f712c9SDave Chinner int *stat) /* success/failure */ 10630f712c9SDave Chinner { 107e16cf9b0SChristoph Hellwig cur->bc_rec.b = *irec; 10830f712c9SDave Chinner return xfs_btree_lookup(cur, XFS_LOOKUP_EQ, stat); 10930f712c9SDave Chinner } 11030f712c9SDave Chinner 11130f712c9SDave Chinner STATIC int /* error */ 112b5cfbc22SChristoph Hellwig xfs_bmbt_lookup_first( 11330f712c9SDave Chinner struct xfs_btree_cur *cur, 11430f712c9SDave Chinner int *stat) /* success/failure */ 11530f712c9SDave Chinner { 116b5cfbc22SChristoph Hellwig cur->bc_rec.b.br_startoff = 0; 117b5cfbc22SChristoph Hellwig cur->bc_rec.b.br_startblock = 0; 118b5cfbc22SChristoph Hellwig cur->bc_rec.b.br_blockcount = 0; 11930f712c9SDave Chinner return xfs_btree_lookup(cur, XFS_LOOKUP_GE, stat); 12030f712c9SDave Chinner } 12130f712c9SDave Chinner 12230f712c9SDave Chinner /* 12330f712c9SDave Chinner * Check if the inode needs to be converted to btree format. 12430f712c9SDave Chinner */ 12530f712c9SDave Chinner static inline bool xfs_bmap_needs_btree(struct xfs_inode *ip, int whichfork) 12630f712c9SDave Chinner { 12760b4984fSDarrick J. Wong return whichfork != XFS_COW_FORK && 12860b4984fSDarrick J. Wong XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_EXTENTS && 12930f712c9SDave Chinner XFS_IFORK_NEXTENTS(ip, whichfork) > 13030f712c9SDave Chinner XFS_IFORK_MAXEXT(ip, whichfork); 13130f712c9SDave Chinner } 13230f712c9SDave Chinner 13330f712c9SDave Chinner /* 13430f712c9SDave Chinner * Check if the inode should be converted to extent format. 13530f712c9SDave Chinner */ 13630f712c9SDave Chinner static inline bool xfs_bmap_wants_extents(struct xfs_inode *ip, int whichfork) 13730f712c9SDave Chinner { 13860b4984fSDarrick J. Wong return whichfork != XFS_COW_FORK && 13960b4984fSDarrick J. Wong XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_BTREE && 14030f712c9SDave Chinner XFS_IFORK_NEXTENTS(ip, whichfork) <= 14130f712c9SDave Chinner XFS_IFORK_MAXEXT(ip, whichfork); 14230f712c9SDave Chinner } 14330f712c9SDave Chinner 14430f712c9SDave Chinner /* 145a67d00a5SChristoph Hellwig * Update the record referred to by cur to the value given by irec 14630f712c9SDave Chinner * This either works (return 0) or gets an EFSCORRUPTED error. 14730f712c9SDave Chinner */ 14830f712c9SDave Chinner STATIC int 14930f712c9SDave Chinner xfs_bmbt_update( 15030f712c9SDave Chinner struct xfs_btree_cur *cur, 151a67d00a5SChristoph Hellwig struct xfs_bmbt_irec *irec) 15230f712c9SDave Chinner { 15330f712c9SDave Chinner union xfs_btree_rec rec; 15430f712c9SDave Chinner 155a67d00a5SChristoph Hellwig xfs_bmbt_disk_set_all(&rec.bmbt, irec); 15630f712c9SDave Chinner return xfs_btree_update(cur, &rec); 15730f712c9SDave Chinner } 15830f712c9SDave Chinner 15930f712c9SDave Chinner /* 16030f712c9SDave Chinner * Compute the worst-case number of indirect blocks that will be used 16130f712c9SDave Chinner * for ip's delayed extent of length "len". 16230f712c9SDave Chinner */ 16330f712c9SDave Chinner STATIC xfs_filblks_t 16430f712c9SDave Chinner xfs_bmap_worst_indlen( 16530f712c9SDave Chinner xfs_inode_t *ip, /* incore inode pointer */ 16630f712c9SDave Chinner xfs_filblks_t len) /* delayed extent length */ 16730f712c9SDave Chinner { 16830f712c9SDave Chinner int level; /* btree level number */ 16930f712c9SDave Chinner int maxrecs; /* maximum record count at this level */ 17030f712c9SDave Chinner xfs_mount_t *mp; /* mount structure */ 17130f712c9SDave Chinner xfs_filblks_t rval; /* return value */ 17230f712c9SDave Chinner 17330f712c9SDave Chinner mp = ip->i_mount; 17430f712c9SDave Chinner maxrecs = mp->m_bmap_dmxr[0]; 17530f712c9SDave Chinner for (level = 0, rval = 0; 17630f712c9SDave Chinner level < XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK); 17730f712c9SDave Chinner level++) { 17830f712c9SDave Chinner len += maxrecs - 1; 17930f712c9SDave Chinner do_div(len, maxrecs); 18030f712c9SDave Chinner rval += len; 1815e5c943cSDarrick J. Wong if (len == 1) 1825e5c943cSDarrick J. Wong return rval + XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK) - 18330f712c9SDave Chinner level - 1; 18430f712c9SDave Chinner if (level == 0) 18530f712c9SDave Chinner maxrecs = mp->m_bmap_dmxr[1]; 18630f712c9SDave Chinner } 18730f712c9SDave Chinner return rval; 18830f712c9SDave Chinner } 18930f712c9SDave Chinner 19030f712c9SDave Chinner /* 19130f712c9SDave Chinner * Calculate the default attribute fork offset for newly created inodes. 19230f712c9SDave Chinner */ 19330f712c9SDave Chinner uint 19430f712c9SDave Chinner xfs_default_attroffset( 19530f712c9SDave Chinner struct xfs_inode *ip) 19630f712c9SDave Chinner { 19730f712c9SDave Chinner struct xfs_mount *mp = ip->i_mount; 19830f712c9SDave Chinner uint offset; 19930f712c9SDave Chinner 20030f712c9SDave Chinner if (mp->m_sb.sb_inodesize == 256) { 20130f712c9SDave Chinner offset = XFS_LITINO(mp, ip->i_d.di_version) - 20230f712c9SDave Chinner XFS_BMDR_SPACE_CALC(MINABTPTRS); 20330f712c9SDave Chinner } else { 20430f712c9SDave Chinner offset = XFS_BMDR_SPACE_CALC(6 * MINABTPTRS); 20530f712c9SDave Chinner } 20630f712c9SDave Chinner 20730f712c9SDave Chinner ASSERT(offset < XFS_LITINO(mp, ip->i_d.di_version)); 20830f712c9SDave Chinner return offset; 20930f712c9SDave Chinner } 21030f712c9SDave Chinner 21130f712c9SDave Chinner /* 21230f712c9SDave Chinner * Helper routine to reset inode di_forkoff field when switching 21330f712c9SDave Chinner * attribute fork from local to extent format - we reset it where 21430f712c9SDave Chinner * possible to make space available for inline data fork extents. 21530f712c9SDave Chinner */ 21630f712c9SDave Chinner STATIC void 21730f712c9SDave Chinner xfs_bmap_forkoff_reset( 21830f712c9SDave Chinner xfs_inode_t *ip, 21930f712c9SDave Chinner int whichfork) 22030f712c9SDave Chinner { 22130f712c9SDave Chinner if (whichfork == XFS_ATTR_FORK && 22230f712c9SDave Chinner ip->i_d.di_format != XFS_DINODE_FMT_DEV && 22330f712c9SDave Chinner ip->i_d.di_format != XFS_DINODE_FMT_BTREE) { 22430f712c9SDave Chinner uint dfl_forkoff = xfs_default_attroffset(ip) >> 3; 22530f712c9SDave Chinner 22630f712c9SDave Chinner if (dfl_forkoff > ip->i_d.di_forkoff) 22730f712c9SDave Chinner ip->i_d.di_forkoff = dfl_forkoff; 22830f712c9SDave Chinner } 22930f712c9SDave Chinner } 23030f712c9SDave Chinner 23130f712c9SDave Chinner #ifdef DEBUG 23230f712c9SDave Chinner STATIC struct xfs_buf * 23330f712c9SDave Chinner xfs_bmap_get_bp( 23430f712c9SDave Chinner struct xfs_btree_cur *cur, 23530f712c9SDave Chinner xfs_fsblock_t bno) 23630f712c9SDave Chinner { 237e6631f85SDave Chinner struct xfs_log_item *lip; 23830f712c9SDave Chinner int i; 23930f712c9SDave Chinner 24030f712c9SDave Chinner if (!cur) 24130f712c9SDave Chinner return NULL; 24230f712c9SDave Chinner 24330f712c9SDave Chinner for (i = 0; i < XFS_BTREE_MAXLEVELS; i++) { 24430f712c9SDave Chinner if (!cur->bc_bufs[i]) 24530f712c9SDave Chinner break; 24630f712c9SDave Chinner if (XFS_BUF_ADDR(cur->bc_bufs[i]) == bno) 24730f712c9SDave Chinner return cur->bc_bufs[i]; 24830f712c9SDave Chinner } 24930f712c9SDave Chinner 25030f712c9SDave Chinner /* Chase down all the log items to see if the bp is there */ 251e6631f85SDave Chinner list_for_each_entry(lip, &cur->bc_tp->t_items, li_trans) { 252e6631f85SDave Chinner struct xfs_buf_log_item *bip = (struct xfs_buf_log_item *)lip; 253e6631f85SDave Chinner 25430f712c9SDave Chinner if (bip->bli_item.li_type == XFS_LI_BUF && 25530f712c9SDave Chinner XFS_BUF_ADDR(bip->bli_buf) == bno) 25630f712c9SDave Chinner return bip->bli_buf; 25730f712c9SDave Chinner } 25830f712c9SDave Chinner 25930f712c9SDave Chinner return NULL; 26030f712c9SDave Chinner } 26130f712c9SDave Chinner 26230f712c9SDave Chinner STATIC void 26330f712c9SDave Chinner xfs_check_block( 26430f712c9SDave Chinner struct xfs_btree_block *block, 26530f712c9SDave Chinner xfs_mount_t *mp, 26630f712c9SDave Chinner int root, 26730f712c9SDave Chinner short sz) 26830f712c9SDave Chinner { 26930f712c9SDave Chinner int i, j, dmxr; 27030f712c9SDave Chinner __be64 *pp, *thispa; /* pointer to block address */ 27130f712c9SDave Chinner xfs_bmbt_key_t *prevp, *keyp; 27230f712c9SDave Chinner 27330f712c9SDave Chinner ASSERT(be16_to_cpu(block->bb_level) > 0); 27430f712c9SDave Chinner 27530f712c9SDave Chinner prevp = NULL; 27630f712c9SDave Chinner for( i = 1; i <= xfs_btree_get_numrecs(block); i++) { 27730f712c9SDave Chinner dmxr = mp->m_bmap_dmxr[0]; 27830f712c9SDave Chinner keyp = XFS_BMBT_KEY_ADDR(mp, block, i); 27930f712c9SDave Chinner 28030f712c9SDave Chinner if (prevp) { 28130f712c9SDave Chinner ASSERT(be64_to_cpu(prevp->br_startoff) < 28230f712c9SDave Chinner be64_to_cpu(keyp->br_startoff)); 28330f712c9SDave Chinner } 28430f712c9SDave Chinner prevp = keyp; 28530f712c9SDave Chinner 28630f712c9SDave Chinner /* 28730f712c9SDave Chinner * Compare the block numbers to see if there are dups. 28830f712c9SDave Chinner */ 28930f712c9SDave Chinner if (root) 29030f712c9SDave Chinner pp = XFS_BMAP_BROOT_PTR_ADDR(mp, block, i, sz); 29130f712c9SDave Chinner else 29230f712c9SDave Chinner pp = XFS_BMBT_PTR_ADDR(mp, block, i, dmxr); 29330f712c9SDave Chinner 29430f712c9SDave Chinner for (j = i+1; j <= be16_to_cpu(block->bb_numrecs); j++) { 29530f712c9SDave Chinner if (root) 29630f712c9SDave Chinner thispa = XFS_BMAP_BROOT_PTR_ADDR(mp, block, j, sz); 29730f712c9SDave Chinner else 29830f712c9SDave Chinner thispa = XFS_BMBT_PTR_ADDR(mp, block, j, dmxr); 29930f712c9SDave Chinner if (*thispa == *pp) { 30030f712c9SDave Chinner xfs_warn(mp, "%s: thispa(%d) == pp(%d) %Ld", 30130f712c9SDave Chinner __func__, j, i, 30230f712c9SDave Chinner (unsigned long long)be64_to_cpu(*thispa)); 303cec57256SDarrick J. Wong xfs_err(mp, "%s: ptrs are equal in node\n", 30430f712c9SDave Chinner __func__); 305cec57256SDarrick J. Wong xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE); 30630f712c9SDave Chinner } 30730f712c9SDave Chinner } 30830f712c9SDave Chinner } 30930f712c9SDave Chinner } 31030f712c9SDave Chinner 31130f712c9SDave Chinner /* 31230f712c9SDave Chinner * Check that the extents for the inode ip are in the right order in all 313e3543819SDave Chinner * btree leaves. THis becomes prohibitively expensive for large extent count 314e3543819SDave Chinner * files, so don't bother with inodes that have more than 10,000 extents in 315e3543819SDave Chinner * them. The btree record ordering checks will still be done, so for such large 316e3543819SDave Chinner * bmapbt constructs that is going to catch most corruptions. 31730f712c9SDave Chinner */ 31830f712c9SDave Chinner STATIC void 31930f712c9SDave Chinner xfs_bmap_check_leaf_extents( 32030f712c9SDave Chinner xfs_btree_cur_t *cur, /* btree cursor or null */ 32130f712c9SDave Chinner xfs_inode_t *ip, /* incore inode pointer */ 32230f712c9SDave Chinner int whichfork) /* data or attr fork */ 32330f712c9SDave Chinner { 32430f712c9SDave Chinner struct xfs_btree_block *block; /* current btree block */ 32530f712c9SDave Chinner xfs_fsblock_t bno; /* block # of "block" */ 32630f712c9SDave Chinner xfs_buf_t *bp; /* buffer for "block" */ 32730f712c9SDave Chinner int error; /* error return value */ 32830f712c9SDave Chinner xfs_extnum_t i=0, j; /* index into the extents list */ 32930f712c9SDave Chinner xfs_ifork_t *ifp; /* fork structure */ 33030f712c9SDave Chinner int level; /* btree level, for checking */ 33130f712c9SDave Chinner xfs_mount_t *mp; /* file system mount structure */ 33230f712c9SDave Chinner __be64 *pp; /* pointer to block address */ 33330f712c9SDave Chinner xfs_bmbt_rec_t *ep; /* pointer to current extent */ 33430f712c9SDave Chinner xfs_bmbt_rec_t last = {0, 0}; /* last extent in prev block */ 33530f712c9SDave Chinner xfs_bmbt_rec_t *nextp; /* pointer to next extent */ 33630f712c9SDave Chinner int bp_release = 0; 33730f712c9SDave Chinner 33830f712c9SDave Chinner if (XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE) { 33930f712c9SDave Chinner return; 34030f712c9SDave Chinner } 34130f712c9SDave Chinner 342e3543819SDave Chinner /* skip large extent count inodes */ 343e3543819SDave Chinner if (ip->i_d.di_nextents > 10000) 344e3543819SDave Chinner return; 345e3543819SDave Chinner 34630f712c9SDave Chinner bno = NULLFSBLOCK; 34730f712c9SDave Chinner mp = ip->i_mount; 34830f712c9SDave Chinner ifp = XFS_IFORK_PTR(ip, whichfork); 34930f712c9SDave Chinner block = ifp->if_broot; 35030f712c9SDave Chinner /* 35130f712c9SDave Chinner * Root level must use BMAP_BROOT_PTR_ADDR macro to get ptr out. 35230f712c9SDave Chinner */ 35330f712c9SDave Chinner level = be16_to_cpu(block->bb_level); 35430f712c9SDave Chinner ASSERT(level > 0); 35530f712c9SDave Chinner xfs_check_block(block, mp, 1, ifp->if_broot_bytes); 35630f712c9SDave Chinner pp = XFS_BMAP_BROOT_PTR_ADDR(mp, block, 1, ifp->if_broot_bytes); 35730f712c9SDave Chinner bno = be64_to_cpu(*pp); 35830f712c9SDave Chinner 359d5cf09baSChristoph Hellwig ASSERT(bno != NULLFSBLOCK); 36030f712c9SDave Chinner ASSERT(XFS_FSB_TO_AGNO(mp, bno) < mp->m_sb.sb_agcount); 36130f712c9SDave Chinner ASSERT(XFS_FSB_TO_AGBNO(mp, bno) < mp->m_sb.sb_agblocks); 36230f712c9SDave Chinner 36330f712c9SDave Chinner /* 36430f712c9SDave Chinner * Go down the tree until leaf level is reached, following the first 36530f712c9SDave Chinner * pointer (leftmost) at each level. 36630f712c9SDave Chinner */ 36730f712c9SDave Chinner while (level-- > 0) { 36830f712c9SDave Chinner /* See if buf is in cur first */ 36930f712c9SDave Chinner bp_release = 0; 37030f712c9SDave Chinner bp = xfs_bmap_get_bp(cur, XFS_FSB_TO_DADDR(mp, bno)); 37130f712c9SDave Chinner if (!bp) { 37230f712c9SDave Chinner bp_release = 1; 37330f712c9SDave Chinner error = xfs_btree_read_bufl(mp, NULL, bno, 0, &bp, 37430f712c9SDave Chinner XFS_BMAP_BTREE_REF, 37530f712c9SDave Chinner &xfs_bmbt_buf_ops); 37630f712c9SDave Chinner if (error) 37730f712c9SDave Chinner goto error_norelse; 37830f712c9SDave Chinner } 37930f712c9SDave Chinner block = XFS_BUF_TO_BLOCK(bp); 38030f712c9SDave Chinner if (level == 0) 38130f712c9SDave Chinner break; 38230f712c9SDave Chinner 38330f712c9SDave Chinner /* 38430f712c9SDave Chinner * Check this block for basic sanity (increasing keys and 38530f712c9SDave Chinner * no duplicate blocks). 38630f712c9SDave Chinner */ 38730f712c9SDave Chinner 38830f712c9SDave Chinner xfs_check_block(block, mp, 0, 0); 38930f712c9SDave Chinner pp = XFS_BMBT_PTR_ADDR(mp, block, 1, mp->m_bmap_dmxr[1]); 39030f712c9SDave Chinner bno = be64_to_cpu(*pp); 391c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, 39259f6fec3SDarrick J. Wong xfs_verify_fsbno(mp, bno), error0); 39330f712c9SDave Chinner if (bp_release) { 39430f712c9SDave Chinner bp_release = 0; 39530f712c9SDave Chinner xfs_trans_brelse(NULL, bp); 39630f712c9SDave Chinner } 39730f712c9SDave Chinner } 39830f712c9SDave Chinner 39930f712c9SDave Chinner /* 40030f712c9SDave Chinner * Here with bp and block set to the leftmost leaf node in the tree. 40130f712c9SDave Chinner */ 40230f712c9SDave Chinner i = 0; 40330f712c9SDave Chinner 40430f712c9SDave Chinner /* 40530f712c9SDave Chinner * Loop over all leaf nodes checking that all extents are in the right order. 40630f712c9SDave Chinner */ 40730f712c9SDave Chinner for (;;) { 40830f712c9SDave Chinner xfs_fsblock_t nextbno; 40930f712c9SDave Chinner xfs_extnum_t num_recs; 41030f712c9SDave Chinner 41130f712c9SDave Chinner 41230f712c9SDave Chinner num_recs = xfs_btree_get_numrecs(block); 41330f712c9SDave Chinner 41430f712c9SDave Chinner /* 41530f712c9SDave Chinner * Read-ahead the next leaf block, if any. 41630f712c9SDave Chinner */ 41730f712c9SDave Chinner 41830f712c9SDave Chinner nextbno = be64_to_cpu(block->bb_u.l.bb_rightsib); 41930f712c9SDave Chinner 42030f712c9SDave Chinner /* 42130f712c9SDave Chinner * Check all the extents to make sure they are OK. 42230f712c9SDave Chinner * If we had a previous block, the last entry should 42330f712c9SDave Chinner * conform with the first entry in this one. 42430f712c9SDave Chinner */ 42530f712c9SDave Chinner 42630f712c9SDave Chinner ep = XFS_BMBT_REC_ADDR(mp, block, 1); 42730f712c9SDave Chinner if (i) { 42830f712c9SDave Chinner ASSERT(xfs_bmbt_disk_get_startoff(&last) + 42930f712c9SDave Chinner xfs_bmbt_disk_get_blockcount(&last) <= 43030f712c9SDave Chinner xfs_bmbt_disk_get_startoff(ep)); 43130f712c9SDave Chinner } 43230f712c9SDave Chinner for (j = 1; j < num_recs; j++) { 43330f712c9SDave Chinner nextp = XFS_BMBT_REC_ADDR(mp, block, j + 1); 43430f712c9SDave Chinner ASSERT(xfs_bmbt_disk_get_startoff(ep) + 43530f712c9SDave Chinner xfs_bmbt_disk_get_blockcount(ep) <= 43630f712c9SDave Chinner xfs_bmbt_disk_get_startoff(nextp)); 43730f712c9SDave Chinner ep = nextp; 43830f712c9SDave Chinner } 43930f712c9SDave Chinner 44030f712c9SDave Chinner last = *ep; 44130f712c9SDave Chinner i += num_recs; 44230f712c9SDave Chinner if (bp_release) { 44330f712c9SDave Chinner bp_release = 0; 44430f712c9SDave Chinner xfs_trans_brelse(NULL, bp); 44530f712c9SDave Chinner } 44630f712c9SDave Chinner bno = nextbno; 44730f712c9SDave Chinner /* 44830f712c9SDave Chinner * If we've reached the end, stop. 44930f712c9SDave Chinner */ 45030f712c9SDave Chinner if (bno == NULLFSBLOCK) 45130f712c9SDave Chinner break; 45230f712c9SDave Chinner 45330f712c9SDave Chinner bp_release = 0; 45430f712c9SDave Chinner bp = xfs_bmap_get_bp(cur, XFS_FSB_TO_DADDR(mp, bno)); 45530f712c9SDave Chinner if (!bp) { 45630f712c9SDave Chinner bp_release = 1; 45730f712c9SDave Chinner error = xfs_btree_read_bufl(mp, NULL, bno, 0, &bp, 45830f712c9SDave Chinner XFS_BMAP_BTREE_REF, 45930f712c9SDave Chinner &xfs_bmbt_buf_ops); 46030f712c9SDave Chinner if (error) 46130f712c9SDave Chinner goto error_norelse; 46230f712c9SDave Chinner } 46330f712c9SDave Chinner block = XFS_BUF_TO_BLOCK(bp); 46430f712c9SDave Chinner } 465a5fd276bSLuis de Bethencourt 46630f712c9SDave Chinner return; 46730f712c9SDave Chinner 46830f712c9SDave Chinner error0: 46930f712c9SDave Chinner xfs_warn(mp, "%s: at error0", __func__); 47030f712c9SDave Chinner if (bp_release) 47130f712c9SDave Chinner xfs_trans_brelse(NULL, bp); 47230f712c9SDave Chinner error_norelse: 47330f712c9SDave Chinner xfs_warn(mp, "%s: BAD after btree leaves for %d extents", 47430f712c9SDave Chinner __func__, i); 475cec57256SDarrick J. Wong xfs_err(mp, "%s: CORRUPTED BTREE OR SOMETHING", __func__); 476cec57256SDarrick J. Wong xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE); 47730f712c9SDave Chinner return; 47830f712c9SDave Chinner } 47930f712c9SDave Chinner 48030f712c9SDave Chinner /* 48130f712c9SDave Chinner * Validate that the bmbt_irecs being returned from bmapi are valid 48230f712c9SDave Chinner * given the caller's original parameters. Specifically check the 48330f712c9SDave Chinner * ranges of the returned irecs to ensure that they only extend beyond 48430f712c9SDave Chinner * the given parameters if the XFS_BMAPI_ENTIRE flag was set. 48530f712c9SDave Chinner */ 48630f712c9SDave Chinner STATIC void 48730f712c9SDave Chinner xfs_bmap_validate_ret( 48830f712c9SDave Chinner xfs_fileoff_t bno, 48930f712c9SDave Chinner xfs_filblks_t len, 49030f712c9SDave Chinner int flags, 49130f712c9SDave Chinner xfs_bmbt_irec_t *mval, 49230f712c9SDave Chinner int nmap, 49330f712c9SDave Chinner int ret_nmap) 49430f712c9SDave Chinner { 49530f712c9SDave Chinner int i; /* index to map values */ 49630f712c9SDave Chinner 49730f712c9SDave Chinner ASSERT(ret_nmap <= nmap); 49830f712c9SDave Chinner 49930f712c9SDave Chinner for (i = 0; i < ret_nmap; i++) { 50030f712c9SDave Chinner ASSERT(mval[i].br_blockcount > 0); 50130f712c9SDave Chinner if (!(flags & XFS_BMAPI_ENTIRE)) { 50230f712c9SDave Chinner ASSERT(mval[i].br_startoff >= bno); 50330f712c9SDave Chinner ASSERT(mval[i].br_blockcount <= len); 50430f712c9SDave Chinner ASSERT(mval[i].br_startoff + mval[i].br_blockcount <= 50530f712c9SDave Chinner bno + len); 50630f712c9SDave Chinner } else { 50730f712c9SDave Chinner ASSERT(mval[i].br_startoff < bno + len); 50830f712c9SDave Chinner ASSERT(mval[i].br_startoff + mval[i].br_blockcount > 50930f712c9SDave Chinner bno); 51030f712c9SDave Chinner } 51130f712c9SDave Chinner ASSERT(i == 0 || 51230f712c9SDave Chinner mval[i - 1].br_startoff + mval[i - 1].br_blockcount == 51330f712c9SDave Chinner mval[i].br_startoff); 51430f712c9SDave Chinner ASSERT(mval[i].br_startblock != DELAYSTARTBLOCK && 51530f712c9SDave Chinner mval[i].br_startblock != HOLESTARTBLOCK); 51630f712c9SDave Chinner ASSERT(mval[i].br_state == XFS_EXT_NORM || 51730f712c9SDave Chinner mval[i].br_state == XFS_EXT_UNWRITTEN); 51830f712c9SDave Chinner } 51930f712c9SDave Chinner } 52030f712c9SDave Chinner 52130f712c9SDave Chinner #else 52230f712c9SDave Chinner #define xfs_bmap_check_leaf_extents(cur, ip, whichfork) do { } while (0) 5237bf7a193SDarrick J. Wong #define xfs_bmap_validate_ret(bno,len,flags,mval,onmap,nmap) do { } while (0) 52430f712c9SDave Chinner #endif /* DEBUG */ 52530f712c9SDave Chinner 52630f712c9SDave Chinner /* 52730f712c9SDave Chinner * bmap free list manipulation functions 52830f712c9SDave Chinner */ 52930f712c9SDave Chinner 53030f712c9SDave Chinner /* 53130f712c9SDave Chinner * Add the extent to the list of extents to be free at transaction end. 53230f712c9SDave Chinner * The list is maintained sorted (by block number). 53330f712c9SDave Chinner */ 53430f712c9SDave Chinner void 535fcb762f5SBrian Foster __xfs_bmap_add_free( 536340785ccSDarrick J. Wong struct xfs_mount *mp, 537340785ccSDarrick J. Wong struct xfs_defer_ops *dfops, 538340785ccSDarrick J. Wong xfs_fsblock_t bno, 539340785ccSDarrick J. Wong xfs_filblks_t len, 540fcb762f5SBrian Foster struct xfs_owner_info *oinfo, 541fcb762f5SBrian Foster bool skip_discard) 54230f712c9SDave Chinner { 543310a75a3SDarrick J. Wong struct xfs_extent_free_item *new; /* new element */ 54430f712c9SDave Chinner #ifdef DEBUG 54530f712c9SDave Chinner xfs_agnumber_t agno; 54630f712c9SDave Chinner xfs_agblock_t agbno; 54730f712c9SDave Chinner 54830f712c9SDave Chinner ASSERT(bno != NULLFSBLOCK); 54930f712c9SDave Chinner ASSERT(len > 0); 55030f712c9SDave Chinner ASSERT(len <= MAXEXTLEN); 55130f712c9SDave Chinner ASSERT(!isnullstartblock(bno)); 55230f712c9SDave Chinner agno = XFS_FSB_TO_AGNO(mp, bno); 55330f712c9SDave Chinner agbno = XFS_FSB_TO_AGBNO(mp, bno); 55430f712c9SDave Chinner ASSERT(agno < mp->m_sb.sb_agcount); 55530f712c9SDave Chinner ASSERT(agbno < mp->m_sb.sb_agblocks); 55630f712c9SDave Chinner ASSERT(len < mp->m_sb.sb_agblocks); 55730f712c9SDave Chinner ASSERT(agbno + len <= mp->m_sb.sb_agblocks); 55830f712c9SDave Chinner #endif 55930f712c9SDave Chinner ASSERT(xfs_bmap_free_item_zone != NULL); 560340785ccSDarrick J. Wong 56130f712c9SDave Chinner new = kmem_zone_alloc(xfs_bmap_free_item_zone, KM_SLEEP); 562310a75a3SDarrick J. Wong new->xefi_startblock = bno; 563310a75a3SDarrick J. Wong new->xefi_blockcount = (xfs_extlen_t)len; 564340785ccSDarrick J. Wong if (oinfo) 565340785ccSDarrick J. Wong new->xefi_oinfo = *oinfo; 566340785ccSDarrick J. Wong else 567340785ccSDarrick J. Wong xfs_rmap_skip_owner_update(&new->xefi_oinfo); 568fcb762f5SBrian Foster new->xefi_skip_discard = skip_discard; 569ba9e7802SDarrick J. Wong trace_xfs_bmap_free_defer(mp, XFS_FSB_TO_AGNO(mp, bno), 0, 570ba9e7802SDarrick J. Wong XFS_FSB_TO_AGBNO(mp, bno), len); 5712c3234d1SDarrick J. Wong xfs_defer_add(dfops, XFS_DEFER_OPS_TYPE_FREE, &new->xefi_list); 57230f712c9SDave Chinner } 57330f712c9SDave Chinner 57430f712c9SDave Chinner /* 57530f712c9SDave Chinner * Inode fork format manipulation functions 57630f712c9SDave Chinner */ 57730f712c9SDave Chinner 57830f712c9SDave Chinner /* 57930f712c9SDave Chinner * Transform a btree format file with only one leaf node, where the 58030f712c9SDave Chinner * extents list will fit in the inode, into an extents format file. 58130f712c9SDave Chinner * Since the file extents are already in-core, all we have to do is 58230f712c9SDave Chinner * give up the space for the btree root and pitch the leaf block. 58330f712c9SDave Chinner */ 58430f712c9SDave Chinner STATIC int /* error */ 58530f712c9SDave Chinner xfs_bmap_btree_to_extents( 58630f712c9SDave Chinner xfs_trans_t *tp, /* transaction pointer */ 58730f712c9SDave Chinner xfs_inode_t *ip, /* incore inode pointer */ 58830f712c9SDave Chinner xfs_btree_cur_t *cur, /* btree cursor */ 58930f712c9SDave Chinner int *logflagsp, /* inode logging flags */ 59030f712c9SDave Chinner int whichfork) /* data or attr fork */ 59130f712c9SDave Chinner { 59230f712c9SDave Chinner /* REFERENCED */ 59330f712c9SDave Chinner struct xfs_btree_block *cblock;/* child btree block */ 59430f712c9SDave Chinner xfs_fsblock_t cbno; /* child block number */ 59530f712c9SDave Chinner xfs_buf_t *cbp; /* child block's buffer */ 59630f712c9SDave Chinner int error; /* error return value */ 59730f712c9SDave Chinner xfs_ifork_t *ifp; /* inode fork data */ 59830f712c9SDave Chinner xfs_mount_t *mp; /* mount point structure */ 59930f712c9SDave Chinner __be64 *pp; /* ptr to block address */ 60030f712c9SDave Chinner struct xfs_btree_block *rblock;/* root btree block */ 601340785ccSDarrick J. Wong struct xfs_owner_info oinfo; 60230f712c9SDave Chinner 60330f712c9SDave Chinner mp = ip->i_mount; 60430f712c9SDave Chinner ifp = XFS_IFORK_PTR(ip, whichfork); 60560b4984fSDarrick J. Wong ASSERT(whichfork != XFS_COW_FORK); 60630f712c9SDave Chinner ASSERT(ifp->if_flags & XFS_IFEXTENTS); 60730f712c9SDave Chinner ASSERT(XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_BTREE); 60830f712c9SDave Chinner rblock = ifp->if_broot; 60930f712c9SDave Chinner ASSERT(be16_to_cpu(rblock->bb_level) == 1); 61030f712c9SDave Chinner ASSERT(be16_to_cpu(rblock->bb_numrecs) == 1); 61130f712c9SDave Chinner ASSERT(xfs_bmbt_maxrecs(mp, ifp->if_broot_bytes, 0) == 1); 61230f712c9SDave Chinner pp = XFS_BMAP_BROOT_PTR_ADDR(mp, rblock, 1, ifp->if_broot_bytes); 61330f712c9SDave Chinner cbno = be64_to_cpu(*pp); 61430f712c9SDave Chinner *logflagsp = 0; 61530f712c9SDave Chinner #ifdef DEBUG 616f135761aSDarrick J. Wong XFS_WANT_CORRUPTED_RETURN(cur->bc_mp, 617f135761aSDarrick J. Wong xfs_btree_check_lptr(cur, cbno, 1)); 61830f712c9SDave Chinner #endif 61930f712c9SDave Chinner error = xfs_btree_read_bufl(mp, tp, cbno, 0, &cbp, XFS_BMAP_BTREE_REF, 62030f712c9SDave Chinner &xfs_bmbt_buf_ops); 62130f712c9SDave Chinner if (error) 62230f712c9SDave Chinner return error; 62330f712c9SDave Chinner cblock = XFS_BUF_TO_BLOCK(cbp); 62430f712c9SDave Chinner if ((error = xfs_btree_check_block(cur, cblock, 0, cbp))) 62530f712c9SDave Chinner return error; 626340785ccSDarrick J. Wong xfs_rmap_ino_bmbt_owner(&oinfo, ip->i_ino, whichfork); 62742b394a9SBrian Foster xfs_bmap_add_free(mp, cur->bc_tp->t_dfops, cbno, 1, &oinfo); 62830f712c9SDave Chinner ip->i_d.di_nblocks--; 62930f712c9SDave Chinner xfs_trans_mod_dquot_byino(tp, ip, XFS_TRANS_DQ_BCOUNT, -1L); 63030f712c9SDave Chinner xfs_trans_binval(tp, cbp); 63130f712c9SDave Chinner if (cur->bc_bufs[0] == cbp) 63230f712c9SDave Chinner cur->bc_bufs[0] = NULL; 63330f712c9SDave Chinner xfs_iroot_realloc(ip, -1, whichfork); 63430f712c9SDave Chinner ASSERT(ifp->if_broot == NULL); 63530f712c9SDave Chinner ASSERT((ifp->if_flags & XFS_IFBROOT) == 0); 63630f712c9SDave Chinner XFS_IFORK_FMT_SET(ip, whichfork, XFS_DINODE_FMT_EXTENTS); 63730f712c9SDave Chinner *logflagsp = XFS_ILOG_CORE | xfs_ilog_fext(whichfork); 63830f712c9SDave Chinner return 0; 63930f712c9SDave Chinner } 64030f712c9SDave Chinner 64130f712c9SDave Chinner /* 64230f712c9SDave Chinner * Convert an extents-format file into a btree-format file. 64330f712c9SDave Chinner * The new file will have a root block (in the inode) and a single child block. 64430f712c9SDave Chinner */ 64530f712c9SDave Chinner STATIC int /* error */ 64630f712c9SDave Chinner xfs_bmap_extents_to_btree( 64781ba8f3eSBrian Foster struct xfs_trans *tp, /* transaction pointer */ 64881ba8f3eSBrian Foster struct xfs_inode *ip, /* incore inode pointer */ 64981ba8f3eSBrian Foster struct xfs_btree_cur **curp, /* cursor returned to caller */ 65030f712c9SDave Chinner int wasdel, /* converting a delayed alloc */ 65130f712c9SDave Chinner int *logflagsp, /* inode logging flags */ 65230f712c9SDave Chinner int whichfork) /* data or attr fork */ 65330f712c9SDave Chinner { 65430f712c9SDave Chinner struct xfs_btree_block *ablock; /* allocated (child) bt block */ 65581ba8f3eSBrian Foster struct xfs_buf *abp; /* buffer for ablock */ 65681ba8f3eSBrian Foster struct xfs_alloc_arg args; /* allocation arguments */ 65781ba8f3eSBrian Foster struct xfs_bmbt_rec *arp; /* child record pointer */ 65830f712c9SDave Chinner struct xfs_btree_block *block; /* btree root block */ 65981ba8f3eSBrian Foster struct xfs_btree_cur *cur; /* bmap btree cursor */ 66030f712c9SDave Chinner int error; /* error return value */ 66181ba8f3eSBrian Foster struct xfs_ifork *ifp; /* inode fork pointer */ 66281ba8f3eSBrian Foster struct xfs_bmbt_key *kp; /* root block key pointer */ 66381ba8f3eSBrian Foster struct xfs_mount *mp; /* mount structure */ 66430f712c9SDave Chinner xfs_bmbt_ptr_t *pp; /* root block address pointer */ 665b2b1712aSChristoph Hellwig struct xfs_iext_cursor icur; 666906abed5SChristoph Hellwig struct xfs_bmbt_irec rec; 667b2b1712aSChristoph Hellwig xfs_extnum_t cnt = 0; 66830f712c9SDave Chinner 66930f712c9SDave Chinner mp = ip->i_mount; 67060b4984fSDarrick J. Wong ASSERT(whichfork != XFS_COW_FORK); 67130f712c9SDave Chinner ifp = XFS_IFORK_PTR(ip, whichfork); 67230f712c9SDave Chinner ASSERT(XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_EXTENTS); 67330f712c9SDave Chinner 67430f712c9SDave Chinner /* 67530f712c9SDave Chinner * Make space in the inode incore. 67630f712c9SDave Chinner */ 67730f712c9SDave Chinner xfs_iroot_realloc(ip, 1, whichfork); 67830f712c9SDave Chinner ifp->if_flags |= XFS_IFBROOT; 67930f712c9SDave Chinner 68030f712c9SDave Chinner /* 68130f712c9SDave Chinner * Fill in the root. 68230f712c9SDave Chinner */ 68330f712c9SDave Chinner block = ifp->if_broot; 68430f712c9SDave Chinner xfs_btree_init_block_int(mp, block, XFS_BUF_DADDR_NULL, 685b6f41e44SEric Sandeen XFS_BTNUM_BMAP, 1, 1, ip->i_ino, 686f88ae46bSEric Sandeen XFS_BTREE_LONG_PTRS); 68730f712c9SDave Chinner /* 68830f712c9SDave Chinner * Need a cursor. Can't allocate until bb_level is filled in. 68930f712c9SDave Chinner */ 69030f712c9SDave Chinner cur = xfs_bmbt_init_cursor(mp, tp, ip, whichfork); 69130f712c9SDave Chinner cur->bc_private.b.flags = wasdel ? XFS_BTCUR_BPRV_WASDEL : 0; 69230f712c9SDave Chinner /* 69330f712c9SDave Chinner * Convert to a btree with two levels, one record in root. 69430f712c9SDave Chinner */ 69530f712c9SDave Chinner XFS_IFORK_FMT_SET(ip, whichfork, XFS_DINODE_FMT_BTREE); 69630f712c9SDave Chinner memset(&args, 0, sizeof(args)); 69730f712c9SDave Chinner args.tp = tp; 69830f712c9SDave Chinner args.mp = mp; 699340785ccSDarrick J. Wong xfs_rmap_ino_bmbt_owner(&args.oinfo, ip->i_ino, whichfork); 700280253d2SBrian Foster if (tp->t_firstblock == NULLFSBLOCK) { 70130f712c9SDave Chinner args.type = XFS_ALLOCTYPE_START_BNO; 70230f712c9SDave Chinner args.fsbno = XFS_INO_TO_FSB(mp, ip->i_ino); 70381ba8f3eSBrian Foster } else if (tp->t_dfops->dop_low) { 70430f712c9SDave Chinner args.type = XFS_ALLOCTYPE_START_BNO; 705280253d2SBrian Foster args.fsbno = tp->t_firstblock; 70630f712c9SDave Chinner } else { 70730f712c9SDave Chinner args.type = XFS_ALLOCTYPE_NEAR_BNO; 708280253d2SBrian Foster args.fsbno = tp->t_firstblock; 70930f712c9SDave Chinner } 71030f712c9SDave Chinner args.minlen = args.maxlen = args.prod = 1; 71130f712c9SDave Chinner args.wasdel = wasdel; 71230f712c9SDave Chinner *logflagsp = 0; 71330f712c9SDave Chinner if ((error = xfs_alloc_vextent(&args))) { 71430f712c9SDave Chinner xfs_iroot_realloc(ip, -1, whichfork); 7152c4306f7SEric Sandeen ASSERT(ifp->if_broot == NULL); 7162c4306f7SEric Sandeen XFS_IFORK_FMT_SET(ip, whichfork, XFS_DINODE_FMT_EXTENTS); 71730f712c9SDave Chinner xfs_btree_del_cursor(cur, XFS_BTREE_ERROR); 71830f712c9SDave Chinner return error; 71930f712c9SDave Chinner } 72090e2056dSDarrick J. Wong 7212fcc319dSChristoph Hellwig if (WARN_ON_ONCE(args.fsbno == NULLFSBLOCK)) { 7222fcc319dSChristoph Hellwig xfs_iroot_realloc(ip, -1, whichfork); 7232c4306f7SEric Sandeen ASSERT(ifp->if_broot == NULL); 7242c4306f7SEric Sandeen XFS_IFORK_FMT_SET(ip, whichfork, XFS_DINODE_FMT_EXTENTS); 7252fcc319dSChristoph Hellwig xfs_btree_del_cursor(cur, XFS_BTREE_ERROR); 7262fcc319dSChristoph Hellwig return -ENOSPC; 7272fcc319dSChristoph Hellwig } 72830f712c9SDave Chinner /* 72930f712c9SDave Chinner * Allocation can't fail, the space was reserved. 73030f712c9SDave Chinner */ 731280253d2SBrian Foster ASSERT(tp->t_firstblock == NULLFSBLOCK || 732280253d2SBrian Foster args.agno >= XFS_FSB_TO_AGNO(mp, tp->t_firstblock)); 733cf612de7SBrian Foster tp->t_firstblock = args.fsbno; 73430f712c9SDave Chinner cur->bc_private.b.allocated++; 73530f712c9SDave Chinner ip->i_d.di_nblocks++; 73630f712c9SDave Chinner xfs_trans_mod_dquot_byino(tp, ip, XFS_TRANS_DQ_BCOUNT, 1L); 73730f712c9SDave Chinner abp = xfs_btree_get_bufl(mp, tp, args.fsbno, 0); 73830f712c9SDave Chinner /* 73930f712c9SDave Chinner * Fill in the child block. 74030f712c9SDave Chinner */ 74130f712c9SDave Chinner abp->b_ops = &xfs_bmbt_buf_ops; 74230f712c9SDave Chinner ablock = XFS_BUF_TO_BLOCK(abp); 74330f712c9SDave Chinner xfs_btree_init_block_int(mp, ablock, abp->b_bn, 744b6f41e44SEric Sandeen XFS_BTNUM_BMAP, 0, 0, ip->i_ino, 74530f712c9SDave Chinner XFS_BTREE_LONG_PTRS); 74630f712c9SDave Chinner 747b2b1712aSChristoph Hellwig for_each_xfs_iext(ifp, &icur, &rec) { 748906abed5SChristoph Hellwig if (isnullstartblock(rec.br_startblock)) 749906abed5SChristoph Hellwig continue; 750906abed5SChristoph Hellwig arp = XFS_BMBT_REC_ADDR(mp, ablock, 1 + cnt); 751906abed5SChristoph Hellwig xfs_bmbt_disk_set_all(arp, &rec); 752906abed5SChristoph Hellwig cnt++; 75330f712c9SDave Chinner } 75430f712c9SDave Chinner ASSERT(cnt == XFS_IFORK_NEXTENTS(ip, whichfork)); 75530f712c9SDave Chinner xfs_btree_set_numrecs(ablock, cnt); 75630f712c9SDave Chinner 75730f712c9SDave Chinner /* 75830f712c9SDave Chinner * Fill in the root key and pointer. 75930f712c9SDave Chinner */ 76030f712c9SDave Chinner kp = XFS_BMBT_KEY_ADDR(mp, block, 1); 76130f712c9SDave Chinner arp = XFS_BMBT_REC_ADDR(mp, ablock, 1); 76230f712c9SDave Chinner kp->br_startoff = cpu_to_be64(xfs_bmbt_disk_get_startoff(arp)); 76330f712c9SDave Chinner pp = XFS_BMBT_PTR_ADDR(mp, block, 1, xfs_bmbt_get_maxrecs(cur, 76430f712c9SDave Chinner be16_to_cpu(block->bb_level))); 76530f712c9SDave Chinner *pp = cpu_to_be64(args.fsbno); 76630f712c9SDave Chinner 76730f712c9SDave Chinner /* 76830f712c9SDave Chinner * Do all this logging at the end so that 76930f712c9SDave Chinner * the root is at the right level. 77030f712c9SDave Chinner */ 77130f712c9SDave Chinner xfs_btree_log_block(cur, abp, XFS_BB_ALL_BITS); 77230f712c9SDave Chinner xfs_btree_log_recs(cur, abp, 1, be16_to_cpu(ablock->bb_numrecs)); 77330f712c9SDave Chinner ASSERT(*curp == NULL); 77430f712c9SDave Chinner *curp = cur; 77530f712c9SDave Chinner *logflagsp = XFS_ILOG_CORE | xfs_ilog_fbroot(whichfork); 77630f712c9SDave Chinner return 0; 77730f712c9SDave Chinner } 77830f712c9SDave Chinner 77930f712c9SDave Chinner /* 78030f712c9SDave Chinner * Convert a local file to an extents file. 78130f712c9SDave Chinner * This code is out of bounds for data forks of regular files, 78230f712c9SDave Chinner * since the file data needs to get logged so things will stay consistent. 78330f712c9SDave Chinner * (The bmap-level manipulations are ok, though). 78430f712c9SDave Chinner */ 78530f712c9SDave Chinner void 78630f712c9SDave Chinner xfs_bmap_local_to_extents_empty( 78730f712c9SDave Chinner struct xfs_inode *ip, 78830f712c9SDave Chinner int whichfork) 78930f712c9SDave Chinner { 79030f712c9SDave Chinner struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, whichfork); 79130f712c9SDave Chinner 79260b4984fSDarrick J. Wong ASSERT(whichfork != XFS_COW_FORK); 79330f712c9SDave Chinner ASSERT(XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_LOCAL); 79430f712c9SDave Chinner ASSERT(ifp->if_bytes == 0); 79530f712c9SDave Chinner ASSERT(XFS_IFORK_NEXTENTS(ip, whichfork) == 0); 79630f712c9SDave Chinner 79730f712c9SDave Chinner xfs_bmap_forkoff_reset(ip, whichfork); 79830f712c9SDave Chinner ifp->if_flags &= ~XFS_IFINLINE; 79930f712c9SDave Chinner ifp->if_flags |= XFS_IFEXTENTS; 8006bdcf26aSChristoph Hellwig ifp->if_u1.if_root = NULL; 8016bdcf26aSChristoph Hellwig ifp->if_height = 0; 80230f712c9SDave Chinner XFS_IFORK_FMT_SET(ip, whichfork, XFS_DINODE_FMT_EXTENTS); 80330f712c9SDave Chinner } 80430f712c9SDave Chinner 80530f712c9SDave Chinner 80630f712c9SDave Chinner STATIC int /* error */ 80730f712c9SDave Chinner xfs_bmap_local_to_extents( 80830f712c9SDave Chinner xfs_trans_t *tp, /* transaction pointer */ 80930f712c9SDave Chinner xfs_inode_t *ip, /* incore inode pointer */ 81030f712c9SDave Chinner xfs_extlen_t total, /* total blocks needed by transaction */ 81130f712c9SDave Chinner int *logflagsp, /* inode logging flags */ 81230f712c9SDave Chinner int whichfork, 81330f712c9SDave Chinner void (*init_fn)(struct xfs_trans *tp, 81430f712c9SDave Chinner struct xfs_buf *bp, 81530f712c9SDave Chinner struct xfs_inode *ip, 81630f712c9SDave Chinner struct xfs_ifork *ifp)) 81730f712c9SDave Chinner { 81830f712c9SDave Chinner int error = 0; 81930f712c9SDave Chinner int flags; /* logging flags returned */ 82030f712c9SDave Chinner xfs_ifork_t *ifp; /* inode fork pointer */ 82130f712c9SDave Chinner xfs_alloc_arg_t args; /* allocation arguments */ 82230f712c9SDave Chinner xfs_buf_t *bp; /* buffer for extent block */ 82350bb44c2SChristoph Hellwig struct xfs_bmbt_irec rec; 824b2b1712aSChristoph Hellwig struct xfs_iext_cursor icur; 82530f712c9SDave Chinner 82630f712c9SDave Chinner /* 82730f712c9SDave Chinner * We don't want to deal with the case of keeping inode data inline yet. 82830f712c9SDave Chinner * So sending the data fork of a regular inode is invalid. 82930f712c9SDave Chinner */ 830c19b3b05SDave Chinner ASSERT(!(S_ISREG(VFS_I(ip)->i_mode) && whichfork == XFS_DATA_FORK)); 83130f712c9SDave Chinner ifp = XFS_IFORK_PTR(ip, whichfork); 83230f712c9SDave Chinner ASSERT(XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_LOCAL); 83330f712c9SDave Chinner 83430f712c9SDave Chinner if (!ifp->if_bytes) { 83530f712c9SDave Chinner xfs_bmap_local_to_extents_empty(ip, whichfork); 83630f712c9SDave Chinner flags = XFS_ILOG_CORE; 83730f712c9SDave Chinner goto done; 83830f712c9SDave Chinner } 83930f712c9SDave Chinner 84030f712c9SDave Chinner flags = 0; 84130f712c9SDave Chinner error = 0; 8426bdcf26aSChristoph Hellwig ASSERT((ifp->if_flags & (XFS_IFINLINE|XFS_IFEXTENTS)) == XFS_IFINLINE); 84330f712c9SDave Chinner memset(&args, 0, sizeof(args)); 84430f712c9SDave Chinner args.tp = tp; 84530f712c9SDave Chinner args.mp = ip->i_mount; 846340785ccSDarrick J. Wong xfs_rmap_ino_owner(&args.oinfo, ip->i_ino, whichfork, 0); 84730f712c9SDave Chinner /* 84830f712c9SDave Chinner * Allocate a block. We know we need only one, since the 84930f712c9SDave Chinner * file currently fits in an inode. 85030f712c9SDave Chinner */ 851280253d2SBrian Foster if (tp->t_firstblock == NULLFSBLOCK) { 85230f712c9SDave Chinner args.fsbno = XFS_INO_TO_FSB(args.mp, ip->i_ino); 85330f712c9SDave Chinner args.type = XFS_ALLOCTYPE_START_BNO; 85430f712c9SDave Chinner } else { 855280253d2SBrian Foster args.fsbno = tp->t_firstblock; 85630f712c9SDave Chinner args.type = XFS_ALLOCTYPE_NEAR_BNO; 85730f712c9SDave Chinner } 85830f712c9SDave Chinner args.total = total; 85930f712c9SDave Chinner args.minlen = args.maxlen = args.prod = 1; 86030f712c9SDave Chinner error = xfs_alloc_vextent(&args); 86130f712c9SDave Chinner if (error) 86230f712c9SDave Chinner goto done; 86330f712c9SDave Chinner 86430f712c9SDave Chinner /* Can't fail, the space was reserved. */ 86530f712c9SDave Chinner ASSERT(args.fsbno != NULLFSBLOCK); 86630f712c9SDave Chinner ASSERT(args.len == 1); 867280253d2SBrian Foster tp->t_firstblock = args.fsbno; 86830f712c9SDave Chinner bp = xfs_btree_get_bufl(args.mp, tp, args.fsbno, 0); 86930f712c9SDave Chinner 870fe22d552SDave Chinner /* 871b7cdc66bSBrian Foster * Initialize the block, copy the data and log the remote buffer. 872fe22d552SDave Chinner * 873b7cdc66bSBrian Foster * The callout is responsible for logging because the remote format 874b7cdc66bSBrian Foster * might differ from the local format and thus we don't know how much to 875b7cdc66bSBrian Foster * log here. Note that init_fn must also set the buffer log item type 876b7cdc66bSBrian Foster * correctly. 877fe22d552SDave Chinner */ 87830f712c9SDave Chinner init_fn(tp, bp, ip, ifp); 87930f712c9SDave Chinner 880b7cdc66bSBrian Foster /* account for the change in fork size */ 88130f712c9SDave Chinner xfs_idata_realloc(ip, -ifp->if_bytes, whichfork); 88230f712c9SDave Chinner xfs_bmap_local_to_extents_empty(ip, whichfork); 88330f712c9SDave Chinner flags |= XFS_ILOG_CORE; 88430f712c9SDave Chinner 8856bdcf26aSChristoph Hellwig ifp->if_u1.if_root = NULL; 8866bdcf26aSChristoph Hellwig ifp->if_height = 0; 8876bdcf26aSChristoph Hellwig 88850bb44c2SChristoph Hellwig rec.br_startoff = 0; 88950bb44c2SChristoph Hellwig rec.br_startblock = args.fsbno; 89050bb44c2SChristoph Hellwig rec.br_blockcount = 1; 89150bb44c2SChristoph Hellwig rec.br_state = XFS_EXT_NORM; 892b2b1712aSChristoph Hellwig xfs_iext_first(ifp, &icur); 8930254c2f2SChristoph Hellwig xfs_iext_insert(ip, &icur, &rec, 0); 89450bb44c2SChristoph Hellwig 89530f712c9SDave Chinner XFS_IFORK_NEXT_SET(ip, whichfork, 1); 89630f712c9SDave Chinner ip->i_d.di_nblocks = 1; 89730f712c9SDave Chinner xfs_trans_mod_dquot_byino(tp, ip, 89830f712c9SDave Chinner XFS_TRANS_DQ_BCOUNT, 1L); 89930f712c9SDave Chinner flags |= xfs_ilog_fext(whichfork); 90030f712c9SDave Chinner 90130f712c9SDave Chinner done: 90230f712c9SDave Chinner *logflagsp = flags; 90330f712c9SDave Chinner return error; 90430f712c9SDave Chinner } 90530f712c9SDave Chinner 90630f712c9SDave Chinner /* 90730f712c9SDave Chinner * Called from xfs_bmap_add_attrfork to handle btree format files. 90830f712c9SDave Chinner */ 90930f712c9SDave Chinner STATIC int /* error */ 91030f712c9SDave Chinner xfs_bmap_add_attrfork_btree( 91130f712c9SDave Chinner xfs_trans_t *tp, /* transaction pointer */ 91230f712c9SDave Chinner xfs_inode_t *ip, /* incore inode pointer */ 91330f712c9SDave Chinner int *flags) /* inode logging flags */ 91430f712c9SDave Chinner { 91530f712c9SDave Chinner xfs_btree_cur_t *cur; /* btree cursor */ 91630f712c9SDave Chinner int error; /* error return value */ 91730f712c9SDave Chinner xfs_mount_t *mp; /* file system mount struct */ 91830f712c9SDave Chinner int stat; /* newroot status */ 91930f712c9SDave Chinner 92030f712c9SDave Chinner mp = ip->i_mount; 92130f712c9SDave Chinner if (ip->i_df.if_broot_bytes <= XFS_IFORK_DSIZE(ip)) 92230f712c9SDave Chinner *flags |= XFS_ILOG_DBROOT; 92330f712c9SDave Chinner else { 92430f712c9SDave Chinner cur = xfs_bmbt_init_cursor(mp, tp, ip, XFS_DATA_FORK); 925b5cfbc22SChristoph Hellwig error = xfs_bmbt_lookup_first(cur, &stat); 926b5cfbc22SChristoph Hellwig if (error) 92730f712c9SDave Chinner goto error0; 92830f712c9SDave Chinner /* must be at least one entry */ 929c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, stat == 1, error0); 93030f712c9SDave Chinner if ((error = xfs_btree_new_iroot(cur, flags, &stat))) 93130f712c9SDave Chinner goto error0; 93230f712c9SDave Chinner if (stat == 0) { 93330f712c9SDave Chinner xfs_btree_del_cursor(cur, XFS_BTREE_NOERROR); 9342451337dSDave Chinner return -ENOSPC; 93530f712c9SDave Chinner } 93630f712c9SDave Chinner cur->bc_private.b.allocated = 0; 93730f712c9SDave Chinner xfs_btree_del_cursor(cur, XFS_BTREE_NOERROR); 93830f712c9SDave Chinner } 93930f712c9SDave Chinner return 0; 94030f712c9SDave Chinner error0: 94130f712c9SDave Chinner xfs_btree_del_cursor(cur, XFS_BTREE_ERROR); 94230f712c9SDave Chinner return error; 94330f712c9SDave Chinner } 94430f712c9SDave Chinner 94530f712c9SDave Chinner /* 94630f712c9SDave Chinner * Called from xfs_bmap_add_attrfork to handle extents format files. 94730f712c9SDave Chinner */ 94830f712c9SDave Chinner STATIC int /* error */ 94930f712c9SDave Chinner xfs_bmap_add_attrfork_extents( 95081ba8f3eSBrian Foster struct xfs_trans *tp, /* transaction pointer */ 95181ba8f3eSBrian Foster struct xfs_inode *ip, /* incore inode pointer */ 95230f712c9SDave Chinner int *flags) /* inode logging flags */ 95330f712c9SDave Chinner { 95430f712c9SDave Chinner xfs_btree_cur_t *cur; /* bmap btree cursor */ 95530f712c9SDave Chinner int error; /* error return value */ 95630f712c9SDave Chinner 95730f712c9SDave Chinner if (ip->i_d.di_nextents * sizeof(xfs_bmbt_rec_t) <= XFS_IFORK_DSIZE(ip)) 95830f712c9SDave Chinner return 0; 95930f712c9SDave Chinner cur = NULL; 960280253d2SBrian Foster error = xfs_bmap_extents_to_btree(tp, ip, &cur, 0, flags, 961280253d2SBrian Foster XFS_DATA_FORK); 96230f712c9SDave Chinner if (cur) { 96330f712c9SDave Chinner cur->bc_private.b.allocated = 0; 9640b04b6b8SDarrick J. Wong xfs_btree_del_cursor(cur, error); 96530f712c9SDave Chinner } 96630f712c9SDave Chinner return error; 96730f712c9SDave Chinner } 96830f712c9SDave Chinner 96930f712c9SDave Chinner /* 97030f712c9SDave Chinner * Called from xfs_bmap_add_attrfork to handle local format files. Each 97130f712c9SDave Chinner * different data fork content type needs a different callout to do the 97230f712c9SDave Chinner * conversion. Some are basic and only require special block initialisation 97330f712c9SDave Chinner * callouts for the data formating, others (directories) are so specialised they 97430f712c9SDave Chinner * handle everything themselves. 97530f712c9SDave Chinner * 97630f712c9SDave Chinner * XXX (dgc): investigate whether directory conversion can use the generic 97730f712c9SDave Chinner * formatting callout. It should be possible - it's just a very complex 97830f712c9SDave Chinner * formatter. 97930f712c9SDave Chinner */ 98030f712c9SDave Chinner STATIC int /* error */ 98130f712c9SDave Chinner xfs_bmap_add_attrfork_local( 982825d75cdSBrian Foster struct xfs_trans *tp, /* transaction pointer */ 983825d75cdSBrian Foster struct xfs_inode *ip, /* incore inode pointer */ 98430f712c9SDave Chinner int *flags) /* inode logging flags */ 98530f712c9SDave Chinner { 986825d75cdSBrian Foster struct xfs_da_args dargs; /* args for dir/attr code */ 98730f712c9SDave Chinner 98830f712c9SDave Chinner if (ip->i_df.if_bytes <= XFS_IFORK_DSIZE(ip)) 98930f712c9SDave Chinner return 0; 99030f712c9SDave Chinner 991c19b3b05SDave Chinner if (S_ISDIR(VFS_I(ip)->i_mode)) { 99230f712c9SDave Chinner memset(&dargs, 0, sizeof(dargs)); 99330f712c9SDave Chinner dargs.geo = ip->i_mount->m_dir_geo; 99430f712c9SDave Chinner dargs.dp = ip; 99530f712c9SDave Chinner dargs.total = dargs.geo->fsbcount; 99630f712c9SDave Chinner dargs.whichfork = XFS_DATA_FORK; 99730f712c9SDave Chinner dargs.trans = tp; 99830f712c9SDave Chinner return xfs_dir2_sf_to_block(&dargs); 99930f712c9SDave Chinner } 100030f712c9SDave Chinner 1001c19b3b05SDave Chinner if (S_ISLNK(VFS_I(ip)->i_mode)) 1002280253d2SBrian Foster return xfs_bmap_local_to_extents(tp, ip, 1, flags, 1003280253d2SBrian Foster XFS_DATA_FORK, 100430f712c9SDave Chinner xfs_symlink_local_to_remote); 100530f712c9SDave Chinner 100630f712c9SDave Chinner /* should only be called for types that support local format data */ 100730f712c9SDave Chinner ASSERT(0); 10082451337dSDave Chinner return -EFSCORRUPTED; 100930f712c9SDave Chinner } 101030f712c9SDave Chinner 101130f712c9SDave Chinner /* 101230f712c9SDave Chinner * Convert inode from non-attributed to attributed. 101330f712c9SDave Chinner * Must not be in a transaction, ip must not be locked. 101430f712c9SDave Chinner */ 101530f712c9SDave Chinner int /* error code */ 101630f712c9SDave Chinner xfs_bmap_add_attrfork( 101730f712c9SDave Chinner xfs_inode_t *ip, /* incore inode pointer */ 101830f712c9SDave Chinner int size, /* space new attribute needs */ 101930f712c9SDave Chinner int rsvd) /* xact may use reserved blks */ 102030f712c9SDave Chinner { 10212c3234d1SDarrick J. Wong struct xfs_defer_ops dfops; /* freed extent records */ 102230f712c9SDave Chinner xfs_mount_t *mp; /* mount structure */ 102330f712c9SDave Chinner xfs_trans_t *tp; /* transaction pointer */ 102430f712c9SDave Chinner int blks; /* space reservation */ 102530f712c9SDave Chinner int version = 1; /* superblock attr version */ 102630f712c9SDave Chinner int logflags; /* logging flags */ 102730f712c9SDave Chinner int error; /* error return value */ 102830f712c9SDave Chinner 102930f712c9SDave Chinner ASSERT(XFS_IFORK_Q(ip) == 0); 103030f712c9SDave Chinner 103130f712c9SDave Chinner mp = ip->i_mount; 103230f712c9SDave Chinner ASSERT(!XFS_NOT_DQATTACHED(mp, ip)); 1033253f4911SChristoph Hellwig 103430f712c9SDave Chinner blks = XFS_ADDAFORK_SPACE_RES(mp); 1035253f4911SChristoph Hellwig 1036253f4911SChristoph Hellwig error = xfs_trans_alloc(mp, &M_RES(mp)->tr_addafork, blks, 0, 1037253f4911SChristoph Hellwig rsvd ? XFS_TRANS_RESERVE : 0, &tp); 1038253f4911SChristoph Hellwig if (error) 103930f712c9SDave Chinner return error; 10405fdd9794SBrian Foster xfs_defer_init(tp, &dfops); 1041253f4911SChristoph Hellwig 104230f712c9SDave Chinner xfs_ilock(ip, XFS_ILOCK_EXCL); 104330f712c9SDave Chinner error = xfs_trans_reserve_quota_nblks(tp, ip, blks, 0, rsvd ? 104430f712c9SDave Chinner XFS_QMOPT_RES_REGBLKS | XFS_QMOPT_FORCE_RES : 104530f712c9SDave Chinner XFS_QMOPT_RES_REGBLKS); 104630f712c9SDave Chinner if (error) 104730f712c9SDave Chinner goto trans_cancel; 104830f712c9SDave Chinner if (XFS_IFORK_Q(ip)) 104930f712c9SDave Chinner goto trans_cancel; 10500f352f8eSDarrick J. Wong if (ip->i_d.di_anextents != 0) { 10510f352f8eSDarrick J. Wong error = -EFSCORRUPTED; 10520f352f8eSDarrick J. Wong goto trans_cancel; 10530f352f8eSDarrick J. Wong } 105430f712c9SDave Chinner if (ip->i_d.di_aformat != XFS_DINODE_FMT_EXTENTS) { 105530f712c9SDave Chinner /* 105630f712c9SDave Chinner * For inodes coming from pre-6.2 filesystems. 105730f712c9SDave Chinner */ 105830f712c9SDave Chinner ASSERT(ip->i_d.di_aformat == 0); 105930f712c9SDave Chinner ip->i_d.di_aformat = XFS_DINODE_FMT_EXTENTS; 106030f712c9SDave Chinner } 106130f712c9SDave Chinner 106230f712c9SDave Chinner xfs_trans_ijoin(tp, ip, 0); 106330f712c9SDave Chinner xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE); 106430f712c9SDave Chinner 106530f712c9SDave Chinner switch (ip->i_d.di_format) { 106630f712c9SDave Chinner case XFS_DINODE_FMT_DEV: 106730f712c9SDave Chinner ip->i_d.di_forkoff = roundup(sizeof(xfs_dev_t), 8) >> 3; 106830f712c9SDave Chinner break; 106930f712c9SDave Chinner case XFS_DINODE_FMT_LOCAL: 107030f712c9SDave Chinner case XFS_DINODE_FMT_EXTENTS: 107130f712c9SDave Chinner case XFS_DINODE_FMT_BTREE: 107230f712c9SDave Chinner ip->i_d.di_forkoff = xfs_attr_shortform_bytesfit(ip, size); 107330f712c9SDave Chinner if (!ip->i_d.di_forkoff) 107430f712c9SDave Chinner ip->i_d.di_forkoff = xfs_default_attroffset(ip) >> 3; 107530f712c9SDave Chinner else if (mp->m_flags & XFS_MOUNT_ATTR2) 107630f712c9SDave Chinner version = 2; 107730f712c9SDave Chinner break; 107830f712c9SDave Chinner default: 107930f712c9SDave Chinner ASSERT(0); 10802451337dSDave Chinner error = -EINVAL; 108130f712c9SDave Chinner goto trans_cancel; 108230f712c9SDave Chinner } 108330f712c9SDave Chinner 108430f712c9SDave Chinner ASSERT(ip->i_afp == NULL); 108530f712c9SDave Chinner ip->i_afp = kmem_zone_zalloc(xfs_ifork_zone, KM_SLEEP); 108630f712c9SDave Chinner ip->i_afp->if_flags = XFS_IFEXTENTS; 108730f712c9SDave Chinner logflags = 0; 108830f712c9SDave Chinner switch (ip->i_d.di_format) { 108930f712c9SDave Chinner case XFS_DINODE_FMT_LOCAL: 1090825d75cdSBrian Foster error = xfs_bmap_add_attrfork_local(tp, ip, &logflags); 109130f712c9SDave Chinner break; 109230f712c9SDave Chinner case XFS_DINODE_FMT_EXTENTS: 1093825d75cdSBrian Foster error = xfs_bmap_add_attrfork_extents(tp, ip, &logflags); 109430f712c9SDave Chinner break; 109530f712c9SDave Chinner case XFS_DINODE_FMT_BTREE: 1096825d75cdSBrian Foster error = xfs_bmap_add_attrfork_btree(tp, ip, &logflags); 109730f712c9SDave Chinner break; 109830f712c9SDave Chinner default: 109930f712c9SDave Chinner error = 0; 110030f712c9SDave Chinner break; 110130f712c9SDave Chinner } 110230f712c9SDave Chinner if (logflags) 110330f712c9SDave Chinner xfs_trans_log_inode(tp, ip, logflags); 110430f712c9SDave Chinner if (error) 110530f712c9SDave Chinner goto bmap_cancel; 110630f712c9SDave Chinner if (!xfs_sb_version_hasattr(&mp->m_sb) || 110730f712c9SDave Chinner (!xfs_sb_version_hasattr2(&mp->m_sb) && version == 2)) { 110861e63ecbSDave Chinner bool log_sb = false; 110930f712c9SDave Chinner 111030f712c9SDave Chinner spin_lock(&mp->m_sb_lock); 111130f712c9SDave Chinner if (!xfs_sb_version_hasattr(&mp->m_sb)) { 111230f712c9SDave Chinner xfs_sb_version_addattr(&mp->m_sb); 111361e63ecbSDave Chinner log_sb = true; 111430f712c9SDave Chinner } 111530f712c9SDave Chinner if (!xfs_sb_version_hasattr2(&mp->m_sb) && version == 2) { 111630f712c9SDave Chinner xfs_sb_version_addattr2(&mp->m_sb); 111761e63ecbSDave Chinner log_sb = true; 111830f712c9SDave Chinner } 111930f712c9SDave Chinner spin_unlock(&mp->m_sb_lock); 112061e63ecbSDave Chinner if (log_sb) 112161e63ecbSDave Chinner xfs_log_sb(tp); 112230f712c9SDave Chinner } 112330f712c9SDave Chinner 11248ad7c629SChristoph Hellwig error = xfs_defer_finish(&tp, &dfops); 112530f712c9SDave Chinner if (error) 112630f712c9SDave Chinner goto bmap_cancel; 112770393313SChristoph Hellwig error = xfs_trans_commit(tp); 112830f712c9SDave Chinner xfs_iunlock(ip, XFS_ILOCK_EXCL); 112930f712c9SDave Chinner return error; 113030f712c9SDave Chinner 113130f712c9SDave Chinner bmap_cancel: 11322c3234d1SDarrick J. Wong xfs_defer_cancel(&dfops); 113330f712c9SDave Chinner trans_cancel: 11344906e215SChristoph Hellwig xfs_trans_cancel(tp); 113530f712c9SDave Chinner xfs_iunlock(ip, XFS_ILOCK_EXCL); 113630f712c9SDave Chinner return error; 113730f712c9SDave Chinner } 113830f712c9SDave Chinner 113930f712c9SDave Chinner /* 114030f712c9SDave Chinner * Internal and external extent tree search functions. 114130f712c9SDave Chinner */ 114230f712c9SDave Chinner 114330f712c9SDave Chinner /* 1144211e95bbSChristoph Hellwig * Read in extents from a btree-format inode. 114530f712c9SDave Chinner */ 1146211e95bbSChristoph Hellwig int 1147211e95bbSChristoph Hellwig xfs_iread_extents( 1148211e95bbSChristoph Hellwig struct xfs_trans *tp, 1149211e95bbSChristoph Hellwig struct xfs_inode *ip, 1150211e95bbSChristoph Hellwig int whichfork) 115130f712c9SDave Chinner { 1152211e95bbSChristoph Hellwig struct xfs_mount *mp = ip->i_mount; 1153e8e0e170SChristoph Hellwig int state = xfs_bmap_fork_to_state(whichfork); 1154211e95bbSChristoph Hellwig struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, whichfork); 1155211e95bbSChristoph Hellwig xfs_extnum_t nextents = XFS_IFORK_NEXTENTS(ip, whichfork); 1156211e95bbSChristoph Hellwig struct xfs_btree_block *block = ifp->if_broot; 1157b2b1712aSChristoph Hellwig struct xfs_iext_cursor icur; 11586bdcf26aSChristoph Hellwig struct xfs_bmbt_irec new; 1159211e95bbSChristoph Hellwig xfs_fsblock_t bno; 1160211e95bbSChristoph Hellwig struct xfs_buf *bp; 1161211e95bbSChristoph Hellwig xfs_extnum_t i, j; 1162211e95bbSChristoph Hellwig int level; 1163211e95bbSChristoph Hellwig __be64 *pp; 1164211e95bbSChristoph Hellwig int error; 116530f712c9SDave Chinner 1166211e95bbSChristoph Hellwig ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL)); 1167211e95bbSChristoph Hellwig 1168211e95bbSChristoph Hellwig if (unlikely(XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE)) { 1169211e95bbSChristoph Hellwig XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_LOW, mp); 1170211e95bbSChristoph Hellwig return -EFSCORRUPTED; 1171211e95bbSChristoph Hellwig } 1172211e95bbSChristoph Hellwig 117330f712c9SDave Chinner /* 117430f712c9SDave Chinner * Root level must use BMAP_BROOT_PTR_ADDR macro to get ptr out. 117530f712c9SDave Chinner */ 117630f712c9SDave Chinner level = be16_to_cpu(block->bb_level); 117730f712c9SDave Chinner ASSERT(level > 0); 117830f712c9SDave Chinner pp = XFS_BMAP_BROOT_PTR_ADDR(mp, block, 1, ifp->if_broot_bytes); 117930f712c9SDave Chinner bno = be64_to_cpu(*pp); 1180d5a91baeSDarrick J. Wong 118130f712c9SDave Chinner /* 118230f712c9SDave Chinner * Go down the tree until leaf level is reached, following the first 118330f712c9SDave Chinner * pointer (leftmost) at each level. 118430f712c9SDave Chinner */ 118530f712c9SDave Chinner while (level-- > 0) { 118630f712c9SDave Chinner error = xfs_btree_read_bufl(mp, tp, bno, 0, &bp, 118730f712c9SDave Chinner XFS_BMAP_BTREE_REF, &xfs_bmbt_buf_ops); 118830f712c9SDave Chinner if (error) 1189211e95bbSChristoph Hellwig goto out; 119030f712c9SDave Chinner block = XFS_BUF_TO_BLOCK(bp); 119130f712c9SDave Chinner if (level == 0) 119230f712c9SDave Chinner break; 119330f712c9SDave Chinner pp = XFS_BMBT_PTR_ADDR(mp, block, 1, mp->m_bmap_dmxr[1]); 119430f712c9SDave Chinner bno = be64_to_cpu(*pp); 1195c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, 119659f6fec3SDarrick J. Wong xfs_verify_fsbno(mp, bno), out_brelse); 119730f712c9SDave Chinner xfs_trans_brelse(tp, bp); 119830f712c9SDave Chinner } 1199211e95bbSChristoph Hellwig 120030f712c9SDave Chinner /* 120130f712c9SDave Chinner * Here with bp and block set to the leftmost leaf node in the tree. 120230f712c9SDave Chinner */ 120330f712c9SDave Chinner i = 0; 1204b2b1712aSChristoph Hellwig xfs_iext_first(ifp, &icur); 1205211e95bbSChristoph Hellwig 120630f712c9SDave Chinner /* 120730f712c9SDave Chinner * Loop over all leaf nodes. Copy information to the extent records. 120830f712c9SDave Chinner */ 120930f712c9SDave Chinner for (;;) { 121030f712c9SDave Chinner xfs_bmbt_rec_t *frp; 121130f712c9SDave Chinner xfs_fsblock_t nextbno; 121230f712c9SDave Chinner xfs_extnum_t num_recs; 121330f712c9SDave Chinner 121430f712c9SDave Chinner num_recs = xfs_btree_get_numrecs(block); 1215211e95bbSChristoph Hellwig if (unlikely(i + num_recs > nextents)) { 121630f712c9SDave Chinner xfs_warn(ip->i_mount, 121730f712c9SDave Chinner "corrupt dinode %Lu, (btree extents).", 121830f712c9SDave Chinner (unsigned long long) ip->i_ino); 121990a58f95SDarrick J. Wong xfs_inode_verifier_error(ip, -EFSCORRUPTED, 122090a58f95SDarrick J. Wong __func__, block, sizeof(*block), 122190a58f95SDarrick J. Wong __this_address); 1222211e95bbSChristoph Hellwig error = -EFSCORRUPTED; 1223211e95bbSChristoph Hellwig goto out_brelse; 122430f712c9SDave Chinner } 122530f712c9SDave Chinner /* 122630f712c9SDave Chinner * Read-ahead the next leaf block, if any. 122730f712c9SDave Chinner */ 122830f712c9SDave Chinner nextbno = be64_to_cpu(block->bb_u.l.bb_rightsib); 122930f712c9SDave Chinner if (nextbno != NULLFSBLOCK) 123030f712c9SDave Chinner xfs_btree_reada_bufl(mp, nextbno, 1, 123130f712c9SDave Chinner &xfs_bmbt_buf_ops); 123230f712c9SDave Chinner /* 123330f712c9SDave Chinner * Copy records into the extent records. 123430f712c9SDave Chinner */ 123530f712c9SDave Chinner frp = XFS_BMBT_REC_ADDR(mp, block, 1); 12366bdcf26aSChristoph Hellwig for (j = 0; j < num_recs; j++, frp++, i++) { 123730b0984dSDarrick J. Wong xfs_failaddr_t fa; 123830b0984dSDarrick J. Wong 1239dac9c9b1SChristoph Hellwig xfs_bmbt_disk_get_all(frp, &new); 124030b0984dSDarrick J. Wong fa = xfs_bmap_validate_extent(ip, whichfork, &new); 124130b0984dSDarrick J. Wong if (fa) { 1242211e95bbSChristoph Hellwig error = -EFSCORRUPTED; 124330b0984dSDarrick J. Wong xfs_inode_verifier_error(ip, error, 124430b0984dSDarrick J. Wong "xfs_iread_extents(2)", 124530b0984dSDarrick J. Wong frp, sizeof(*frp), fa); 1246211e95bbSChristoph Hellwig goto out_brelse; 124730f712c9SDave Chinner } 12480254c2f2SChristoph Hellwig xfs_iext_insert(ip, &icur, &new, state); 1249b2b1712aSChristoph Hellwig trace_xfs_read_extent(ip, &icur, state, _THIS_IP_); 1250b2b1712aSChristoph Hellwig xfs_iext_next(ifp, &icur); 125130f712c9SDave Chinner } 125230f712c9SDave Chinner xfs_trans_brelse(tp, bp); 125330f712c9SDave Chinner bno = nextbno; 125430f712c9SDave Chinner /* 125530f712c9SDave Chinner * If we've reached the end, stop. 125630f712c9SDave Chinner */ 125730f712c9SDave Chinner if (bno == NULLFSBLOCK) 125830f712c9SDave Chinner break; 125930f712c9SDave Chinner error = xfs_btree_read_bufl(mp, tp, bno, 0, &bp, 126030f712c9SDave Chinner XFS_BMAP_BTREE_REF, &xfs_bmbt_buf_ops); 126130f712c9SDave Chinner if (error) 1262211e95bbSChristoph Hellwig goto out; 126330f712c9SDave Chinner block = XFS_BUF_TO_BLOCK(bp); 126430f712c9SDave Chinner } 1265211e95bbSChristoph Hellwig 1266211e95bbSChristoph Hellwig if (i != XFS_IFORK_NEXTENTS(ip, whichfork)) { 1267211e95bbSChristoph Hellwig error = -EFSCORRUPTED; 1268211e95bbSChristoph Hellwig goto out; 1269211e95bbSChristoph Hellwig } 12705d829300SEric Sandeen ASSERT(i == xfs_iext_count(ifp)); 1271211e95bbSChristoph Hellwig 1272211e95bbSChristoph Hellwig ifp->if_flags |= XFS_IFEXTENTS; 127330f712c9SDave Chinner return 0; 1274211e95bbSChristoph Hellwig 1275211e95bbSChristoph Hellwig out_brelse: 127630f712c9SDave Chinner xfs_trans_brelse(tp, bp); 1277211e95bbSChristoph Hellwig out: 1278211e95bbSChristoph Hellwig xfs_iext_destroy(ifp); 1279211e95bbSChristoph Hellwig return error; 128030f712c9SDave Chinner } 128130f712c9SDave Chinner 128230f712c9SDave Chinner /* 128329b3e94aSChristoph Hellwig * Returns the relative block number of the first unused block(s) in the given 128429b3e94aSChristoph Hellwig * fork with at least "len" logically contiguous blocks free. This is the 128529b3e94aSChristoph Hellwig * lowest-address hole if the fork has holes, else the first block past the end 128629b3e94aSChristoph Hellwig * of fork. Return 0 if the fork is currently local (in-inode). 128730f712c9SDave Chinner */ 128830f712c9SDave Chinner int /* error */ 128930f712c9SDave Chinner xfs_bmap_first_unused( 129029b3e94aSChristoph Hellwig struct xfs_trans *tp, /* transaction pointer */ 129129b3e94aSChristoph Hellwig struct xfs_inode *ip, /* incore inode */ 129230f712c9SDave Chinner xfs_extlen_t len, /* size of hole to find */ 129330f712c9SDave Chinner xfs_fileoff_t *first_unused, /* unused block */ 129430f712c9SDave Chinner int whichfork) /* data or attr fork */ 129530f712c9SDave Chinner { 129629b3e94aSChristoph Hellwig struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, whichfork); 129729b3e94aSChristoph Hellwig struct xfs_bmbt_irec got; 1298b2b1712aSChristoph Hellwig struct xfs_iext_cursor icur; 129929b3e94aSChristoph Hellwig xfs_fileoff_t lastaddr = 0; 130029b3e94aSChristoph Hellwig xfs_fileoff_t lowest, max; 130129b3e94aSChristoph Hellwig int error; 130230f712c9SDave Chinner 130330f712c9SDave Chinner ASSERT(XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_BTREE || 130430f712c9SDave Chinner XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_EXTENTS || 130530f712c9SDave Chinner XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_LOCAL); 130629b3e94aSChristoph Hellwig 130730f712c9SDave Chinner if (XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_LOCAL) { 130830f712c9SDave Chinner *first_unused = 0; 130930f712c9SDave Chinner return 0; 131030f712c9SDave Chinner } 131129b3e94aSChristoph Hellwig 131229b3e94aSChristoph Hellwig if (!(ifp->if_flags & XFS_IFEXTENTS)) { 131329b3e94aSChristoph Hellwig error = xfs_iread_extents(tp, ip, whichfork); 131429b3e94aSChristoph Hellwig if (error) 131530f712c9SDave Chinner return error; 131629b3e94aSChristoph Hellwig } 1317f2285c14SChristoph Hellwig 131829b3e94aSChristoph Hellwig lowest = max = *first_unused; 1319b2b1712aSChristoph Hellwig for_each_xfs_iext(ifp, &icur, &got) { 132030f712c9SDave Chinner /* 132130f712c9SDave Chinner * See if the hole before this extent will work. 132230f712c9SDave Chinner */ 1323f2285c14SChristoph Hellwig if (got.br_startoff >= lowest + len && 132429b3e94aSChristoph Hellwig got.br_startoff - max >= len) 132529b3e94aSChristoph Hellwig break; 1326f2285c14SChristoph Hellwig lastaddr = got.br_startoff + got.br_blockcount; 132730f712c9SDave Chinner max = XFS_FILEOFF_MAX(lastaddr, lowest); 132830f712c9SDave Chinner } 132929b3e94aSChristoph Hellwig 133030f712c9SDave Chinner *first_unused = max; 133130f712c9SDave Chinner return 0; 133230f712c9SDave Chinner } 133330f712c9SDave Chinner 133430f712c9SDave Chinner /* 133530f712c9SDave Chinner * Returns the file-relative block number of the last block - 1 before 133630f712c9SDave Chinner * last_block (input value) in the file. 133730f712c9SDave Chinner * This is not based on i_size, it is based on the extent records. 133830f712c9SDave Chinner * Returns 0 for local files, as they do not have extent records. 133930f712c9SDave Chinner */ 134030f712c9SDave Chinner int /* error */ 134130f712c9SDave Chinner xfs_bmap_last_before( 134286685f7bSChristoph Hellwig struct xfs_trans *tp, /* transaction pointer */ 134386685f7bSChristoph Hellwig struct xfs_inode *ip, /* incore inode */ 134430f712c9SDave Chinner xfs_fileoff_t *last_block, /* last block */ 134530f712c9SDave Chinner int whichfork) /* data or attr fork */ 134630f712c9SDave Chinner { 134786685f7bSChristoph Hellwig struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, whichfork); 134886685f7bSChristoph Hellwig struct xfs_bmbt_irec got; 1349b2b1712aSChristoph Hellwig struct xfs_iext_cursor icur; 135086685f7bSChristoph Hellwig int error; 135130f712c9SDave Chinner 135286685f7bSChristoph Hellwig switch (XFS_IFORK_FORMAT(ip, whichfork)) { 135386685f7bSChristoph Hellwig case XFS_DINODE_FMT_LOCAL: 135430f712c9SDave Chinner *last_block = 0; 135530f712c9SDave Chinner return 0; 135686685f7bSChristoph Hellwig case XFS_DINODE_FMT_BTREE: 135786685f7bSChristoph Hellwig case XFS_DINODE_FMT_EXTENTS: 135886685f7bSChristoph Hellwig break; 135986685f7bSChristoph Hellwig default: 136086685f7bSChristoph Hellwig return -EIO; 136130f712c9SDave Chinner } 136286685f7bSChristoph Hellwig 136386685f7bSChristoph Hellwig if (!(ifp->if_flags & XFS_IFEXTENTS)) { 136486685f7bSChristoph Hellwig error = xfs_iread_extents(tp, ip, whichfork); 136586685f7bSChristoph Hellwig if (error) 136630f712c9SDave Chinner return error; 136730f712c9SDave Chinner } 136886685f7bSChristoph Hellwig 1369b2b1712aSChristoph Hellwig if (!xfs_iext_lookup_extent_before(ip, ifp, last_block, &icur, &got)) 137086685f7bSChristoph Hellwig *last_block = 0; 137130f712c9SDave Chinner return 0; 137230f712c9SDave Chinner } 137330f712c9SDave Chinner 137430f712c9SDave Chinner int 137530f712c9SDave Chinner xfs_bmap_last_extent( 137630f712c9SDave Chinner struct xfs_trans *tp, 137730f712c9SDave Chinner struct xfs_inode *ip, 137830f712c9SDave Chinner int whichfork, 137930f712c9SDave Chinner struct xfs_bmbt_irec *rec, 138030f712c9SDave Chinner int *is_empty) 138130f712c9SDave Chinner { 138230f712c9SDave Chinner struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, whichfork); 1383b2b1712aSChristoph Hellwig struct xfs_iext_cursor icur; 138430f712c9SDave Chinner int error; 138530f712c9SDave Chinner 138630f712c9SDave Chinner if (!(ifp->if_flags & XFS_IFEXTENTS)) { 138730f712c9SDave Chinner error = xfs_iread_extents(tp, ip, whichfork); 138830f712c9SDave Chinner if (error) 138930f712c9SDave Chinner return error; 139030f712c9SDave Chinner } 139130f712c9SDave Chinner 1392b2b1712aSChristoph Hellwig xfs_iext_last(ifp, &icur); 1393b2b1712aSChristoph Hellwig if (!xfs_iext_get_extent(ifp, &icur, rec)) 139430f712c9SDave Chinner *is_empty = 1; 1395b2b1712aSChristoph Hellwig else 139630f712c9SDave Chinner *is_empty = 0; 139730f712c9SDave Chinner return 0; 139830f712c9SDave Chinner } 139930f712c9SDave Chinner 140030f712c9SDave Chinner /* 140130f712c9SDave Chinner * Check the last inode extent to determine whether this allocation will result 140230f712c9SDave Chinner * in blocks being allocated at the end of the file. When we allocate new data 140330f712c9SDave Chinner * blocks at the end of the file which do not start at the previous data block, 140430f712c9SDave Chinner * we will try to align the new blocks at stripe unit boundaries. 140530f712c9SDave Chinner * 140630f712c9SDave Chinner * Returns 1 in bma->aeof if the file (fork) is empty as any new write will be 140730f712c9SDave Chinner * at, or past the EOF. 140830f712c9SDave Chinner */ 140930f712c9SDave Chinner STATIC int 141030f712c9SDave Chinner xfs_bmap_isaeof( 141130f712c9SDave Chinner struct xfs_bmalloca *bma, 141230f712c9SDave Chinner int whichfork) 141330f712c9SDave Chinner { 141430f712c9SDave Chinner struct xfs_bmbt_irec rec; 141530f712c9SDave Chinner int is_empty; 141630f712c9SDave Chinner int error; 141730f712c9SDave Chinner 1418749f24f3SThomas Meyer bma->aeof = false; 141930f712c9SDave Chinner error = xfs_bmap_last_extent(NULL, bma->ip, whichfork, &rec, 142030f712c9SDave Chinner &is_empty); 142130f712c9SDave Chinner if (error) 142230f712c9SDave Chinner return error; 142330f712c9SDave Chinner 142430f712c9SDave Chinner if (is_empty) { 1425749f24f3SThomas Meyer bma->aeof = true; 142630f712c9SDave Chinner return 0; 142730f712c9SDave Chinner } 142830f712c9SDave Chinner 142930f712c9SDave Chinner /* 143030f712c9SDave Chinner * Check if we are allocation or past the last extent, or at least into 143130f712c9SDave Chinner * the last delayed allocated extent. 143230f712c9SDave Chinner */ 143330f712c9SDave Chinner bma->aeof = bma->offset >= rec.br_startoff + rec.br_blockcount || 143430f712c9SDave Chinner (bma->offset >= rec.br_startoff && 143530f712c9SDave Chinner isnullstartblock(rec.br_startblock)); 143630f712c9SDave Chinner return 0; 143730f712c9SDave Chinner } 143830f712c9SDave Chinner 143930f712c9SDave Chinner /* 144030f712c9SDave Chinner * Returns the file-relative block number of the first block past eof in 144130f712c9SDave Chinner * the file. This is not based on i_size, it is based on the extent records. 144230f712c9SDave Chinner * Returns 0 for local files, as they do not have extent records. 144330f712c9SDave Chinner */ 144430f712c9SDave Chinner int 144530f712c9SDave Chinner xfs_bmap_last_offset( 144630f712c9SDave Chinner struct xfs_inode *ip, 144730f712c9SDave Chinner xfs_fileoff_t *last_block, 144830f712c9SDave Chinner int whichfork) 144930f712c9SDave Chinner { 145030f712c9SDave Chinner struct xfs_bmbt_irec rec; 145130f712c9SDave Chinner int is_empty; 145230f712c9SDave Chinner int error; 145330f712c9SDave Chinner 145430f712c9SDave Chinner *last_block = 0; 145530f712c9SDave Chinner 145630f712c9SDave Chinner if (XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_LOCAL) 145730f712c9SDave Chinner return 0; 145830f712c9SDave Chinner 145930f712c9SDave Chinner if (XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE && 146030f712c9SDave Chinner XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS) 14612451337dSDave Chinner return -EIO; 146230f712c9SDave Chinner 146330f712c9SDave Chinner error = xfs_bmap_last_extent(NULL, ip, whichfork, &rec, &is_empty); 146430f712c9SDave Chinner if (error || is_empty) 146530f712c9SDave Chinner return error; 146630f712c9SDave Chinner 146730f712c9SDave Chinner *last_block = rec.br_startoff + rec.br_blockcount; 146830f712c9SDave Chinner return 0; 146930f712c9SDave Chinner } 147030f712c9SDave Chinner 147130f712c9SDave Chinner /* 147230f712c9SDave Chinner * Returns whether the selected fork of the inode has exactly one 147330f712c9SDave Chinner * block or not. For the data fork we check this matches di_size, 147430f712c9SDave Chinner * implying the file's range is 0..bsize-1. 147530f712c9SDave Chinner */ 147630f712c9SDave Chinner int /* 1=>1 block, 0=>otherwise */ 147730f712c9SDave Chinner xfs_bmap_one_block( 147830f712c9SDave Chinner xfs_inode_t *ip, /* incore inode */ 147930f712c9SDave Chinner int whichfork) /* data or attr fork */ 148030f712c9SDave Chinner { 148130f712c9SDave Chinner xfs_ifork_t *ifp; /* inode fork pointer */ 148230f712c9SDave Chinner int rval; /* return value */ 148330f712c9SDave Chinner xfs_bmbt_irec_t s; /* internal version of extent */ 1484b2b1712aSChristoph Hellwig struct xfs_iext_cursor icur; 148530f712c9SDave Chinner 148630f712c9SDave Chinner #ifndef DEBUG 148730f712c9SDave Chinner if (whichfork == XFS_DATA_FORK) 148830f712c9SDave Chinner return XFS_ISIZE(ip) == ip->i_mount->m_sb.sb_blocksize; 148930f712c9SDave Chinner #endif /* !DEBUG */ 149030f712c9SDave Chinner if (XFS_IFORK_NEXTENTS(ip, whichfork) != 1) 149130f712c9SDave Chinner return 0; 149230f712c9SDave Chinner if (XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS) 149330f712c9SDave Chinner return 0; 149430f712c9SDave Chinner ifp = XFS_IFORK_PTR(ip, whichfork); 149530f712c9SDave Chinner ASSERT(ifp->if_flags & XFS_IFEXTENTS); 1496b2b1712aSChristoph Hellwig xfs_iext_first(ifp, &icur); 1497b2b1712aSChristoph Hellwig xfs_iext_get_extent(ifp, &icur, &s); 149830f712c9SDave Chinner rval = s.br_startoff == 0 && s.br_blockcount == 1; 149930f712c9SDave Chinner if (rval && whichfork == XFS_DATA_FORK) 150030f712c9SDave Chinner ASSERT(XFS_ISIZE(ip) == ip->i_mount->m_sb.sb_blocksize); 150130f712c9SDave Chinner return rval; 150230f712c9SDave Chinner } 150330f712c9SDave Chinner 150430f712c9SDave Chinner /* 150530f712c9SDave Chinner * Extent tree manipulation functions used during allocation. 150630f712c9SDave Chinner */ 150730f712c9SDave Chinner 150830f712c9SDave Chinner /* 150930f712c9SDave Chinner * Convert a delayed allocation to a real allocation. 151030f712c9SDave Chinner */ 151130f712c9SDave Chinner STATIC int /* error */ 151230f712c9SDave Chinner xfs_bmap_add_extent_delay_real( 151360b4984fSDarrick J. Wong struct xfs_bmalloca *bma, 151460b4984fSDarrick J. Wong int whichfork) 151530f712c9SDave Chinner { 151630f712c9SDave Chinner struct xfs_bmbt_irec *new = &bma->got; 151730f712c9SDave Chinner int error; /* error return value */ 151830f712c9SDave Chinner int i; /* temp state */ 151930f712c9SDave Chinner xfs_ifork_t *ifp; /* inode fork pointer */ 152030f712c9SDave Chinner xfs_fileoff_t new_endoff; /* end offset of new entry */ 152130f712c9SDave Chinner xfs_bmbt_irec_t r[3]; /* neighbor extent entries */ 152230f712c9SDave Chinner /* left is 0, right is 1, prev is 2 */ 152330f712c9SDave Chinner int rval=0; /* return value (logging flags) */ 1524060ea65bSChristoph Hellwig int state = xfs_bmap_fork_to_state(whichfork); 152530f712c9SDave Chinner xfs_filblks_t da_new; /* new count del alloc blocks used */ 152630f712c9SDave Chinner xfs_filblks_t da_old; /* old count del alloc blocks used */ 152730f712c9SDave Chinner xfs_filblks_t temp=0; /* value for da_new calculations */ 152830f712c9SDave Chinner int tmp_rval; /* partial logging flags */ 1529c29aad41SEric Sandeen struct xfs_mount *mp; 153060b4984fSDarrick J. Wong xfs_extnum_t *nextents; 15314dcb8869SChristoph Hellwig struct xfs_bmbt_irec old; 153230f712c9SDave Chinner 1533f1f96c49SEric Sandeen mp = bma->ip->i_mount; 15346d3eb1ecSDarrick J. Wong ifp = XFS_IFORK_PTR(bma->ip, whichfork); 153560b4984fSDarrick J. Wong ASSERT(whichfork != XFS_ATTR_FORK); 153660b4984fSDarrick J. Wong nextents = (whichfork == XFS_COW_FORK ? &bma->ip->i_cnextents : 153760b4984fSDarrick J. Wong &bma->ip->i_d.di_nextents); 153830f712c9SDave Chinner 153930f712c9SDave Chinner ASSERT(!isnullstartblock(new->br_startblock)); 154030f712c9SDave Chinner ASSERT(!bma->cur || 154130f712c9SDave Chinner (bma->cur->bc_private.b.flags & XFS_BTCUR_BPRV_WASDEL)); 154230f712c9SDave Chinner 1543ff6d6af2SBill O'Donnell XFS_STATS_INC(mp, xs_add_exlist); 154430f712c9SDave Chinner 154530f712c9SDave Chinner #define LEFT r[0] 154630f712c9SDave Chinner #define RIGHT r[1] 154730f712c9SDave Chinner #define PREV r[2] 154830f712c9SDave Chinner 154930f712c9SDave Chinner /* 155030f712c9SDave Chinner * Set up a bunch of variables to make the tests simpler. 155130f712c9SDave Chinner */ 1552b2b1712aSChristoph Hellwig xfs_iext_get_extent(ifp, &bma->icur, &PREV); 155330f712c9SDave Chinner new_endoff = new->br_startoff + new->br_blockcount; 15544dcb8869SChristoph Hellwig ASSERT(isnullstartblock(PREV.br_startblock)); 155530f712c9SDave Chinner ASSERT(PREV.br_startoff <= new->br_startoff); 155630f712c9SDave Chinner ASSERT(PREV.br_startoff + PREV.br_blockcount >= new_endoff); 155730f712c9SDave Chinner 155830f712c9SDave Chinner da_old = startblockval(PREV.br_startblock); 155930f712c9SDave Chinner da_new = 0; 156030f712c9SDave Chinner 156130f712c9SDave Chinner /* 156230f712c9SDave Chinner * Set flags determining what part of the previous delayed allocation 156330f712c9SDave Chinner * extent is being replaced by a real allocation. 156430f712c9SDave Chinner */ 156530f712c9SDave Chinner if (PREV.br_startoff == new->br_startoff) 156630f712c9SDave Chinner state |= BMAP_LEFT_FILLING; 156730f712c9SDave Chinner if (PREV.br_startoff + PREV.br_blockcount == new_endoff) 156830f712c9SDave Chinner state |= BMAP_RIGHT_FILLING; 156930f712c9SDave Chinner 157030f712c9SDave Chinner /* 157130f712c9SDave Chinner * Check and set flags if this segment has a left neighbor. 157230f712c9SDave Chinner * Don't set contiguous if the combined extent would be too large. 157330f712c9SDave Chinner */ 1574b2b1712aSChristoph Hellwig if (xfs_iext_peek_prev_extent(ifp, &bma->icur, &LEFT)) { 157530f712c9SDave Chinner state |= BMAP_LEFT_VALID; 157630f712c9SDave Chinner if (isnullstartblock(LEFT.br_startblock)) 157730f712c9SDave Chinner state |= BMAP_LEFT_DELAY; 157830f712c9SDave Chinner } 157930f712c9SDave Chinner 158030f712c9SDave Chinner if ((state & BMAP_LEFT_VALID) && !(state & BMAP_LEFT_DELAY) && 158130f712c9SDave Chinner LEFT.br_startoff + LEFT.br_blockcount == new->br_startoff && 158230f712c9SDave Chinner LEFT.br_startblock + LEFT.br_blockcount == new->br_startblock && 158330f712c9SDave Chinner LEFT.br_state == new->br_state && 158430f712c9SDave Chinner LEFT.br_blockcount + new->br_blockcount <= MAXEXTLEN) 158530f712c9SDave Chinner state |= BMAP_LEFT_CONTIG; 158630f712c9SDave Chinner 158730f712c9SDave Chinner /* 158830f712c9SDave Chinner * Check and set flags if this segment has a right neighbor. 158930f712c9SDave Chinner * Don't set contiguous if the combined extent would be too large. 159030f712c9SDave Chinner * Also check for all-three-contiguous being too large. 159130f712c9SDave Chinner */ 1592b2b1712aSChristoph Hellwig if (xfs_iext_peek_next_extent(ifp, &bma->icur, &RIGHT)) { 159330f712c9SDave Chinner state |= BMAP_RIGHT_VALID; 159430f712c9SDave Chinner if (isnullstartblock(RIGHT.br_startblock)) 159530f712c9SDave Chinner state |= BMAP_RIGHT_DELAY; 159630f712c9SDave Chinner } 159730f712c9SDave Chinner 159830f712c9SDave Chinner if ((state & BMAP_RIGHT_VALID) && !(state & BMAP_RIGHT_DELAY) && 159930f712c9SDave Chinner new_endoff == RIGHT.br_startoff && 160030f712c9SDave Chinner new->br_startblock + new->br_blockcount == RIGHT.br_startblock && 160130f712c9SDave Chinner new->br_state == RIGHT.br_state && 160230f712c9SDave Chinner new->br_blockcount + RIGHT.br_blockcount <= MAXEXTLEN && 160330f712c9SDave Chinner ((state & (BMAP_LEFT_CONTIG | BMAP_LEFT_FILLING | 160430f712c9SDave Chinner BMAP_RIGHT_FILLING)) != 160530f712c9SDave Chinner (BMAP_LEFT_CONTIG | BMAP_LEFT_FILLING | 160630f712c9SDave Chinner BMAP_RIGHT_FILLING) || 160730f712c9SDave Chinner LEFT.br_blockcount + new->br_blockcount + RIGHT.br_blockcount 160830f712c9SDave Chinner <= MAXEXTLEN)) 160930f712c9SDave Chinner state |= BMAP_RIGHT_CONTIG; 161030f712c9SDave Chinner 161130f712c9SDave Chinner error = 0; 161230f712c9SDave Chinner /* 161330f712c9SDave Chinner * Switch out based on the FILLING and CONTIG state bits. 161430f712c9SDave Chinner */ 161530f712c9SDave Chinner switch (state & (BMAP_LEFT_FILLING | BMAP_LEFT_CONTIG | 161630f712c9SDave Chinner BMAP_RIGHT_FILLING | BMAP_RIGHT_CONTIG)) { 161730f712c9SDave Chinner case BMAP_LEFT_FILLING | BMAP_LEFT_CONTIG | 161830f712c9SDave Chinner BMAP_RIGHT_FILLING | BMAP_RIGHT_CONTIG: 161930f712c9SDave Chinner /* 162030f712c9SDave Chinner * Filling in all of a previously delayed allocation extent. 162130f712c9SDave Chinner * The left and right neighbors are both contiguous with new. 162230f712c9SDave Chinner */ 16234dcb8869SChristoph Hellwig LEFT.br_blockcount += PREV.br_blockcount + RIGHT.br_blockcount; 162430f712c9SDave Chinner 1625c38ccf59SChristoph Hellwig xfs_iext_remove(bma->ip, &bma->icur, state); 1626c38ccf59SChristoph Hellwig xfs_iext_remove(bma->ip, &bma->icur, state); 1627b2b1712aSChristoph Hellwig xfs_iext_prev(ifp, &bma->icur); 1628b2b1712aSChristoph Hellwig xfs_iext_update_extent(bma->ip, state, &bma->icur, &LEFT); 162960b4984fSDarrick J. Wong (*nextents)--; 16300d045540SChristoph Hellwig 163130f712c9SDave Chinner if (bma->cur == NULL) 163230f712c9SDave Chinner rval = XFS_ILOG_CORE | XFS_ILOG_DEXT; 163330f712c9SDave Chinner else { 163430f712c9SDave Chinner rval = XFS_ILOG_CORE; 1635e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(bma->cur, &RIGHT, &i); 163630f712c9SDave Chinner if (error) 163730f712c9SDave Chinner goto done; 1638c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 163930f712c9SDave Chinner error = xfs_btree_delete(bma->cur, &i); 164030f712c9SDave Chinner if (error) 164130f712c9SDave Chinner goto done; 1642c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 164330f712c9SDave Chinner error = xfs_btree_decrement(bma->cur, 0, &i); 164430f712c9SDave Chinner if (error) 164530f712c9SDave Chinner goto done; 1646c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 1647a67d00a5SChristoph Hellwig error = xfs_bmbt_update(bma->cur, &LEFT); 164830f712c9SDave Chinner if (error) 164930f712c9SDave Chinner goto done; 165030f712c9SDave Chinner } 165130f712c9SDave Chinner break; 165230f712c9SDave Chinner 165330f712c9SDave Chinner case BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING | BMAP_LEFT_CONTIG: 165430f712c9SDave Chinner /* 165530f712c9SDave Chinner * Filling in all of a previously delayed allocation extent. 165630f712c9SDave Chinner * The left neighbor is contiguous, the right is not. 165730f712c9SDave Chinner */ 16584dcb8869SChristoph Hellwig old = LEFT; 16594dcb8869SChristoph Hellwig LEFT.br_blockcount += PREV.br_blockcount; 16600d045540SChristoph Hellwig 1661c38ccf59SChristoph Hellwig xfs_iext_remove(bma->ip, &bma->icur, state); 1662b2b1712aSChristoph Hellwig xfs_iext_prev(ifp, &bma->icur); 1663b2b1712aSChristoph Hellwig xfs_iext_update_extent(bma->ip, state, &bma->icur, &LEFT); 166430f712c9SDave Chinner 166530f712c9SDave Chinner if (bma->cur == NULL) 166630f712c9SDave Chinner rval = XFS_ILOG_DEXT; 166730f712c9SDave Chinner else { 166830f712c9SDave Chinner rval = 0; 1669e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(bma->cur, &old, &i); 167030f712c9SDave Chinner if (error) 167130f712c9SDave Chinner goto done; 1672c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 1673a67d00a5SChristoph Hellwig error = xfs_bmbt_update(bma->cur, &LEFT); 167430f712c9SDave Chinner if (error) 167530f712c9SDave Chinner goto done; 167630f712c9SDave Chinner } 167730f712c9SDave Chinner break; 167830f712c9SDave Chinner 167930f712c9SDave Chinner case BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING | BMAP_RIGHT_CONTIG: 168030f712c9SDave Chinner /* 168130f712c9SDave Chinner * Filling in all of a previously delayed allocation extent. 168230f712c9SDave Chinner * The right neighbor is contiguous, the left is not. 168330f712c9SDave Chinner */ 16844dcb8869SChristoph Hellwig PREV.br_startblock = new->br_startblock; 16854dcb8869SChristoph Hellwig PREV.br_blockcount += RIGHT.br_blockcount; 16860d045540SChristoph Hellwig 1687b2b1712aSChristoph Hellwig xfs_iext_next(ifp, &bma->icur); 1688c38ccf59SChristoph Hellwig xfs_iext_remove(bma->ip, &bma->icur, state); 1689b2b1712aSChristoph Hellwig xfs_iext_prev(ifp, &bma->icur); 1690b2b1712aSChristoph Hellwig xfs_iext_update_extent(bma->ip, state, &bma->icur, &PREV); 169130f712c9SDave Chinner 169230f712c9SDave Chinner if (bma->cur == NULL) 169330f712c9SDave Chinner rval = XFS_ILOG_DEXT; 169430f712c9SDave Chinner else { 169530f712c9SDave Chinner rval = 0; 1696e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(bma->cur, &RIGHT, &i); 169730f712c9SDave Chinner if (error) 169830f712c9SDave Chinner goto done; 1699c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 1700a67d00a5SChristoph Hellwig error = xfs_bmbt_update(bma->cur, &PREV); 170130f712c9SDave Chinner if (error) 170230f712c9SDave Chinner goto done; 170330f712c9SDave Chinner } 170430f712c9SDave Chinner break; 170530f712c9SDave Chinner 170630f712c9SDave Chinner case BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING: 170730f712c9SDave Chinner /* 170830f712c9SDave Chinner * Filling in all of a previously delayed allocation extent. 170930f712c9SDave Chinner * Neither the left nor right neighbors are contiguous with 171030f712c9SDave Chinner * the new one. 171130f712c9SDave Chinner */ 17124dcb8869SChristoph Hellwig PREV.br_startblock = new->br_startblock; 17134dcb8869SChristoph Hellwig PREV.br_state = new->br_state; 1714b2b1712aSChristoph Hellwig xfs_iext_update_extent(bma->ip, state, &bma->icur, &PREV); 171530f712c9SDave Chinner 171660b4984fSDarrick J. Wong (*nextents)++; 171730f712c9SDave Chinner if (bma->cur == NULL) 171830f712c9SDave Chinner rval = XFS_ILOG_CORE | XFS_ILOG_DEXT; 171930f712c9SDave Chinner else { 172030f712c9SDave Chinner rval = XFS_ILOG_CORE; 1721e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(bma->cur, new, &i); 172230f712c9SDave Chinner if (error) 172330f712c9SDave Chinner goto done; 1724c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 0, done); 172530f712c9SDave Chinner error = xfs_btree_insert(bma->cur, &i); 172630f712c9SDave Chinner if (error) 172730f712c9SDave Chinner goto done; 1728c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 172930f712c9SDave Chinner } 173030f712c9SDave Chinner break; 173130f712c9SDave Chinner 173230f712c9SDave Chinner case BMAP_LEFT_FILLING | BMAP_LEFT_CONTIG: 173330f712c9SDave Chinner /* 173430f712c9SDave Chinner * Filling in the first part of a previous delayed allocation. 173530f712c9SDave Chinner * The left neighbor is contiguous. 173630f712c9SDave Chinner */ 17374dcb8869SChristoph Hellwig old = LEFT; 17384dcb8869SChristoph Hellwig temp = PREV.br_blockcount - new->br_blockcount; 17394dcb8869SChristoph Hellwig da_new = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(bma->ip, temp), 17404dcb8869SChristoph Hellwig startblockval(PREV.br_startblock)); 17414dcb8869SChristoph Hellwig 17424dcb8869SChristoph Hellwig LEFT.br_blockcount += new->br_blockcount; 174330f712c9SDave Chinner 1744bf99971cSChristoph Hellwig PREV.br_blockcount = temp; 17454dcb8869SChristoph Hellwig PREV.br_startoff += new->br_blockcount; 17464dcb8869SChristoph Hellwig PREV.br_startblock = nullstartblock(da_new); 17470d045540SChristoph Hellwig 1748b2b1712aSChristoph Hellwig xfs_iext_update_extent(bma->ip, state, &bma->icur, &PREV); 1749b2b1712aSChristoph Hellwig xfs_iext_prev(ifp, &bma->icur); 1750b2b1712aSChristoph Hellwig xfs_iext_update_extent(bma->ip, state, &bma->icur, &LEFT); 17514dcb8869SChristoph Hellwig 175230f712c9SDave Chinner if (bma->cur == NULL) 175330f712c9SDave Chinner rval = XFS_ILOG_DEXT; 175430f712c9SDave Chinner else { 175530f712c9SDave Chinner rval = 0; 1756e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(bma->cur, &old, &i); 175730f712c9SDave Chinner if (error) 175830f712c9SDave Chinner goto done; 1759c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 1760a67d00a5SChristoph Hellwig error = xfs_bmbt_update(bma->cur, &LEFT); 176130f712c9SDave Chinner if (error) 176230f712c9SDave Chinner goto done; 176330f712c9SDave Chinner } 176430f712c9SDave Chinner break; 176530f712c9SDave Chinner 176630f712c9SDave Chinner case BMAP_LEFT_FILLING: 176730f712c9SDave Chinner /* 176830f712c9SDave Chinner * Filling in the first part of a previous delayed allocation. 176930f712c9SDave Chinner * The left neighbor is not contiguous. 177030f712c9SDave Chinner */ 1771b2b1712aSChristoph Hellwig xfs_iext_update_extent(bma->ip, state, &bma->icur, new); 177260b4984fSDarrick J. Wong (*nextents)++; 177330f712c9SDave Chinner if (bma->cur == NULL) 177430f712c9SDave Chinner rval = XFS_ILOG_CORE | XFS_ILOG_DEXT; 177530f712c9SDave Chinner else { 177630f712c9SDave Chinner rval = XFS_ILOG_CORE; 1777e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(bma->cur, new, &i); 177830f712c9SDave Chinner if (error) 177930f712c9SDave Chinner goto done; 1780c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 0, done); 178130f712c9SDave Chinner error = xfs_btree_insert(bma->cur, &i); 178230f712c9SDave Chinner if (error) 178330f712c9SDave Chinner goto done; 1784c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 178530f712c9SDave Chinner } 178630f712c9SDave Chinner 17876d3eb1ecSDarrick J. Wong if (xfs_bmap_needs_btree(bma->ip, whichfork)) { 178830f712c9SDave Chinner error = xfs_bmap_extents_to_btree(bma->tp, bma->ip, 1789280253d2SBrian Foster &bma->cur, 1, &tmp_rval, whichfork); 179030f712c9SDave Chinner rval |= tmp_rval; 179130f712c9SDave Chinner if (error) 179230f712c9SDave Chinner goto done; 179330f712c9SDave Chinner } 17944dcb8869SChristoph Hellwig 17954dcb8869SChristoph Hellwig temp = PREV.br_blockcount - new->br_blockcount; 179630f712c9SDave Chinner da_new = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(bma->ip, temp), 179730f712c9SDave Chinner startblockval(PREV.br_startblock) - 179830f712c9SDave Chinner (bma->cur ? bma->cur->bc_private.b.allocated : 0)); 17994dcb8869SChristoph Hellwig 18004dcb8869SChristoph Hellwig PREV.br_startoff = new_endoff; 18014dcb8869SChristoph Hellwig PREV.br_blockcount = temp; 18024dcb8869SChristoph Hellwig PREV.br_startblock = nullstartblock(da_new); 1803b2b1712aSChristoph Hellwig xfs_iext_next(ifp, &bma->icur); 18040254c2f2SChristoph Hellwig xfs_iext_insert(bma->ip, &bma->icur, &PREV, state); 1805b2b1712aSChristoph Hellwig xfs_iext_prev(ifp, &bma->icur); 180630f712c9SDave Chinner break; 180730f712c9SDave Chinner 180830f712c9SDave Chinner case BMAP_RIGHT_FILLING | BMAP_RIGHT_CONTIG: 180930f712c9SDave Chinner /* 181030f712c9SDave Chinner * Filling in the last part of a previous delayed allocation. 181130f712c9SDave Chinner * The right neighbor is contiguous with the new allocation. 181230f712c9SDave Chinner */ 18134dcb8869SChristoph Hellwig old = RIGHT; 18144dcb8869SChristoph Hellwig RIGHT.br_startoff = new->br_startoff; 18154dcb8869SChristoph Hellwig RIGHT.br_startblock = new->br_startblock; 18164dcb8869SChristoph Hellwig RIGHT.br_blockcount += new->br_blockcount; 18174dcb8869SChristoph Hellwig 181830f712c9SDave Chinner if (bma->cur == NULL) 181930f712c9SDave Chinner rval = XFS_ILOG_DEXT; 182030f712c9SDave Chinner else { 182130f712c9SDave Chinner rval = 0; 1822e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(bma->cur, &old, &i); 182330f712c9SDave Chinner if (error) 182430f712c9SDave Chinner goto done; 1825c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 1826a67d00a5SChristoph Hellwig error = xfs_bmbt_update(bma->cur, &RIGHT); 182730f712c9SDave Chinner if (error) 182830f712c9SDave Chinner goto done; 182930f712c9SDave Chinner } 183030f712c9SDave Chinner 18314dcb8869SChristoph Hellwig temp = PREV.br_blockcount - new->br_blockcount; 183230f712c9SDave Chinner da_new = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(bma->ip, temp), 183330f712c9SDave Chinner startblockval(PREV.br_startblock)); 18344dcb8869SChristoph Hellwig 18354dcb8869SChristoph Hellwig PREV.br_blockcount = temp; 18364dcb8869SChristoph Hellwig PREV.br_startblock = nullstartblock(da_new); 183730f712c9SDave Chinner 1838b2b1712aSChristoph Hellwig xfs_iext_update_extent(bma->ip, state, &bma->icur, &PREV); 1839b2b1712aSChristoph Hellwig xfs_iext_next(ifp, &bma->icur); 1840b2b1712aSChristoph Hellwig xfs_iext_update_extent(bma->ip, state, &bma->icur, &RIGHT); 184130f712c9SDave Chinner break; 184230f712c9SDave Chinner 184330f712c9SDave Chinner case BMAP_RIGHT_FILLING: 184430f712c9SDave Chinner /* 184530f712c9SDave Chinner * Filling in the last part of a previous delayed allocation. 184630f712c9SDave Chinner * The right neighbor is not contiguous. 184730f712c9SDave Chinner */ 1848b2b1712aSChristoph Hellwig xfs_iext_update_extent(bma->ip, state, &bma->icur, new); 184960b4984fSDarrick J. Wong (*nextents)++; 185030f712c9SDave Chinner if (bma->cur == NULL) 185130f712c9SDave Chinner rval = XFS_ILOG_CORE | XFS_ILOG_DEXT; 185230f712c9SDave Chinner else { 185330f712c9SDave Chinner rval = XFS_ILOG_CORE; 1854e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(bma->cur, new, &i); 185530f712c9SDave Chinner if (error) 185630f712c9SDave Chinner goto done; 1857c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 0, done); 185830f712c9SDave Chinner error = xfs_btree_insert(bma->cur, &i); 185930f712c9SDave Chinner if (error) 186030f712c9SDave Chinner goto done; 1861c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 186230f712c9SDave Chinner } 186330f712c9SDave Chinner 18646d3eb1ecSDarrick J. Wong if (xfs_bmap_needs_btree(bma->ip, whichfork)) { 186530f712c9SDave Chinner error = xfs_bmap_extents_to_btree(bma->tp, bma->ip, 1866280253d2SBrian Foster &bma->cur, 1, &tmp_rval, whichfork); 186730f712c9SDave Chinner rval |= tmp_rval; 186830f712c9SDave Chinner if (error) 186930f712c9SDave Chinner goto done; 187030f712c9SDave Chinner } 18714dcb8869SChristoph Hellwig 18724dcb8869SChristoph Hellwig temp = PREV.br_blockcount - new->br_blockcount; 187330f712c9SDave Chinner da_new = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(bma->ip, temp), 187430f712c9SDave Chinner startblockval(PREV.br_startblock) - 187530f712c9SDave Chinner (bma->cur ? bma->cur->bc_private.b.allocated : 0)); 18764dcb8869SChristoph Hellwig 18774dcb8869SChristoph Hellwig PREV.br_startblock = nullstartblock(da_new); 18784dcb8869SChristoph Hellwig PREV.br_blockcount = temp; 18790254c2f2SChristoph Hellwig xfs_iext_insert(bma->ip, &bma->icur, &PREV, state); 1880b2b1712aSChristoph Hellwig xfs_iext_next(ifp, &bma->icur); 188130f712c9SDave Chinner break; 188230f712c9SDave Chinner 188330f712c9SDave Chinner case 0: 188430f712c9SDave Chinner /* 188530f712c9SDave Chinner * Filling in the middle part of a previous delayed allocation. 188630f712c9SDave Chinner * Contiguity is impossible here. 188730f712c9SDave Chinner * This case is avoided almost all the time. 188830f712c9SDave Chinner * 188930f712c9SDave Chinner * We start with a delayed allocation: 189030f712c9SDave Chinner * 189130f712c9SDave Chinner * +ddddddddddddddddddddddddddddddddddddddddddddddddddddddd+ 189230f712c9SDave Chinner * PREV @ idx 189330f712c9SDave Chinner * 189430f712c9SDave Chinner * and we are allocating: 189530f712c9SDave Chinner * +rrrrrrrrrrrrrrrrr+ 189630f712c9SDave Chinner * new 189730f712c9SDave Chinner * 189830f712c9SDave Chinner * and we set it up for insertion as: 189930f712c9SDave Chinner * +ddddddddddddddddddd+rrrrrrrrrrrrrrrrr+ddddddddddddddddd+ 190030f712c9SDave Chinner * new 190130f712c9SDave Chinner * PREV @ idx LEFT RIGHT 190230f712c9SDave Chinner * inserted at idx + 1 190330f712c9SDave Chinner */ 19044dcb8869SChristoph Hellwig old = PREV; 19054dcb8869SChristoph Hellwig 19064dcb8869SChristoph Hellwig /* LEFT is the new middle */ 190730f712c9SDave Chinner LEFT = *new; 19084dcb8869SChristoph Hellwig 19094dcb8869SChristoph Hellwig /* RIGHT is the new right */ 191030f712c9SDave Chinner RIGHT.br_state = PREV.br_state; 191130f712c9SDave Chinner RIGHT.br_startoff = new_endoff; 19124dcb8869SChristoph Hellwig RIGHT.br_blockcount = 19134dcb8869SChristoph Hellwig PREV.br_startoff + PREV.br_blockcount - new_endoff; 19144dcb8869SChristoph Hellwig RIGHT.br_startblock = 19154dcb8869SChristoph Hellwig nullstartblock(xfs_bmap_worst_indlen(bma->ip, 19164dcb8869SChristoph Hellwig RIGHT.br_blockcount)); 19174dcb8869SChristoph Hellwig 19184dcb8869SChristoph Hellwig /* truncate PREV */ 19194dcb8869SChristoph Hellwig PREV.br_blockcount = new->br_startoff - PREV.br_startoff; 19204dcb8869SChristoph Hellwig PREV.br_startblock = 19214dcb8869SChristoph Hellwig nullstartblock(xfs_bmap_worst_indlen(bma->ip, 19224dcb8869SChristoph Hellwig PREV.br_blockcount)); 1923b2b1712aSChristoph Hellwig xfs_iext_update_extent(bma->ip, state, &bma->icur, &PREV); 19244dcb8869SChristoph Hellwig 1925b2b1712aSChristoph Hellwig xfs_iext_next(ifp, &bma->icur); 19260254c2f2SChristoph Hellwig xfs_iext_insert(bma->ip, &bma->icur, &RIGHT, state); 19270254c2f2SChristoph Hellwig xfs_iext_insert(bma->ip, &bma->icur, &LEFT, state); 192860b4984fSDarrick J. Wong (*nextents)++; 19294dcb8869SChristoph Hellwig 193030f712c9SDave Chinner if (bma->cur == NULL) 193130f712c9SDave Chinner rval = XFS_ILOG_CORE | XFS_ILOG_DEXT; 193230f712c9SDave Chinner else { 193330f712c9SDave Chinner rval = XFS_ILOG_CORE; 1934e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(bma->cur, new, &i); 193530f712c9SDave Chinner if (error) 193630f712c9SDave Chinner goto done; 1937c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 0, done); 193830f712c9SDave Chinner error = xfs_btree_insert(bma->cur, &i); 193930f712c9SDave Chinner if (error) 194030f712c9SDave Chinner goto done; 1941c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 194230f712c9SDave Chinner } 194330f712c9SDave Chinner 19446d3eb1ecSDarrick J. Wong if (xfs_bmap_needs_btree(bma->ip, whichfork)) { 194530f712c9SDave Chinner error = xfs_bmap_extents_to_btree(bma->tp, bma->ip, 1946280253d2SBrian Foster &bma->cur, 1, &tmp_rval, whichfork); 194730f712c9SDave Chinner rval |= tmp_rval; 194830f712c9SDave Chinner if (error) 194930f712c9SDave Chinner goto done; 195030f712c9SDave Chinner } 19514dcb8869SChristoph Hellwig 19524dcb8869SChristoph Hellwig da_new = startblockval(PREV.br_startblock) + 19534dcb8869SChristoph Hellwig startblockval(RIGHT.br_startblock); 195430f712c9SDave Chinner break; 195530f712c9SDave Chinner 195630f712c9SDave Chinner case BMAP_LEFT_FILLING | BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG: 195730f712c9SDave Chinner case BMAP_RIGHT_FILLING | BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG: 195830f712c9SDave Chinner case BMAP_LEFT_FILLING | BMAP_RIGHT_CONTIG: 195930f712c9SDave Chinner case BMAP_RIGHT_FILLING | BMAP_LEFT_CONTIG: 196030f712c9SDave Chinner case BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG: 196130f712c9SDave Chinner case BMAP_LEFT_CONTIG: 196230f712c9SDave Chinner case BMAP_RIGHT_CONTIG: 196330f712c9SDave Chinner /* 196430f712c9SDave Chinner * These cases are all impossible. 196530f712c9SDave Chinner */ 196630f712c9SDave Chinner ASSERT(0); 196730f712c9SDave Chinner } 196830f712c9SDave Chinner 196995eb308cSDarrick J. Wong /* add reverse mapping unless caller opted out */ 197095eb308cSDarrick J. Wong if (!(bma->flags & XFS_BMAPI_NORMAP)) { 19713e3673e3SBrian Foster error = xfs_rmap_map_extent(mp, bma->tp->t_dfops, bma->ip, 197295eb308cSDarrick J. Wong whichfork, new); 19739c194644SDarrick J. Wong if (error) 19749c194644SDarrick J. Wong goto done; 197595eb308cSDarrick J. Wong } 19769c194644SDarrick J. Wong 197730f712c9SDave Chinner /* convert to a btree if necessary */ 19786d3eb1ecSDarrick J. Wong if (xfs_bmap_needs_btree(bma->ip, whichfork)) { 197930f712c9SDave Chinner int tmp_logflags; /* partial log flag return val */ 198030f712c9SDave Chinner 198130f712c9SDave Chinner ASSERT(bma->cur == NULL); 198230f712c9SDave Chinner error = xfs_bmap_extents_to_btree(bma->tp, bma->ip, 1983280253d2SBrian Foster &bma->cur, da_old > 0, &tmp_logflags, 1984280253d2SBrian Foster whichfork); 198530f712c9SDave Chinner bma->logflags |= tmp_logflags; 198630f712c9SDave Chinner if (error) 198730f712c9SDave Chinner goto done; 198830f712c9SDave Chinner } 198930f712c9SDave Chinner 1990ca1862b0SChristoph Hellwig if (bma->cur) { 1991ca1862b0SChristoph Hellwig da_new += bma->cur->bc_private.b.allocated; 1992ca1862b0SChristoph Hellwig bma->cur->bc_private.b.allocated = 0; 199330f712c9SDave Chinner } 199430f712c9SDave Chinner 1995ca1862b0SChristoph Hellwig /* adjust for changes in reserved delayed indirect blocks */ 1996ca1862b0SChristoph Hellwig if (da_new != da_old) { 1997ca1862b0SChristoph Hellwig ASSERT(state == 0 || da_new < da_old); 1998ca1862b0SChristoph Hellwig error = xfs_mod_fdblocks(mp, (int64_t)(da_old - da_new), 1999ca1862b0SChristoph Hellwig false); 2000ca1862b0SChristoph Hellwig } 200130f712c9SDave Chinner 20026d3eb1ecSDarrick J. Wong xfs_bmap_check_leaf_extents(bma->cur, bma->ip, whichfork); 200330f712c9SDave Chinner done: 200460b4984fSDarrick J. Wong if (whichfork != XFS_COW_FORK) 200530f712c9SDave Chinner bma->logflags |= rval; 200630f712c9SDave Chinner return error; 200730f712c9SDave Chinner #undef LEFT 200830f712c9SDave Chinner #undef RIGHT 200930f712c9SDave Chinner #undef PREV 201030f712c9SDave Chinner } 201130f712c9SDave Chinner 201230f712c9SDave Chinner /* 201330f712c9SDave Chinner * Convert an unwritten allocation to a real allocation or vice versa. 201430f712c9SDave Chinner */ 201530f712c9SDave Chinner STATIC int /* error */ 201630f712c9SDave Chinner xfs_bmap_add_extent_unwritten_real( 201730f712c9SDave Chinner struct xfs_trans *tp, 201830f712c9SDave Chinner xfs_inode_t *ip, /* incore inode pointer */ 201905a630d7SDarrick J. Wong int whichfork, 2020b2b1712aSChristoph Hellwig struct xfs_iext_cursor *icur, 202130f712c9SDave Chinner xfs_btree_cur_t **curp, /* if *curp is null, not a btree */ 202230f712c9SDave Chinner xfs_bmbt_irec_t *new, /* new data to add to file extents */ 202330f712c9SDave Chinner int *logflagsp) /* inode logging flags */ 202430f712c9SDave Chinner { 202530f712c9SDave Chinner xfs_btree_cur_t *cur; /* btree cursor */ 202630f712c9SDave Chinner int error; /* error return value */ 202730f712c9SDave Chinner int i; /* temp state */ 202830f712c9SDave Chinner xfs_ifork_t *ifp; /* inode fork pointer */ 202930f712c9SDave Chinner xfs_fileoff_t new_endoff; /* end offset of new entry */ 203030f712c9SDave Chinner xfs_bmbt_irec_t r[3]; /* neighbor extent entries */ 203130f712c9SDave Chinner /* left is 0, right is 1, prev is 2 */ 203230f712c9SDave Chinner int rval=0; /* return value (logging flags) */ 2033060ea65bSChristoph Hellwig int state = xfs_bmap_fork_to_state(whichfork); 203405a630d7SDarrick J. Wong struct xfs_mount *mp = ip->i_mount; 203579fa6143SChristoph Hellwig struct xfs_bmbt_irec old; 203681ba8f3eSBrian Foster struct xfs_defer_ops *dfops = tp ? tp->t_dfops : NULL; 203730f712c9SDave Chinner 203830f712c9SDave Chinner *logflagsp = 0; 203930f712c9SDave Chinner 204030f712c9SDave Chinner cur = *curp; 204105a630d7SDarrick J. Wong ifp = XFS_IFORK_PTR(ip, whichfork); 204230f712c9SDave Chinner 204330f712c9SDave Chinner ASSERT(!isnullstartblock(new->br_startblock)); 204430f712c9SDave Chinner 2045ff6d6af2SBill O'Donnell XFS_STATS_INC(mp, xs_add_exlist); 204630f712c9SDave Chinner 204730f712c9SDave Chinner #define LEFT r[0] 204830f712c9SDave Chinner #define RIGHT r[1] 204930f712c9SDave Chinner #define PREV r[2] 205030f712c9SDave Chinner 205130f712c9SDave Chinner /* 205230f712c9SDave Chinner * Set up a bunch of variables to make the tests simpler. 205330f712c9SDave Chinner */ 205430f712c9SDave Chinner error = 0; 2055b2b1712aSChristoph Hellwig xfs_iext_get_extent(ifp, icur, &PREV); 205679fa6143SChristoph Hellwig ASSERT(new->br_state != PREV.br_state); 205730f712c9SDave Chinner new_endoff = new->br_startoff + new->br_blockcount; 205830f712c9SDave Chinner ASSERT(PREV.br_startoff <= new->br_startoff); 205930f712c9SDave Chinner ASSERT(PREV.br_startoff + PREV.br_blockcount >= new_endoff); 206030f712c9SDave Chinner 206130f712c9SDave Chinner /* 206230f712c9SDave Chinner * Set flags determining what part of the previous oldext allocation 206330f712c9SDave Chinner * extent is being replaced by a newext allocation. 206430f712c9SDave Chinner */ 206530f712c9SDave Chinner if (PREV.br_startoff == new->br_startoff) 206630f712c9SDave Chinner state |= BMAP_LEFT_FILLING; 206730f712c9SDave Chinner if (PREV.br_startoff + PREV.br_blockcount == new_endoff) 206830f712c9SDave Chinner state |= BMAP_RIGHT_FILLING; 206930f712c9SDave Chinner 207030f712c9SDave Chinner /* 207130f712c9SDave Chinner * Check and set flags if this segment has a left neighbor. 207230f712c9SDave Chinner * Don't set contiguous if the combined extent would be too large. 207330f712c9SDave Chinner */ 2074b2b1712aSChristoph Hellwig if (xfs_iext_peek_prev_extent(ifp, icur, &LEFT)) { 207530f712c9SDave Chinner state |= BMAP_LEFT_VALID; 207630f712c9SDave Chinner if (isnullstartblock(LEFT.br_startblock)) 207730f712c9SDave Chinner state |= BMAP_LEFT_DELAY; 207830f712c9SDave Chinner } 207930f712c9SDave Chinner 208030f712c9SDave Chinner if ((state & BMAP_LEFT_VALID) && !(state & BMAP_LEFT_DELAY) && 208130f712c9SDave Chinner LEFT.br_startoff + LEFT.br_blockcount == new->br_startoff && 208230f712c9SDave Chinner LEFT.br_startblock + LEFT.br_blockcount == new->br_startblock && 208379fa6143SChristoph Hellwig LEFT.br_state == new->br_state && 208430f712c9SDave Chinner LEFT.br_blockcount + new->br_blockcount <= MAXEXTLEN) 208530f712c9SDave Chinner state |= BMAP_LEFT_CONTIG; 208630f712c9SDave Chinner 208730f712c9SDave Chinner /* 208830f712c9SDave Chinner * Check and set flags if this segment has a right neighbor. 208930f712c9SDave Chinner * Don't set contiguous if the combined extent would be too large. 209030f712c9SDave Chinner * Also check for all-three-contiguous being too large. 209130f712c9SDave Chinner */ 2092b2b1712aSChristoph Hellwig if (xfs_iext_peek_next_extent(ifp, icur, &RIGHT)) { 209330f712c9SDave Chinner state |= BMAP_RIGHT_VALID; 209430f712c9SDave Chinner if (isnullstartblock(RIGHT.br_startblock)) 209530f712c9SDave Chinner state |= BMAP_RIGHT_DELAY; 209630f712c9SDave Chinner } 209730f712c9SDave Chinner 209830f712c9SDave Chinner if ((state & BMAP_RIGHT_VALID) && !(state & BMAP_RIGHT_DELAY) && 209930f712c9SDave Chinner new_endoff == RIGHT.br_startoff && 210030f712c9SDave Chinner new->br_startblock + new->br_blockcount == RIGHT.br_startblock && 210179fa6143SChristoph Hellwig new->br_state == RIGHT.br_state && 210230f712c9SDave Chinner new->br_blockcount + RIGHT.br_blockcount <= MAXEXTLEN && 210330f712c9SDave Chinner ((state & (BMAP_LEFT_CONTIG | BMAP_LEFT_FILLING | 210430f712c9SDave Chinner BMAP_RIGHT_FILLING)) != 210530f712c9SDave Chinner (BMAP_LEFT_CONTIG | BMAP_LEFT_FILLING | 210630f712c9SDave Chinner BMAP_RIGHT_FILLING) || 210730f712c9SDave Chinner LEFT.br_blockcount + new->br_blockcount + RIGHT.br_blockcount 210830f712c9SDave Chinner <= MAXEXTLEN)) 210930f712c9SDave Chinner state |= BMAP_RIGHT_CONTIG; 211030f712c9SDave Chinner 211130f712c9SDave Chinner /* 211230f712c9SDave Chinner * Switch out based on the FILLING and CONTIG state bits. 211330f712c9SDave Chinner */ 211430f712c9SDave Chinner switch (state & (BMAP_LEFT_FILLING | BMAP_LEFT_CONTIG | 211530f712c9SDave Chinner BMAP_RIGHT_FILLING | BMAP_RIGHT_CONTIG)) { 211630f712c9SDave Chinner case BMAP_LEFT_FILLING | BMAP_LEFT_CONTIG | 211730f712c9SDave Chinner BMAP_RIGHT_FILLING | BMAP_RIGHT_CONTIG: 211830f712c9SDave Chinner /* 211930f712c9SDave Chinner * Setting all of a previous oldext extent to newext. 212030f712c9SDave Chinner * The left and right neighbors are both contiguous with new. 212130f712c9SDave Chinner */ 212279fa6143SChristoph Hellwig LEFT.br_blockcount += PREV.br_blockcount + RIGHT.br_blockcount; 212330f712c9SDave Chinner 2124c38ccf59SChristoph Hellwig xfs_iext_remove(ip, icur, state); 2125c38ccf59SChristoph Hellwig xfs_iext_remove(ip, icur, state); 2126b2b1712aSChristoph Hellwig xfs_iext_prev(ifp, icur); 2127b2b1712aSChristoph Hellwig xfs_iext_update_extent(ip, state, icur, &LEFT); 212805a630d7SDarrick J. Wong XFS_IFORK_NEXT_SET(ip, whichfork, 212905a630d7SDarrick J. Wong XFS_IFORK_NEXTENTS(ip, whichfork) - 2); 213030f712c9SDave Chinner if (cur == NULL) 213130f712c9SDave Chinner rval = XFS_ILOG_CORE | XFS_ILOG_DEXT; 213230f712c9SDave Chinner else { 213330f712c9SDave Chinner rval = XFS_ILOG_CORE; 2134e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(cur, &RIGHT, &i); 2135e16cf9b0SChristoph Hellwig if (error) 213630f712c9SDave Chinner goto done; 2137c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 213830f712c9SDave Chinner if ((error = xfs_btree_delete(cur, &i))) 213930f712c9SDave Chinner goto done; 2140c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 214130f712c9SDave Chinner if ((error = xfs_btree_decrement(cur, 0, &i))) 214230f712c9SDave Chinner goto done; 2143c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 214430f712c9SDave Chinner if ((error = xfs_btree_delete(cur, &i))) 214530f712c9SDave Chinner goto done; 2146c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 214730f712c9SDave Chinner if ((error = xfs_btree_decrement(cur, 0, &i))) 214830f712c9SDave Chinner goto done; 2149c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 2150a67d00a5SChristoph Hellwig error = xfs_bmbt_update(cur, &LEFT); 215179fa6143SChristoph Hellwig if (error) 215230f712c9SDave Chinner goto done; 215330f712c9SDave Chinner } 215430f712c9SDave Chinner break; 215530f712c9SDave Chinner 215630f712c9SDave Chinner case BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING | BMAP_LEFT_CONTIG: 215730f712c9SDave Chinner /* 215830f712c9SDave Chinner * Setting all of a previous oldext extent to newext. 215930f712c9SDave Chinner * The left neighbor is contiguous, the right is not. 216030f712c9SDave Chinner */ 216179fa6143SChristoph Hellwig LEFT.br_blockcount += PREV.br_blockcount; 216230f712c9SDave Chinner 2163c38ccf59SChristoph Hellwig xfs_iext_remove(ip, icur, state); 2164b2b1712aSChristoph Hellwig xfs_iext_prev(ifp, icur); 2165b2b1712aSChristoph Hellwig xfs_iext_update_extent(ip, state, icur, &LEFT); 216605a630d7SDarrick J. Wong XFS_IFORK_NEXT_SET(ip, whichfork, 216705a630d7SDarrick J. Wong XFS_IFORK_NEXTENTS(ip, whichfork) - 1); 216830f712c9SDave Chinner if (cur == NULL) 216930f712c9SDave Chinner rval = XFS_ILOG_CORE | XFS_ILOG_DEXT; 217030f712c9SDave Chinner else { 217130f712c9SDave Chinner rval = XFS_ILOG_CORE; 2172e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(cur, &PREV, &i); 2173e16cf9b0SChristoph Hellwig if (error) 217430f712c9SDave Chinner goto done; 2175c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 217630f712c9SDave Chinner if ((error = xfs_btree_delete(cur, &i))) 217730f712c9SDave Chinner goto done; 2178c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 217930f712c9SDave Chinner if ((error = xfs_btree_decrement(cur, 0, &i))) 218030f712c9SDave Chinner goto done; 2181c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 2182a67d00a5SChristoph Hellwig error = xfs_bmbt_update(cur, &LEFT); 218379fa6143SChristoph Hellwig if (error) 218430f712c9SDave Chinner goto done; 218530f712c9SDave Chinner } 218630f712c9SDave Chinner break; 218730f712c9SDave Chinner 218830f712c9SDave Chinner case BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING | BMAP_RIGHT_CONTIG: 218930f712c9SDave Chinner /* 219030f712c9SDave Chinner * Setting all of a previous oldext extent to newext. 219130f712c9SDave Chinner * The right neighbor is contiguous, the left is not. 219230f712c9SDave Chinner */ 219379fa6143SChristoph Hellwig PREV.br_blockcount += RIGHT.br_blockcount; 219479fa6143SChristoph Hellwig PREV.br_state = new->br_state; 2195a6818477SChristoph Hellwig 2196b2b1712aSChristoph Hellwig xfs_iext_next(ifp, icur); 2197c38ccf59SChristoph Hellwig xfs_iext_remove(ip, icur, state); 2198b2b1712aSChristoph Hellwig xfs_iext_prev(ifp, icur); 2199b2b1712aSChristoph Hellwig xfs_iext_update_extent(ip, state, icur, &PREV); 220079fa6143SChristoph Hellwig 220105a630d7SDarrick J. Wong XFS_IFORK_NEXT_SET(ip, whichfork, 220205a630d7SDarrick J. Wong XFS_IFORK_NEXTENTS(ip, whichfork) - 1); 220330f712c9SDave Chinner if (cur == NULL) 220430f712c9SDave Chinner rval = XFS_ILOG_CORE | XFS_ILOG_DEXT; 220530f712c9SDave Chinner else { 220630f712c9SDave Chinner rval = XFS_ILOG_CORE; 2207e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(cur, &RIGHT, &i); 2208e16cf9b0SChristoph Hellwig if (error) 220930f712c9SDave Chinner goto done; 2210c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 221130f712c9SDave Chinner if ((error = xfs_btree_delete(cur, &i))) 221230f712c9SDave Chinner goto done; 2213c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 221430f712c9SDave Chinner if ((error = xfs_btree_decrement(cur, 0, &i))) 221530f712c9SDave Chinner goto done; 2216c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 2217a67d00a5SChristoph Hellwig error = xfs_bmbt_update(cur, &PREV); 221879fa6143SChristoph Hellwig if (error) 221930f712c9SDave Chinner goto done; 222030f712c9SDave Chinner } 222130f712c9SDave Chinner break; 222230f712c9SDave Chinner 222330f712c9SDave Chinner case BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING: 222430f712c9SDave Chinner /* 222530f712c9SDave Chinner * Setting all of a previous oldext extent to newext. 222630f712c9SDave Chinner * Neither the left nor right neighbors are contiguous with 222730f712c9SDave Chinner * the new one. 222830f712c9SDave Chinner */ 222979fa6143SChristoph Hellwig PREV.br_state = new->br_state; 2230b2b1712aSChristoph Hellwig xfs_iext_update_extent(ip, state, icur, &PREV); 223130f712c9SDave Chinner 223230f712c9SDave Chinner if (cur == NULL) 223330f712c9SDave Chinner rval = XFS_ILOG_DEXT; 223430f712c9SDave Chinner else { 223530f712c9SDave Chinner rval = 0; 2236e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(cur, new, &i); 2237e16cf9b0SChristoph Hellwig if (error) 223830f712c9SDave Chinner goto done; 2239c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 2240a67d00a5SChristoph Hellwig error = xfs_bmbt_update(cur, &PREV); 224179fa6143SChristoph Hellwig if (error) 224230f712c9SDave Chinner goto done; 224330f712c9SDave Chinner } 224430f712c9SDave Chinner break; 224530f712c9SDave Chinner 224630f712c9SDave Chinner case BMAP_LEFT_FILLING | BMAP_LEFT_CONTIG: 224730f712c9SDave Chinner /* 224830f712c9SDave Chinner * Setting the first part of a previous oldext extent to newext. 224930f712c9SDave Chinner * The left neighbor is contiguous. 225030f712c9SDave Chinner */ 225179fa6143SChristoph Hellwig LEFT.br_blockcount += new->br_blockcount; 225230f712c9SDave Chinner 225379fa6143SChristoph Hellwig old = PREV; 225479fa6143SChristoph Hellwig PREV.br_startoff += new->br_blockcount; 225579fa6143SChristoph Hellwig PREV.br_startblock += new->br_blockcount; 225679fa6143SChristoph Hellwig PREV.br_blockcount -= new->br_blockcount; 225730f712c9SDave Chinner 2258b2b1712aSChristoph Hellwig xfs_iext_update_extent(ip, state, icur, &PREV); 2259b2b1712aSChristoph Hellwig xfs_iext_prev(ifp, icur); 2260b2b1712aSChristoph Hellwig xfs_iext_update_extent(ip, state, icur, &LEFT); 226130f712c9SDave Chinner 226230f712c9SDave Chinner if (cur == NULL) 226330f712c9SDave Chinner rval = XFS_ILOG_DEXT; 226430f712c9SDave Chinner else { 226530f712c9SDave Chinner rval = 0; 2266e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(cur, &old, &i); 226779fa6143SChristoph Hellwig if (error) 226830f712c9SDave Chinner goto done; 2269c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 2270a67d00a5SChristoph Hellwig error = xfs_bmbt_update(cur, &PREV); 227179fa6143SChristoph Hellwig if (error) 227230f712c9SDave Chinner goto done; 227379fa6143SChristoph Hellwig error = xfs_btree_decrement(cur, 0, &i); 227479fa6143SChristoph Hellwig if (error) 227530f712c9SDave Chinner goto done; 2276a67d00a5SChristoph Hellwig error = xfs_bmbt_update(cur, &LEFT); 227730f712c9SDave Chinner if (error) 227830f712c9SDave Chinner goto done; 227930f712c9SDave Chinner } 228030f712c9SDave Chinner break; 228130f712c9SDave Chinner 228230f712c9SDave Chinner case BMAP_LEFT_FILLING: 228330f712c9SDave Chinner /* 228430f712c9SDave Chinner * Setting the first part of a previous oldext extent to newext. 228530f712c9SDave Chinner * The left neighbor is not contiguous. 228630f712c9SDave Chinner */ 228779fa6143SChristoph Hellwig old = PREV; 228879fa6143SChristoph Hellwig PREV.br_startoff += new->br_blockcount; 228979fa6143SChristoph Hellwig PREV.br_startblock += new->br_blockcount; 229079fa6143SChristoph Hellwig PREV.br_blockcount -= new->br_blockcount; 229130f712c9SDave Chinner 2292b2b1712aSChristoph Hellwig xfs_iext_update_extent(ip, state, icur, &PREV); 22930254c2f2SChristoph Hellwig xfs_iext_insert(ip, icur, new, state); 229405a630d7SDarrick J. Wong XFS_IFORK_NEXT_SET(ip, whichfork, 229505a630d7SDarrick J. Wong XFS_IFORK_NEXTENTS(ip, whichfork) + 1); 229630f712c9SDave Chinner if (cur == NULL) 229730f712c9SDave Chinner rval = XFS_ILOG_CORE | XFS_ILOG_DEXT; 229830f712c9SDave Chinner else { 229930f712c9SDave Chinner rval = XFS_ILOG_CORE; 2300e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(cur, &old, &i); 230179fa6143SChristoph Hellwig if (error) 230230f712c9SDave Chinner goto done; 2303c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 2304a67d00a5SChristoph Hellwig error = xfs_bmbt_update(cur, &PREV); 230579fa6143SChristoph Hellwig if (error) 230630f712c9SDave Chinner goto done; 230730f712c9SDave Chinner cur->bc_rec.b = *new; 230830f712c9SDave Chinner if ((error = xfs_btree_insert(cur, &i))) 230930f712c9SDave Chinner goto done; 2310c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 231130f712c9SDave Chinner } 231230f712c9SDave Chinner break; 231330f712c9SDave Chinner 231430f712c9SDave Chinner case BMAP_RIGHT_FILLING | BMAP_RIGHT_CONTIG: 231530f712c9SDave Chinner /* 231630f712c9SDave Chinner * Setting the last part of a previous oldext extent to newext. 231730f712c9SDave Chinner * The right neighbor is contiguous with the new allocation. 231830f712c9SDave Chinner */ 231979fa6143SChristoph Hellwig old = PREV; 232079fa6143SChristoph Hellwig PREV.br_blockcount -= new->br_blockcount; 232130f712c9SDave Chinner 232279fa6143SChristoph Hellwig RIGHT.br_startoff = new->br_startoff; 232379fa6143SChristoph Hellwig RIGHT.br_startblock = new->br_startblock; 232479fa6143SChristoph Hellwig RIGHT.br_blockcount += new->br_blockcount; 2325a6818477SChristoph Hellwig 2326b2b1712aSChristoph Hellwig xfs_iext_update_extent(ip, state, icur, &PREV); 2327b2b1712aSChristoph Hellwig xfs_iext_next(ifp, icur); 2328b2b1712aSChristoph Hellwig xfs_iext_update_extent(ip, state, icur, &RIGHT); 232930f712c9SDave Chinner 233030f712c9SDave Chinner if (cur == NULL) 233130f712c9SDave Chinner rval = XFS_ILOG_DEXT; 233230f712c9SDave Chinner else { 233330f712c9SDave Chinner rval = 0; 2334e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(cur, &old, &i); 233579fa6143SChristoph Hellwig if (error) 233630f712c9SDave Chinner goto done; 2337c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 2338a67d00a5SChristoph Hellwig error = xfs_bmbt_update(cur, &PREV); 233979fa6143SChristoph Hellwig if (error) 234030f712c9SDave Chinner goto done; 234179fa6143SChristoph Hellwig error = xfs_btree_increment(cur, 0, &i); 234279fa6143SChristoph Hellwig if (error) 234330f712c9SDave Chinner goto done; 2344a67d00a5SChristoph Hellwig error = xfs_bmbt_update(cur, &RIGHT); 234579fa6143SChristoph Hellwig if (error) 234630f712c9SDave Chinner goto done; 234730f712c9SDave Chinner } 234830f712c9SDave Chinner break; 234930f712c9SDave Chinner 235030f712c9SDave Chinner case BMAP_RIGHT_FILLING: 235130f712c9SDave Chinner /* 235230f712c9SDave Chinner * Setting the last part of a previous oldext extent to newext. 235330f712c9SDave Chinner * The right neighbor is not contiguous. 235430f712c9SDave Chinner */ 235579fa6143SChristoph Hellwig old = PREV; 235679fa6143SChristoph Hellwig PREV.br_blockcount -= new->br_blockcount; 235730f712c9SDave Chinner 2358b2b1712aSChristoph Hellwig xfs_iext_update_extent(ip, state, icur, &PREV); 2359b2b1712aSChristoph Hellwig xfs_iext_next(ifp, icur); 23600254c2f2SChristoph Hellwig xfs_iext_insert(ip, icur, new, state); 236130f712c9SDave Chinner 236205a630d7SDarrick J. Wong XFS_IFORK_NEXT_SET(ip, whichfork, 236305a630d7SDarrick J. Wong XFS_IFORK_NEXTENTS(ip, whichfork) + 1); 236430f712c9SDave Chinner if (cur == NULL) 236530f712c9SDave Chinner rval = XFS_ILOG_CORE | XFS_ILOG_DEXT; 236630f712c9SDave Chinner else { 236730f712c9SDave Chinner rval = XFS_ILOG_CORE; 2368e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(cur, &old, &i); 236979fa6143SChristoph Hellwig if (error) 237030f712c9SDave Chinner goto done; 2371c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 2372a67d00a5SChristoph Hellwig error = xfs_bmbt_update(cur, &PREV); 237379fa6143SChristoph Hellwig if (error) 237430f712c9SDave Chinner goto done; 2375e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(cur, new, &i); 2376e16cf9b0SChristoph Hellwig if (error) 237730f712c9SDave Chinner goto done; 2378c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 0, done); 237930f712c9SDave Chinner if ((error = xfs_btree_insert(cur, &i))) 238030f712c9SDave Chinner goto done; 2381c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 238230f712c9SDave Chinner } 238330f712c9SDave Chinner break; 238430f712c9SDave Chinner 238530f712c9SDave Chinner case 0: 238630f712c9SDave Chinner /* 238730f712c9SDave Chinner * Setting the middle part of a previous oldext extent to 238830f712c9SDave Chinner * newext. Contiguity is impossible here. 238930f712c9SDave Chinner * One extent becomes three extents. 239030f712c9SDave Chinner */ 239179fa6143SChristoph Hellwig old = PREV; 239279fa6143SChristoph Hellwig PREV.br_blockcount = new->br_startoff - PREV.br_startoff; 239330f712c9SDave Chinner 239430f712c9SDave Chinner r[0] = *new; 239530f712c9SDave Chinner r[1].br_startoff = new_endoff; 239630f712c9SDave Chinner r[1].br_blockcount = 239779fa6143SChristoph Hellwig old.br_startoff + old.br_blockcount - new_endoff; 239830f712c9SDave Chinner r[1].br_startblock = new->br_startblock + new->br_blockcount; 239979fa6143SChristoph Hellwig r[1].br_state = PREV.br_state; 240030f712c9SDave Chinner 2401b2b1712aSChristoph Hellwig xfs_iext_update_extent(ip, state, icur, &PREV); 2402b2b1712aSChristoph Hellwig xfs_iext_next(ifp, icur); 24030254c2f2SChristoph Hellwig xfs_iext_insert(ip, icur, &r[1], state); 24040254c2f2SChristoph Hellwig xfs_iext_insert(ip, icur, &r[0], state); 240530f712c9SDave Chinner 240605a630d7SDarrick J. Wong XFS_IFORK_NEXT_SET(ip, whichfork, 240705a630d7SDarrick J. Wong XFS_IFORK_NEXTENTS(ip, whichfork) + 2); 240830f712c9SDave Chinner if (cur == NULL) 240930f712c9SDave Chinner rval = XFS_ILOG_CORE | XFS_ILOG_DEXT; 241030f712c9SDave Chinner else { 241130f712c9SDave Chinner rval = XFS_ILOG_CORE; 2412e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(cur, &old, &i); 241379fa6143SChristoph Hellwig if (error) 241430f712c9SDave Chinner goto done; 2415c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 241630f712c9SDave Chinner /* new right extent - oldext */ 2417a67d00a5SChristoph Hellwig error = xfs_bmbt_update(cur, &r[1]); 2418a67d00a5SChristoph Hellwig if (error) 241930f712c9SDave Chinner goto done; 242030f712c9SDave Chinner /* new left extent - oldext */ 242130f712c9SDave Chinner cur->bc_rec.b = PREV; 242230f712c9SDave Chinner if ((error = xfs_btree_insert(cur, &i))) 242330f712c9SDave Chinner goto done; 2424c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 242530f712c9SDave Chinner /* 242630f712c9SDave Chinner * Reset the cursor to the position of the new extent 242730f712c9SDave Chinner * we are about to insert as we can't trust it after 242830f712c9SDave Chinner * the previous insert. 242930f712c9SDave Chinner */ 2430e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(cur, new, &i); 2431e16cf9b0SChristoph Hellwig if (error) 243230f712c9SDave Chinner goto done; 2433c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 0, done); 243430f712c9SDave Chinner /* new middle extent - newext */ 243530f712c9SDave Chinner if ((error = xfs_btree_insert(cur, &i))) 243630f712c9SDave Chinner goto done; 2437c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 243830f712c9SDave Chinner } 243930f712c9SDave Chinner break; 244030f712c9SDave Chinner 244130f712c9SDave Chinner case BMAP_LEFT_FILLING | BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG: 244230f712c9SDave Chinner case BMAP_RIGHT_FILLING | BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG: 244330f712c9SDave Chinner case BMAP_LEFT_FILLING | BMAP_RIGHT_CONTIG: 244430f712c9SDave Chinner case BMAP_RIGHT_FILLING | BMAP_LEFT_CONTIG: 244530f712c9SDave Chinner case BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG: 244630f712c9SDave Chinner case BMAP_LEFT_CONTIG: 244730f712c9SDave Chinner case BMAP_RIGHT_CONTIG: 244830f712c9SDave Chinner /* 244930f712c9SDave Chinner * These cases are all impossible. 245030f712c9SDave Chinner */ 245130f712c9SDave Chinner ASSERT(0); 245230f712c9SDave Chinner } 245330f712c9SDave Chinner 24549c194644SDarrick J. Wong /* update reverse mappings */ 245505a630d7SDarrick J. Wong error = xfs_rmap_convert_extent(mp, dfops, ip, whichfork, new); 24569c194644SDarrick J. Wong if (error) 24579c194644SDarrick J. Wong goto done; 24589c194644SDarrick J. Wong 245930f712c9SDave Chinner /* convert to a btree if necessary */ 246005a630d7SDarrick J. Wong if (xfs_bmap_needs_btree(ip, whichfork)) { 246130f712c9SDave Chinner int tmp_logflags; /* partial log flag return val */ 246230f712c9SDave Chinner 246330f712c9SDave Chinner ASSERT(cur == NULL); 2464280253d2SBrian Foster error = xfs_bmap_extents_to_btree(tp, ip, &cur, 0, 2465280253d2SBrian Foster &tmp_logflags, whichfork); 246630f712c9SDave Chinner *logflagsp |= tmp_logflags; 246730f712c9SDave Chinner if (error) 246830f712c9SDave Chinner goto done; 246930f712c9SDave Chinner } 247030f712c9SDave Chinner 247130f712c9SDave Chinner /* clear out the allocated field, done with it now in any case. */ 247230f712c9SDave Chinner if (cur) { 247330f712c9SDave Chinner cur->bc_private.b.allocated = 0; 247430f712c9SDave Chinner *curp = cur; 247530f712c9SDave Chinner } 247630f712c9SDave Chinner 247705a630d7SDarrick J. Wong xfs_bmap_check_leaf_extents(*curp, ip, whichfork); 247830f712c9SDave Chinner done: 247930f712c9SDave Chinner *logflagsp |= rval; 248030f712c9SDave Chinner return error; 248130f712c9SDave Chinner #undef LEFT 248230f712c9SDave Chinner #undef RIGHT 248330f712c9SDave Chinner #undef PREV 248430f712c9SDave Chinner } 248530f712c9SDave Chinner 248630f712c9SDave Chinner /* 248730f712c9SDave Chinner * Convert a hole to a delayed allocation. 248830f712c9SDave Chinner */ 248930f712c9SDave Chinner STATIC void 249030f712c9SDave Chinner xfs_bmap_add_extent_hole_delay( 249130f712c9SDave Chinner xfs_inode_t *ip, /* incore inode pointer */ 2492be51f811SDarrick J. Wong int whichfork, 2493b2b1712aSChristoph Hellwig struct xfs_iext_cursor *icur, 249430f712c9SDave Chinner xfs_bmbt_irec_t *new) /* new data to add to file extents */ 249530f712c9SDave Chinner { 249630f712c9SDave Chinner xfs_ifork_t *ifp; /* inode fork pointer */ 249730f712c9SDave Chinner xfs_bmbt_irec_t left; /* left neighbor extent entry */ 249830f712c9SDave Chinner xfs_filblks_t newlen=0; /* new indirect size */ 249930f712c9SDave Chinner xfs_filblks_t oldlen=0; /* old indirect size */ 250030f712c9SDave Chinner xfs_bmbt_irec_t right; /* right neighbor extent entry */ 2501060ea65bSChristoph Hellwig int state = xfs_bmap_fork_to_state(whichfork); 25023ffc18ecSChristoph Hellwig xfs_filblks_t temp; /* temp for indirect calculations */ 250330f712c9SDave Chinner 2504be51f811SDarrick J. Wong ifp = XFS_IFORK_PTR(ip, whichfork); 250530f712c9SDave Chinner ASSERT(isnullstartblock(new->br_startblock)); 250630f712c9SDave Chinner 250730f712c9SDave Chinner /* 250830f712c9SDave Chinner * Check and set flags if this segment has a left neighbor 250930f712c9SDave Chinner */ 2510b2b1712aSChristoph Hellwig if (xfs_iext_peek_prev_extent(ifp, icur, &left)) { 251130f712c9SDave Chinner state |= BMAP_LEFT_VALID; 251230f712c9SDave Chinner if (isnullstartblock(left.br_startblock)) 251330f712c9SDave Chinner state |= BMAP_LEFT_DELAY; 251430f712c9SDave Chinner } 251530f712c9SDave Chinner 251630f712c9SDave Chinner /* 251730f712c9SDave Chinner * Check and set flags if the current (right) segment exists. 251830f712c9SDave Chinner * If it doesn't exist, we're converting the hole at end-of-file. 251930f712c9SDave Chinner */ 2520b2b1712aSChristoph Hellwig if (xfs_iext_get_extent(ifp, icur, &right)) { 252130f712c9SDave Chinner state |= BMAP_RIGHT_VALID; 252230f712c9SDave Chinner if (isnullstartblock(right.br_startblock)) 252330f712c9SDave Chinner state |= BMAP_RIGHT_DELAY; 252430f712c9SDave Chinner } 252530f712c9SDave Chinner 252630f712c9SDave Chinner /* 252730f712c9SDave Chinner * Set contiguity flags on the left and right neighbors. 252830f712c9SDave Chinner * Don't let extents get too large, even if the pieces are contiguous. 252930f712c9SDave Chinner */ 253030f712c9SDave Chinner if ((state & BMAP_LEFT_VALID) && (state & BMAP_LEFT_DELAY) && 253130f712c9SDave Chinner left.br_startoff + left.br_blockcount == new->br_startoff && 253230f712c9SDave Chinner left.br_blockcount + new->br_blockcount <= MAXEXTLEN) 253330f712c9SDave Chinner state |= BMAP_LEFT_CONTIG; 253430f712c9SDave Chinner 253530f712c9SDave Chinner if ((state & BMAP_RIGHT_VALID) && (state & BMAP_RIGHT_DELAY) && 253630f712c9SDave Chinner new->br_startoff + new->br_blockcount == right.br_startoff && 253730f712c9SDave Chinner new->br_blockcount + right.br_blockcount <= MAXEXTLEN && 253830f712c9SDave Chinner (!(state & BMAP_LEFT_CONTIG) || 253930f712c9SDave Chinner (left.br_blockcount + new->br_blockcount + 254030f712c9SDave Chinner right.br_blockcount <= MAXEXTLEN))) 254130f712c9SDave Chinner state |= BMAP_RIGHT_CONTIG; 254230f712c9SDave Chinner 254330f712c9SDave Chinner /* 254430f712c9SDave Chinner * Switch out based on the contiguity flags. 254530f712c9SDave Chinner */ 254630f712c9SDave Chinner switch (state & (BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG)) { 254730f712c9SDave Chinner case BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG: 254830f712c9SDave Chinner /* 254930f712c9SDave Chinner * New allocation is contiguous with delayed allocations 255030f712c9SDave Chinner * on the left and on the right. 255130f712c9SDave Chinner * Merge all three into a single extent record. 255230f712c9SDave Chinner */ 255330f712c9SDave Chinner temp = left.br_blockcount + new->br_blockcount + 255430f712c9SDave Chinner right.br_blockcount; 255530f712c9SDave Chinner 255630f712c9SDave Chinner oldlen = startblockval(left.br_startblock) + 255730f712c9SDave Chinner startblockval(new->br_startblock) + 255830f712c9SDave Chinner startblockval(right.br_startblock); 25590e339ef8SBrian Foster newlen = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(ip, temp), 25600e339ef8SBrian Foster oldlen); 25613ffc18ecSChristoph Hellwig left.br_startblock = nullstartblock(newlen); 25623ffc18ecSChristoph Hellwig left.br_blockcount = temp; 256330f712c9SDave Chinner 2564c38ccf59SChristoph Hellwig xfs_iext_remove(ip, icur, state); 2565b2b1712aSChristoph Hellwig xfs_iext_prev(ifp, icur); 2566b2b1712aSChristoph Hellwig xfs_iext_update_extent(ip, state, icur, &left); 256730f712c9SDave Chinner break; 256830f712c9SDave Chinner 256930f712c9SDave Chinner case BMAP_LEFT_CONTIG: 257030f712c9SDave Chinner /* 257130f712c9SDave Chinner * New allocation is contiguous with a delayed allocation 257230f712c9SDave Chinner * on the left. 257330f712c9SDave Chinner * Merge the new allocation with the left neighbor. 257430f712c9SDave Chinner */ 257530f712c9SDave Chinner temp = left.br_blockcount + new->br_blockcount; 257630f712c9SDave Chinner 257730f712c9SDave Chinner oldlen = startblockval(left.br_startblock) + 257830f712c9SDave Chinner startblockval(new->br_startblock); 25790e339ef8SBrian Foster newlen = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(ip, temp), 25800e339ef8SBrian Foster oldlen); 25813ffc18ecSChristoph Hellwig left.br_blockcount = temp; 25823ffc18ecSChristoph Hellwig left.br_startblock = nullstartblock(newlen); 258341d196f4SChristoph Hellwig 2584b2b1712aSChristoph Hellwig xfs_iext_prev(ifp, icur); 2585b2b1712aSChristoph Hellwig xfs_iext_update_extent(ip, state, icur, &left); 258630f712c9SDave Chinner break; 258730f712c9SDave Chinner 258830f712c9SDave Chinner case BMAP_RIGHT_CONTIG: 258930f712c9SDave Chinner /* 259030f712c9SDave Chinner * New allocation is contiguous with a delayed allocation 259130f712c9SDave Chinner * on the right. 259230f712c9SDave Chinner * Merge the new allocation with the right neighbor. 259330f712c9SDave Chinner */ 259430f712c9SDave Chinner temp = new->br_blockcount + right.br_blockcount; 259530f712c9SDave Chinner oldlen = startblockval(new->br_startblock) + 259630f712c9SDave Chinner startblockval(right.br_startblock); 25970e339ef8SBrian Foster newlen = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(ip, temp), 25980e339ef8SBrian Foster oldlen); 25993ffc18ecSChristoph Hellwig right.br_startoff = new->br_startoff; 26003ffc18ecSChristoph Hellwig right.br_startblock = nullstartblock(newlen); 26013ffc18ecSChristoph Hellwig right.br_blockcount = temp; 2602b2b1712aSChristoph Hellwig xfs_iext_update_extent(ip, state, icur, &right); 260330f712c9SDave Chinner break; 260430f712c9SDave Chinner 260530f712c9SDave Chinner case 0: 260630f712c9SDave Chinner /* 260730f712c9SDave Chinner * New allocation is not contiguous with another 260830f712c9SDave Chinner * delayed allocation. 260930f712c9SDave Chinner * Insert a new entry. 261030f712c9SDave Chinner */ 261130f712c9SDave Chinner oldlen = newlen = 0; 26120254c2f2SChristoph Hellwig xfs_iext_insert(ip, icur, new, state); 261330f712c9SDave Chinner break; 261430f712c9SDave Chinner } 261530f712c9SDave Chinner if (oldlen != newlen) { 261630f712c9SDave Chinner ASSERT(oldlen > newlen); 26170d485adaSDave Chinner xfs_mod_fdblocks(ip->i_mount, (int64_t)(oldlen - newlen), 26180d485adaSDave Chinner false); 261930f712c9SDave Chinner /* 262030f712c9SDave Chinner * Nothing to do for disk quota accounting here. 262130f712c9SDave Chinner */ 262230f712c9SDave Chinner } 262330f712c9SDave Chinner } 262430f712c9SDave Chinner 262530f712c9SDave Chinner /* 262630f712c9SDave Chinner * Convert a hole to a real allocation. 262730f712c9SDave Chinner */ 262830f712c9SDave Chinner STATIC int /* error */ 262930f712c9SDave Chinner xfs_bmap_add_extent_hole_real( 26306d04558fSChristoph Hellwig struct xfs_trans *tp, 26316d04558fSChristoph Hellwig struct xfs_inode *ip, 26326d04558fSChristoph Hellwig int whichfork, 2633b2b1712aSChristoph Hellwig struct xfs_iext_cursor *icur, 26346d04558fSChristoph Hellwig struct xfs_btree_cur **curp, 26356d04558fSChristoph Hellwig struct xfs_bmbt_irec *new, 263695eb308cSDarrick J. Wong int *logflagsp, 263795eb308cSDarrick J. Wong int flags) 263830f712c9SDave Chinner { 26396d04558fSChristoph Hellwig struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, whichfork); 26406d04558fSChristoph Hellwig struct xfs_mount *mp = ip->i_mount; 26416d04558fSChristoph Hellwig struct xfs_btree_cur *cur = *curp; 264230f712c9SDave Chinner int error; /* error return value */ 264330f712c9SDave Chinner int i; /* temp state */ 264430f712c9SDave Chinner xfs_bmbt_irec_t left; /* left neighbor extent entry */ 264530f712c9SDave Chinner xfs_bmbt_irec_t right; /* right neighbor extent entry */ 264630f712c9SDave Chinner int rval=0; /* return value (logging flags) */ 2647060ea65bSChristoph Hellwig int state = xfs_bmap_fork_to_state(whichfork); 26481abb9e55SChristoph Hellwig struct xfs_bmbt_irec old; 264930f712c9SDave Chinner 265030f712c9SDave Chinner ASSERT(!isnullstartblock(new->br_startblock)); 26516d04558fSChristoph Hellwig ASSERT(!cur || !(cur->bc_private.b.flags & XFS_BTCUR_BPRV_WASDEL)); 265230f712c9SDave Chinner 2653ff6d6af2SBill O'Donnell XFS_STATS_INC(mp, xs_add_exlist); 265430f712c9SDave Chinner 265530f712c9SDave Chinner /* 265630f712c9SDave Chinner * Check and set flags if this segment has a left neighbor. 265730f712c9SDave Chinner */ 2658b2b1712aSChristoph Hellwig if (xfs_iext_peek_prev_extent(ifp, icur, &left)) { 265930f712c9SDave Chinner state |= BMAP_LEFT_VALID; 266030f712c9SDave Chinner if (isnullstartblock(left.br_startblock)) 266130f712c9SDave Chinner state |= BMAP_LEFT_DELAY; 266230f712c9SDave Chinner } 266330f712c9SDave Chinner 266430f712c9SDave Chinner /* 266530f712c9SDave Chinner * Check and set flags if this segment has a current value. 266630f712c9SDave Chinner * Not true if we're inserting into the "hole" at eof. 266730f712c9SDave Chinner */ 2668b2b1712aSChristoph Hellwig if (xfs_iext_get_extent(ifp, icur, &right)) { 266930f712c9SDave Chinner state |= BMAP_RIGHT_VALID; 267030f712c9SDave Chinner if (isnullstartblock(right.br_startblock)) 267130f712c9SDave Chinner state |= BMAP_RIGHT_DELAY; 267230f712c9SDave Chinner } 267330f712c9SDave Chinner 267430f712c9SDave Chinner /* 267530f712c9SDave Chinner * We're inserting a real allocation between "left" and "right". 267630f712c9SDave Chinner * Set the contiguity flags. Don't let extents get too large. 267730f712c9SDave Chinner */ 267830f712c9SDave Chinner if ((state & BMAP_LEFT_VALID) && !(state & BMAP_LEFT_DELAY) && 267930f712c9SDave Chinner left.br_startoff + left.br_blockcount == new->br_startoff && 268030f712c9SDave Chinner left.br_startblock + left.br_blockcount == new->br_startblock && 268130f712c9SDave Chinner left.br_state == new->br_state && 268230f712c9SDave Chinner left.br_blockcount + new->br_blockcount <= MAXEXTLEN) 268330f712c9SDave Chinner state |= BMAP_LEFT_CONTIG; 268430f712c9SDave Chinner 268530f712c9SDave Chinner if ((state & BMAP_RIGHT_VALID) && !(state & BMAP_RIGHT_DELAY) && 268630f712c9SDave Chinner new->br_startoff + new->br_blockcount == right.br_startoff && 268730f712c9SDave Chinner new->br_startblock + new->br_blockcount == right.br_startblock && 268830f712c9SDave Chinner new->br_state == right.br_state && 268930f712c9SDave Chinner new->br_blockcount + right.br_blockcount <= MAXEXTLEN && 269030f712c9SDave Chinner (!(state & BMAP_LEFT_CONTIG) || 269130f712c9SDave Chinner left.br_blockcount + new->br_blockcount + 269230f712c9SDave Chinner right.br_blockcount <= MAXEXTLEN)) 269330f712c9SDave Chinner state |= BMAP_RIGHT_CONTIG; 269430f712c9SDave Chinner 269530f712c9SDave Chinner error = 0; 269630f712c9SDave Chinner /* 269730f712c9SDave Chinner * Select which case we're in here, and implement it. 269830f712c9SDave Chinner */ 269930f712c9SDave Chinner switch (state & (BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG)) { 270030f712c9SDave Chinner case BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG: 270130f712c9SDave Chinner /* 270230f712c9SDave Chinner * New allocation is contiguous with real allocations on the 270330f712c9SDave Chinner * left and on the right. 270430f712c9SDave Chinner * Merge all three into a single extent record. 270530f712c9SDave Chinner */ 27061abb9e55SChristoph Hellwig left.br_blockcount += new->br_blockcount + right.br_blockcount; 270730f712c9SDave Chinner 2708c38ccf59SChristoph Hellwig xfs_iext_remove(ip, icur, state); 2709b2b1712aSChristoph Hellwig xfs_iext_prev(ifp, icur); 2710b2b1712aSChristoph Hellwig xfs_iext_update_extent(ip, state, icur, &left); 271130f712c9SDave Chinner 27126d04558fSChristoph Hellwig XFS_IFORK_NEXT_SET(ip, whichfork, 27136d04558fSChristoph Hellwig XFS_IFORK_NEXTENTS(ip, whichfork) - 1); 27146d04558fSChristoph Hellwig if (cur == NULL) { 271530f712c9SDave Chinner rval = XFS_ILOG_CORE | xfs_ilog_fext(whichfork); 271630f712c9SDave Chinner } else { 271730f712c9SDave Chinner rval = XFS_ILOG_CORE; 2718e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(cur, &right, &i); 271930f712c9SDave Chinner if (error) 272030f712c9SDave Chinner goto done; 2721c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 27226d04558fSChristoph Hellwig error = xfs_btree_delete(cur, &i); 272330f712c9SDave Chinner if (error) 272430f712c9SDave Chinner goto done; 2725c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 27266d04558fSChristoph Hellwig error = xfs_btree_decrement(cur, 0, &i); 272730f712c9SDave Chinner if (error) 272830f712c9SDave Chinner goto done; 2729c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 2730a67d00a5SChristoph Hellwig error = xfs_bmbt_update(cur, &left); 273130f712c9SDave Chinner if (error) 273230f712c9SDave Chinner goto done; 273330f712c9SDave Chinner } 273430f712c9SDave Chinner break; 273530f712c9SDave Chinner 273630f712c9SDave Chinner case BMAP_LEFT_CONTIG: 273730f712c9SDave Chinner /* 273830f712c9SDave Chinner * New allocation is contiguous with a real allocation 273930f712c9SDave Chinner * on the left. 274030f712c9SDave Chinner * Merge the new allocation with the left neighbor. 274130f712c9SDave Chinner */ 27421abb9e55SChristoph Hellwig old = left; 27431abb9e55SChristoph Hellwig left.br_blockcount += new->br_blockcount; 27441d2e0089SChristoph Hellwig 2745b2b1712aSChristoph Hellwig xfs_iext_prev(ifp, icur); 2746b2b1712aSChristoph Hellwig xfs_iext_update_extent(ip, state, icur, &left); 274730f712c9SDave Chinner 27486d04558fSChristoph Hellwig if (cur == NULL) { 274930f712c9SDave Chinner rval = xfs_ilog_fext(whichfork); 275030f712c9SDave Chinner } else { 275130f712c9SDave Chinner rval = 0; 2752e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(cur, &old, &i); 275330f712c9SDave Chinner if (error) 275430f712c9SDave Chinner goto done; 2755c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 2756a67d00a5SChristoph Hellwig error = xfs_bmbt_update(cur, &left); 275730f712c9SDave Chinner if (error) 275830f712c9SDave Chinner goto done; 275930f712c9SDave Chinner } 276030f712c9SDave Chinner break; 276130f712c9SDave Chinner 276230f712c9SDave Chinner case BMAP_RIGHT_CONTIG: 276330f712c9SDave Chinner /* 276430f712c9SDave Chinner * New allocation is contiguous with a real allocation 276530f712c9SDave Chinner * on the right. 276630f712c9SDave Chinner * Merge the new allocation with the right neighbor. 276730f712c9SDave Chinner */ 27681abb9e55SChristoph Hellwig old = right; 2769ca5d8e5bSChristoph Hellwig 27701abb9e55SChristoph Hellwig right.br_startoff = new->br_startoff; 27711abb9e55SChristoph Hellwig right.br_startblock = new->br_startblock; 27721abb9e55SChristoph Hellwig right.br_blockcount += new->br_blockcount; 2773b2b1712aSChristoph Hellwig xfs_iext_update_extent(ip, state, icur, &right); 277430f712c9SDave Chinner 27756d04558fSChristoph Hellwig if (cur == NULL) { 277630f712c9SDave Chinner rval = xfs_ilog_fext(whichfork); 277730f712c9SDave Chinner } else { 277830f712c9SDave Chinner rval = 0; 2779e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(cur, &old, &i); 278030f712c9SDave Chinner if (error) 278130f712c9SDave Chinner goto done; 2782c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 2783a67d00a5SChristoph Hellwig error = xfs_bmbt_update(cur, &right); 278430f712c9SDave Chinner if (error) 278530f712c9SDave Chinner goto done; 278630f712c9SDave Chinner } 278730f712c9SDave Chinner break; 278830f712c9SDave Chinner 278930f712c9SDave Chinner case 0: 279030f712c9SDave Chinner /* 279130f712c9SDave Chinner * New allocation is not contiguous with another 279230f712c9SDave Chinner * real allocation. 279330f712c9SDave Chinner * Insert a new entry. 279430f712c9SDave Chinner */ 27950254c2f2SChristoph Hellwig xfs_iext_insert(ip, icur, new, state); 27966d04558fSChristoph Hellwig XFS_IFORK_NEXT_SET(ip, whichfork, 27976d04558fSChristoph Hellwig XFS_IFORK_NEXTENTS(ip, whichfork) + 1); 27986d04558fSChristoph Hellwig if (cur == NULL) { 279930f712c9SDave Chinner rval = XFS_ILOG_CORE | xfs_ilog_fext(whichfork); 280030f712c9SDave Chinner } else { 280130f712c9SDave Chinner rval = XFS_ILOG_CORE; 2802e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(cur, new, &i); 280330f712c9SDave Chinner if (error) 280430f712c9SDave Chinner goto done; 2805c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 0, done); 28066d04558fSChristoph Hellwig error = xfs_btree_insert(cur, &i); 280730f712c9SDave Chinner if (error) 280830f712c9SDave Chinner goto done; 2809c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 281030f712c9SDave Chinner } 281130f712c9SDave Chinner break; 281230f712c9SDave Chinner } 281330f712c9SDave Chinner 281495eb308cSDarrick J. Wong /* add reverse mapping unless caller opted out */ 281595eb308cSDarrick J. Wong if (!(flags & XFS_BMAPI_NORMAP)) { 281681ba8f3eSBrian Foster error = xfs_rmap_map_extent(mp, tp->t_dfops, ip, whichfork, 281781ba8f3eSBrian Foster new); 28189c194644SDarrick J. Wong if (error) 28199c194644SDarrick J. Wong goto done; 282095eb308cSDarrick J. Wong } 28219c194644SDarrick J. Wong 282230f712c9SDave Chinner /* convert to a btree if necessary */ 28236d04558fSChristoph Hellwig if (xfs_bmap_needs_btree(ip, whichfork)) { 282430f712c9SDave Chinner int tmp_logflags; /* partial log flag return val */ 282530f712c9SDave Chinner 28266d04558fSChristoph Hellwig ASSERT(cur == NULL); 2827280253d2SBrian Foster error = xfs_bmap_extents_to_btree(tp, ip, curp, 0, 2828280253d2SBrian Foster &tmp_logflags, whichfork); 28296d04558fSChristoph Hellwig *logflagsp |= tmp_logflags; 28306d04558fSChristoph Hellwig cur = *curp; 283130f712c9SDave Chinner if (error) 283230f712c9SDave Chinner goto done; 283330f712c9SDave Chinner } 283430f712c9SDave Chinner 283530f712c9SDave Chinner /* clear out the allocated field, done with it now in any case. */ 28366d04558fSChristoph Hellwig if (cur) 28376d04558fSChristoph Hellwig cur->bc_private.b.allocated = 0; 283830f712c9SDave Chinner 28396d04558fSChristoph Hellwig xfs_bmap_check_leaf_extents(cur, ip, whichfork); 284030f712c9SDave Chinner done: 28416d04558fSChristoph Hellwig *logflagsp |= rval; 284230f712c9SDave Chinner return error; 284330f712c9SDave Chinner } 284430f712c9SDave Chinner 284530f712c9SDave Chinner /* 284630f712c9SDave Chinner * Functions used in the extent read, allocate and remove paths 284730f712c9SDave Chinner */ 284830f712c9SDave Chinner 284930f712c9SDave Chinner /* 285030f712c9SDave Chinner * Adjust the size of the new extent based on di_extsize and rt extsize. 285130f712c9SDave Chinner */ 285230f712c9SDave Chinner int 285330f712c9SDave Chinner xfs_bmap_extsize_align( 285430f712c9SDave Chinner xfs_mount_t *mp, 285530f712c9SDave Chinner xfs_bmbt_irec_t *gotp, /* next extent pointer */ 285630f712c9SDave Chinner xfs_bmbt_irec_t *prevp, /* previous extent pointer */ 285730f712c9SDave Chinner xfs_extlen_t extsz, /* align to this extent size */ 285830f712c9SDave Chinner int rt, /* is this a realtime inode? */ 285930f712c9SDave Chinner int eof, /* is extent at end-of-file? */ 286030f712c9SDave Chinner int delay, /* creating delalloc extent? */ 286130f712c9SDave Chinner int convert, /* overwriting unwritten extent? */ 286230f712c9SDave Chinner xfs_fileoff_t *offp, /* in/out: aligned offset */ 286330f712c9SDave Chinner xfs_extlen_t *lenp) /* in/out: aligned length */ 286430f712c9SDave Chinner { 286530f712c9SDave Chinner xfs_fileoff_t orig_off; /* original offset */ 286630f712c9SDave Chinner xfs_extlen_t orig_alen; /* original length */ 286730f712c9SDave Chinner xfs_fileoff_t orig_end; /* original off+len */ 286830f712c9SDave Chinner xfs_fileoff_t nexto; /* next file offset */ 286930f712c9SDave Chinner xfs_fileoff_t prevo; /* previous file offset */ 287030f712c9SDave Chinner xfs_fileoff_t align_off; /* temp for offset */ 287130f712c9SDave Chinner xfs_extlen_t align_alen; /* temp for length */ 287230f712c9SDave Chinner xfs_extlen_t temp; /* temp for calculations */ 287330f712c9SDave Chinner 287430f712c9SDave Chinner if (convert) 287530f712c9SDave Chinner return 0; 287630f712c9SDave Chinner 287730f712c9SDave Chinner orig_off = align_off = *offp; 287830f712c9SDave Chinner orig_alen = align_alen = *lenp; 287930f712c9SDave Chinner orig_end = orig_off + orig_alen; 288030f712c9SDave Chinner 288130f712c9SDave Chinner /* 288230f712c9SDave Chinner * If this request overlaps an existing extent, then don't 288330f712c9SDave Chinner * attempt to perform any additional alignment. 288430f712c9SDave Chinner */ 288530f712c9SDave Chinner if (!delay && !eof && 288630f712c9SDave Chinner (orig_off >= gotp->br_startoff) && 288730f712c9SDave Chinner (orig_end <= gotp->br_startoff + gotp->br_blockcount)) { 288830f712c9SDave Chinner return 0; 288930f712c9SDave Chinner } 289030f712c9SDave Chinner 289130f712c9SDave Chinner /* 289230f712c9SDave Chinner * If the file offset is unaligned vs. the extent size 289330f712c9SDave Chinner * we need to align it. This will be possible unless 289430f712c9SDave Chinner * the file was previously written with a kernel that didn't 289530f712c9SDave Chinner * perform this alignment, or if a truncate shot us in the 289630f712c9SDave Chinner * foot. 289730f712c9SDave Chinner */ 28980703a8e1SDave Chinner div_u64_rem(orig_off, extsz, &temp); 289930f712c9SDave Chinner if (temp) { 290030f712c9SDave Chinner align_alen += temp; 290130f712c9SDave Chinner align_off -= temp; 290230f712c9SDave Chinner } 29036dea405eSDave Chinner 29046dea405eSDave Chinner /* Same adjustment for the end of the requested area. */ 29056dea405eSDave Chinner temp = (align_alen % extsz); 29066dea405eSDave Chinner if (temp) 290730f712c9SDave Chinner align_alen += extsz - temp; 29086dea405eSDave Chinner 29096dea405eSDave Chinner /* 29106dea405eSDave Chinner * For large extent hint sizes, the aligned extent might be larger than 29116dea405eSDave Chinner * MAXEXTLEN. In that case, reduce the size by an extsz so that it pulls 29126dea405eSDave Chinner * the length back under MAXEXTLEN. The outer allocation loops handle 29136dea405eSDave Chinner * short allocation just fine, so it is safe to do this. We only want to 29146dea405eSDave Chinner * do it when we are forced to, though, because it means more allocation 29156dea405eSDave Chinner * operations are required. 29166dea405eSDave Chinner */ 29176dea405eSDave Chinner while (align_alen > MAXEXTLEN) 29186dea405eSDave Chinner align_alen -= extsz; 29196dea405eSDave Chinner ASSERT(align_alen <= MAXEXTLEN); 29206dea405eSDave Chinner 292130f712c9SDave Chinner /* 292230f712c9SDave Chinner * If the previous block overlaps with this proposed allocation 292330f712c9SDave Chinner * then move the start forward without adjusting the length. 292430f712c9SDave Chinner */ 292530f712c9SDave Chinner if (prevp->br_startoff != NULLFILEOFF) { 292630f712c9SDave Chinner if (prevp->br_startblock == HOLESTARTBLOCK) 292730f712c9SDave Chinner prevo = prevp->br_startoff; 292830f712c9SDave Chinner else 292930f712c9SDave Chinner prevo = prevp->br_startoff + prevp->br_blockcount; 293030f712c9SDave Chinner } else 293130f712c9SDave Chinner prevo = 0; 293230f712c9SDave Chinner if (align_off != orig_off && align_off < prevo) 293330f712c9SDave Chinner align_off = prevo; 293430f712c9SDave Chinner /* 293530f712c9SDave Chinner * If the next block overlaps with this proposed allocation 293630f712c9SDave Chinner * then move the start back without adjusting the length, 293730f712c9SDave Chinner * but not before offset 0. 293830f712c9SDave Chinner * This may of course make the start overlap previous block, 293930f712c9SDave Chinner * and if we hit the offset 0 limit then the next block 294030f712c9SDave Chinner * can still overlap too. 294130f712c9SDave Chinner */ 294230f712c9SDave Chinner if (!eof && gotp->br_startoff != NULLFILEOFF) { 294330f712c9SDave Chinner if ((delay && gotp->br_startblock == HOLESTARTBLOCK) || 294430f712c9SDave Chinner (!delay && gotp->br_startblock == DELAYSTARTBLOCK)) 294530f712c9SDave Chinner nexto = gotp->br_startoff + gotp->br_blockcount; 294630f712c9SDave Chinner else 294730f712c9SDave Chinner nexto = gotp->br_startoff; 294830f712c9SDave Chinner } else 294930f712c9SDave Chinner nexto = NULLFILEOFF; 295030f712c9SDave Chinner if (!eof && 295130f712c9SDave Chinner align_off + align_alen != orig_end && 295230f712c9SDave Chinner align_off + align_alen > nexto) 295330f712c9SDave Chinner align_off = nexto > align_alen ? nexto - align_alen : 0; 295430f712c9SDave Chinner /* 295530f712c9SDave Chinner * If we're now overlapping the next or previous extent that 295630f712c9SDave Chinner * means we can't fit an extsz piece in this hole. Just move 295730f712c9SDave Chinner * the start forward to the first valid spot and set 295830f712c9SDave Chinner * the length so we hit the end. 295930f712c9SDave Chinner */ 296030f712c9SDave Chinner if (align_off != orig_off && align_off < prevo) 296130f712c9SDave Chinner align_off = prevo; 296230f712c9SDave Chinner if (align_off + align_alen != orig_end && 296330f712c9SDave Chinner align_off + align_alen > nexto && 296430f712c9SDave Chinner nexto != NULLFILEOFF) { 296530f712c9SDave Chinner ASSERT(nexto > prevo); 296630f712c9SDave Chinner align_alen = nexto - align_off; 296730f712c9SDave Chinner } 296830f712c9SDave Chinner 296930f712c9SDave Chinner /* 297030f712c9SDave Chinner * If realtime, and the result isn't a multiple of the realtime 297130f712c9SDave Chinner * extent size we need to remove blocks until it is. 297230f712c9SDave Chinner */ 297330f712c9SDave Chinner if (rt && (temp = (align_alen % mp->m_sb.sb_rextsize))) { 297430f712c9SDave Chinner /* 297530f712c9SDave Chinner * We're not covering the original request, or 297630f712c9SDave Chinner * we won't be able to once we fix the length. 297730f712c9SDave Chinner */ 297830f712c9SDave Chinner if (orig_off < align_off || 297930f712c9SDave Chinner orig_end > align_off + align_alen || 298030f712c9SDave Chinner align_alen - temp < orig_alen) 29812451337dSDave Chinner return -EINVAL; 298230f712c9SDave Chinner /* 298330f712c9SDave Chinner * Try to fix it by moving the start up. 298430f712c9SDave Chinner */ 298530f712c9SDave Chinner if (align_off + temp <= orig_off) { 298630f712c9SDave Chinner align_alen -= temp; 298730f712c9SDave Chinner align_off += temp; 298830f712c9SDave Chinner } 298930f712c9SDave Chinner /* 299030f712c9SDave Chinner * Try to fix it by moving the end in. 299130f712c9SDave Chinner */ 299230f712c9SDave Chinner else if (align_off + align_alen - temp >= orig_end) 299330f712c9SDave Chinner align_alen -= temp; 299430f712c9SDave Chinner /* 299530f712c9SDave Chinner * Set the start to the minimum then trim the length. 299630f712c9SDave Chinner */ 299730f712c9SDave Chinner else { 299830f712c9SDave Chinner align_alen -= orig_off - align_off; 299930f712c9SDave Chinner align_off = orig_off; 300030f712c9SDave Chinner align_alen -= align_alen % mp->m_sb.sb_rextsize; 300130f712c9SDave Chinner } 300230f712c9SDave Chinner /* 300330f712c9SDave Chinner * Result doesn't cover the request, fail it. 300430f712c9SDave Chinner */ 300530f712c9SDave Chinner if (orig_off < align_off || orig_end > align_off + align_alen) 30062451337dSDave Chinner return -EINVAL; 300730f712c9SDave Chinner } else { 300830f712c9SDave Chinner ASSERT(orig_off >= align_off); 30096dea405eSDave Chinner /* see MAXEXTLEN handling above */ 30106dea405eSDave Chinner ASSERT(orig_end <= align_off + align_alen || 30116dea405eSDave Chinner align_alen + extsz > MAXEXTLEN); 301230f712c9SDave Chinner } 301330f712c9SDave Chinner 301430f712c9SDave Chinner #ifdef DEBUG 301530f712c9SDave Chinner if (!eof && gotp->br_startoff != NULLFILEOFF) 301630f712c9SDave Chinner ASSERT(align_off + align_alen <= gotp->br_startoff); 301730f712c9SDave Chinner if (prevp->br_startoff != NULLFILEOFF) 301830f712c9SDave Chinner ASSERT(align_off >= prevp->br_startoff + prevp->br_blockcount); 301930f712c9SDave Chinner #endif 302030f712c9SDave Chinner 302130f712c9SDave Chinner *lenp = align_alen; 302230f712c9SDave Chinner *offp = align_off; 302330f712c9SDave Chinner return 0; 302430f712c9SDave Chinner } 302530f712c9SDave Chinner 302630f712c9SDave Chinner #define XFS_ALLOC_GAP_UNITS 4 302730f712c9SDave Chinner 302830f712c9SDave Chinner void 302930f712c9SDave Chinner xfs_bmap_adjacent( 303030f712c9SDave Chinner struct xfs_bmalloca *ap) /* bmap alloc argument struct */ 303130f712c9SDave Chinner { 303230f712c9SDave Chinner xfs_fsblock_t adjust; /* adjustment to block numbers */ 303330f712c9SDave Chinner xfs_agnumber_t fb_agno; /* ag number of ap->firstblock */ 303430f712c9SDave Chinner xfs_mount_t *mp; /* mount point structure */ 303530f712c9SDave Chinner int nullfb; /* true if ap->firstblock isn't set */ 303630f712c9SDave Chinner int rt; /* true if inode is realtime */ 303730f712c9SDave Chinner 303830f712c9SDave Chinner #define ISVALID(x,y) \ 303930f712c9SDave Chinner (rt ? \ 304030f712c9SDave Chinner (x) < mp->m_sb.sb_rblocks : \ 304130f712c9SDave Chinner XFS_FSB_TO_AGNO(mp, x) == XFS_FSB_TO_AGNO(mp, y) && \ 304230f712c9SDave Chinner XFS_FSB_TO_AGNO(mp, x) < mp->m_sb.sb_agcount && \ 304330f712c9SDave Chinner XFS_FSB_TO_AGBNO(mp, x) < mp->m_sb.sb_agblocks) 304430f712c9SDave Chinner 304530f712c9SDave Chinner mp = ap->ip->i_mount; 304694c07b4dSBrian Foster nullfb = ap->tp->t_firstblock == NULLFSBLOCK; 3047292378edSDave Chinner rt = XFS_IS_REALTIME_INODE(ap->ip) && 3048292378edSDave Chinner xfs_alloc_is_userdata(ap->datatype); 304994c07b4dSBrian Foster fb_agno = nullfb ? NULLAGNUMBER : XFS_FSB_TO_AGNO(mp, 305094c07b4dSBrian Foster ap->tp->t_firstblock); 305130f712c9SDave Chinner /* 305230f712c9SDave Chinner * If allocating at eof, and there's a previous real block, 305330f712c9SDave Chinner * try to use its last block as our starting point. 305430f712c9SDave Chinner */ 305530f712c9SDave Chinner if (ap->eof && ap->prev.br_startoff != NULLFILEOFF && 305630f712c9SDave Chinner !isnullstartblock(ap->prev.br_startblock) && 305730f712c9SDave Chinner ISVALID(ap->prev.br_startblock + ap->prev.br_blockcount, 305830f712c9SDave Chinner ap->prev.br_startblock)) { 305930f712c9SDave Chinner ap->blkno = ap->prev.br_startblock + ap->prev.br_blockcount; 306030f712c9SDave Chinner /* 306130f712c9SDave Chinner * Adjust for the gap between prevp and us. 306230f712c9SDave Chinner */ 306330f712c9SDave Chinner adjust = ap->offset - 306430f712c9SDave Chinner (ap->prev.br_startoff + ap->prev.br_blockcount); 306530f712c9SDave Chinner if (adjust && 306630f712c9SDave Chinner ISVALID(ap->blkno + adjust, ap->prev.br_startblock)) 306730f712c9SDave Chinner ap->blkno += adjust; 306830f712c9SDave Chinner } 306930f712c9SDave Chinner /* 307030f712c9SDave Chinner * If not at eof, then compare the two neighbor blocks. 307130f712c9SDave Chinner * Figure out whether either one gives us a good starting point, 307230f712c9SDave Chinner * and pick the better one. 307330f712c9SDave Chinner */ 307430f712c9SDave Chinner else if (!ap->eof) { 307530f712c9SDave Chinner xfs_fsblock_t gotbno; /* right side block number */ 307630f712c9SDave Chinner xfs_fsblock_t gotdiff=0; /* right side difference */ 307730f712c9SDave Chinner xfs_fsblock_t prevbno; /* left side block number */ 307830f712c9SDave Chinner xfs_fsblock_t prevdiff=0; /* left side difference */ 307930f712c9SDave Chinner 308030f712c9SDave Chinner /* 308130f712c9SDave Chinner * If there's a previous (left) block, select a requested 308230f712c9SDave Chinner * start block based on it. 308330f712c9SDave Chinner */ 308430f712c9SDave Chinner if (ap->prev.br_startoff != NULLFILEOFF && 308530f712c9SDave Chinner !isnullstartblock(ap->prev.br_startblock) && 308630f712c9SDave Chinner (prevbno = ap->prev.br_startblock + 308730f712c9SDave Chinner ap->prev.br_blockcount) && 308830f712c9SDave Chinner ISVALID(prevbno, ap->prev.br_startblock)) { 308930f712c9SDave Chinner /* 309030f712c9SDave Chinner * Calculate gap to end of previous block. 309130f712c9SDave Chinner */ 309230f712c9SDave Chinner adjust = prevdiff = ap->offset - 309330f712c9SDave Chinner (ap->prev.br_startoff + 309430f712c9SDave Chinner ap->prev.br_blockcount); 309530f712c9SDave Chinner /* 309630f712c9SDave Chinner * Figure the startblock based on the previous block's 309730f712c9SDave Chinner * end and the gap size. 309830f712c9SDave Chinner * Heuristic! 309930f712c9SDave Chinner * If the gap is large relative to the piece we're 310030f712c9SDave Chinner * allocating, or using it gives us an invalid block 310130f712c9SDave Chinner * number, then just use the end of the previous block. 310230f712c9SDave Chinner */ 310330f712c9SDave Chinner if (prevdiff <= XFS_ALLOC_GAP_UNITS * ap->length && 310430f712c9SDave Chinner ISVALID(prevbno + prevdiff, 310530f712c9SDave Chinner ap->prev.br_startblock)) 310630f712c9SDave Chinner prevbno += adjust; 310730f712c9SDave Chinner else 310830f712c9SDave Chinner prevdiff += adjust; 310930f712c9SDave Chinner /* 311030f712c9SDave Chinner * If the firstblock forbids it, can't use it, 311130f712c9SDave Chinner * must use default. 311230f712c9SDave Chinner */ 311330f712c9SDave Chinner if (!rt && !nullfb && 311430f712c9SDave Chinner XFS_FSB_TO_AGNO(mp, prevbno) != fb_agno) 311530f712c9SDave Chinner prevbno = NULLFSBLOCK; 311630f712c9SDave Chinner } 311730f712c9SDave Chinner /* 311830f712c9SDave Chinner * No previous block or can't follow it, just default. 311930f712c9SDave Chinner */ 312030f712c9SDave Chinner else 312130f712c9SDave Chinner prevbno = NULLFSBLOCK; 312230f712c9SDave Chinner /* 312330f712c9SDave Chinner * If there's a following (right) block, select a requested 312430f712c9SDave Chinner * start block based on it. 312530f712c9SDave Chinner */ 312630f712c9SDave Chinner if (!isnullstartblock(ap->got.br_startblock)) { 312730f712c9SDave Chinner /* 312830f712c9SDave Chinner * Calculate gap to start of next block. 312930f712c9SDave Chinner */ 313030f712c9SDave Chinner adjust = gotdiff = ap->got.br_startoff - ap->offset; 313130f712c9SDave Chinner /* 313230f712c9SDave Chinner * Figure the startblock based on the next block's 313330f712c9SDave Chinner * start and the gap size. 313430f712c9SDave Chinner */ 313530f712c9SDave Chinner gotbno = ap->got.br_startblock; 313630f712c9SDave Chinner /* 313730f712c9SDave Chinner * Heuristic! 313830f712c9SDave Chinner * If the gap is large relative to the piece we're 313930f712c9SDave Chinner * allocating, or using it gives us an invalid block 314030f712c9SDave Chinner * number, then just use the start of the next block 314130f712c9SDave Chinner * offset by our length. 314230f712c9SDave Chinner */ 314330f712c9SDave Chinner if (gotdiff <= XFS_ALLOC_GAP_UNITS * ap->length && 314430f712c9SDave Chinner ISVALID(gotbno - gotdiff, gotbno)) 314530f712c9SDave Chinner gotbno -= adjust; 314630f712c9SDave Chinner else if (ISVALID(gotbno - ap->length, gotbno)) { 314730f712c9SDave Chinner gotbno -= ap->length; 314830f712c9SDave Chinner gotdiff += adjust - ap->length; 314930f712c9SDave Chinner } else 315030f712c9SDave Chinner gotdiff += adjust; 315130f712c9SDave Chinner /* 315230f712c9SDave Chinner * If the firstblock forbids it, can't use it, 315330f712c9SDave Chinner * must use default. 315430f712c9SDave Chinner */ 315530f712c9SDave Chinner if (!rt && !nullfb && 315630f712c9SDave Chinner XFS_FSB_TO_AGNO(mp, gotbno) != fb_agno) 315730f712c9SDave Chinner gotbno = NULLFSBLOCK; 315830f712c9SDave Chinner } 315930f712c9SDave Chinner /* 316030f712c9SDave Chinner * No next block, just default. 316130f712c9SDave Chinner */ 316230f712c9SDave Chinner else 316330f712c9SDave Chinner gotbno = NULLFSBLOCK; 316430f712c9SDave Chinner /* 316530f712c9SDave Chinner * If both valid, pick the better one, else the only good 316630f712c9SDave Chinner * one, else ap->blkno is already set (to 0 or the inode block). 316730f712c9SDave Chinner */ 316830f712c9SDave Chinner if (prevbno != NULLFSBLOCK && gotbno != NULLFSBLOCK) 316930f712c9SDave Chinner ap->blkno = prevdiff <= gotdiff ? prevbno : gotbno; 317030f712c9SDave Chinner else if (prevbno != NULLFSBLOCK) 317130f712c9SDave Chinner ap->blkno = prevbno; 317230f712c9SDave Chinner else if (gotbno != NULLFSBLOCK) 317330f712c9SDave Chinner ap->blkno = gotbno; 317430f712c9SDave Chinner } 317530f712c9SDave Chinner #undef ISVALID 317630f712c9SDave Chinner } 317730f712c9SDave Chinner 317830f712c9SDave Chinner static int 317930f712c9SDave Chinner xfs_bmap_longest_free_extent( 318030f712c9SDave Chinner struct xfs_trans *tp, 318130f712c9SDave Chinner xfs_agnumber_t ag, 318230f712c9SDave Chinner xfs_extlen_t *blen, 318330f712c9SDave Chinner int *notinit) 318430f712c9SDave Chinner { 318530f712c9SDave Chinner struct xfs_mount *mp = tp->t_mountp; 318630f712c9SDave Chinner struct xfs_perag *pag; 318730f712c9SDave Chinner xfs_extlen_t longest; 318830f712c9SDave Chinner int error = 0; 318930f712c9SDave Chinner 319030f712c9SDave Chinner pag = xfs_perag_get(mp, ag); 319130f712c9SDave Chinner if (!pag->pagf_init) { 319230f712c9SDave Chinner error = xfs_alloc_pagf_init(mp, tp, ag, XFS_ALLOC_FLAG_TRYLOCK); 319330f712c9SDave Chinner if (error) 319430f712c9SDave Chinner goto out; 319530f712c9SDave Chinner 319630f712c9SDave Chinner if (!pag->pagf_init) { 319730f712c9SDave Chinner *notinit = 1; 319830f712c9SDave Chinner goto out; 319930f712c9SDave Chinner } 320030f712c9SDave Chinner } 320130f712c9SDave Chinner 3202a1f69417SEric Sandeen longest = xfs_alloc_longest_free_extent(pag, 32033fd129b6SDarrick J. Wong xfs_alloc_min_freelist(mp, pag), 32043fd129b6SDarrick J. Wong xfs_ag_resv_needed(pag, XFS_AG_RESV_NONE)); 320530f712c9SDave Chinner if (*blen < longest) 320630f712c9SDave Chinner *blen = longest; 320730f712c9SDave Chinner 320830f712c9SDave Chinner out: 320930f712c9SDave Chinner xfs_perag_put(pag); 321030f712c9SDave Chinner return error; 321130f712c9SDave Chinner } 321230f712c9SDave Chinner 321330f712c9SDave Chinner static void 321430f712c9SDave Chinner xfs_bmap_select_minlen( 321530f712c9SDave Chinner struct xfs_bmalloca *ap, 321630f712c9SDave Chinner struct xfs_alloc_arg *args, 321730f712c9SDave Chinner xfs_extlen_t *blen, 321830f712c9SDave Chinner int notinit) 321930f712c9SDave Chinner { 322030f712c9SDave Chinner if (notinit || *blen < ap->minlen) { 322130f712c9SDave Chinner /* 322230f712c9SDave Chinner * Since we did a BUF_TRYLOCK above, it is possible that 322330f712c9SDave Chinner * there is space for this request. 322430f712c9SDave Chinner */ 322530f712c9SDave Chinner args->minlen = ap->minlen; 322630f712c9SDave Chinner } else if (*blen < args->maxlen) { 322730f712c9SDave Chinner /* 322830f712c9SDave Chinner * If the best seen length is less than the request length, 322930f712c9SDave Chinner * use the best as the minimum. 323030f712c9SDave Chinner */ 323130f712c9SDave Chinner args->minlen = *blen; 323230f712c9SDave Chinner } else { 323330f712c9SDave Chinner /* 323430f712c9SDave Chinner * Otherwise we've seen an extent as big as maxlen, use that 323530f712c9SDave Chinner * as the minimum. 323630f712c9SDave Chinner */ 323730f712c9SDave Chinner args->minlen = args->maxlen; 323830f712c9SDave Chinner } 323930f712c9SDave Chinner } 324030f712c9SDave Chinner 324130f712c9SDave Chinner STATIC int 324230f712c9SDave Chinner xfs_bmap_btalloc_nullfb( 324330f712c9SDave Chinner struct xfs_bmalloca *ap, 324430f712c9SDave Chinner struct xfs_alloc_arg *args, 324530f712c9SDave Chinner xfs_extlen_t *blen) 324630f712c9SDave Chinner { 324730f712c9SDave Chinner struct xfs_mount *mp = ap->ip->i_mount; 324830f712c9SDave Chinner xfs_agnumber_t ag, startag; 324930f712c9SDave Chinner int notinit = 0; 325030f712c9SDave Chinner int error; 325130f712c9SDave Chinner 325230f712c9SDave Chinner args->type = XFS_ALLOCTYPE_START_BNO; 325330f712c9SDave Chinner args->total = ap->total; 325430f712c9SDave Chinner 325530f712c9SDave Chinner startag = ag = XFS_FSB_TO_AGNO(mp, args->fsbno); 325630f712c9SDave Chinner if (startag == NULLAGNUMBER) 325730f712c9SDave Chinner startag = ag = 0; 325830f712c9SDave Chinner 325930f712c9SDave Chinner while (*blen < args->maxlen) { 326030f712c9SDave Chinner error = xfs_bmap_longest_free_extent(args->tp, ag, blen, 326130f712c9SDave Chinner ¬init); 326230f712c9SDave Chinner if (error) 326330f712c9SDave Chinner return error; 326430f712c9SDave Chinner 326530f712c9SDave Chinner if (++ag == mp->m_sb.sb_agcount) 326630f712c9SDave Chinner ag = 0; 326730f712c9SDave Chinner if (ag == startag) 326830f712c9SDave Chinner break; 326930f712c9SDave Chinner } 327030f712c9SDave Chinner 327130f712c9SDave Chinner xfs_bmap_select_minlen(ap, args, blen, notinit); 327230f712c9SDave Chinner return 0; 327330f712c9SDave Chinner } 327430f712c9SDave Chinner 327530f712c9SDave Chinner STATIC int 327630f712c9SDave Chinner xfs_bmap_btalloc_filestreams( 327730f712c9SDave Chinner struct xfs_bmalloca *ap, 327830f712c9SDave Chinner struct xfs_alloc_arg *args, 327930f712c9SDave Chinner xfs_extlen_t *blen) 328030f712c9SDave Chinner { 328130f712c9SDave Chinner struct xfs_mount *mp = ap->ip->i_mount; 328230f712c9SDave Chinner xfs_agnumber_t ag; 328330f712c9SDave Chinner int notinit = 0; 328430f712c9SDave Chinner int error; 328530f712c9SDave Chinner 328630f712c9SDave Chinner args->type = XFS_ALLOCTYPE_NEAR_BNO; 328730f712c9SDave Chinner args->total = ap->total; 328830f712c9SDave Chinner 328930f712c9SDave Chinner ag = XFS_FSB_TO_AGNO(mp, args->fsbno); 329030f712c9SDave Chinner if (ag == NULLAGNUMBER) 329130f712c9SDave Chinner ag = 0; 329230f712c9SDave Chinner 329330f712c9SDave Chinner error = xfs_bmap_longest_free_extent(args->tp, ag, blen, ¬init); 329430f712c9SDave Chinner if (error) 329530f712c9SDave Chinner return error; 329630f712c9SDave Chinner 329730f712c9SDave Chinner if (*blen < args->maxlen) { 329830f712c9SDave Chinner error = xfs_filestream_new_ag(ap, &ag); 329930f712c9SDave Chinner if (error) 330030f712c9SDave Chinner return error; 330130f712c9SDave Chinner 330230f712c9SDave Chinner error = xfs_bmap_longest_free_extent(args->tp, ag, blen, 330330f712c9SDave Chinner ¬init); 330430f712c9SDave Chinner if (error) 330530f712c9SDave Chinner return error; 330630f712c9SDave Chinner 330730f712c9SDave Chinner } 330830f712c9SDave Chinner 330930f712c9SDave Chinner xfs_bmap_select_minlen(ap, args, blen, notinit); 331030f712c9SDave Chinner 331130f712c9SDave Chinner /* 331230f712c9SDave Chinner * Set the failure fallback case to look in the selected AG as stream 331330f712c9SDave Chinner * may have moved. 331430f712c9SDave Chinner */ 331530f712c9SDave Chinner ap->blkno = args->fsbno = XFS_AGB_TO_FSB(mp, ag, 0); 331630f712c9SDave Chinner return 0; 331730f712c9SDave Chinner } 331830f712c9SDave Chinner 3319751f3767SDarrick J. Wong /* Update all inode and quota accounting for the allocation we just did. */ 3320751f3767SDarrick J. Wong static void 3321751f3767SDarrick J. Wong xfs_bmap_btalloc_accounting( 3322751f3767SDarrick J. Wong struct xfs_bmalloca *ap, 3323751f3767SDarrick J. Wong struct xfs_alloc_arg *args) 3324751f3767SDarrick J. Wong { 33254b4c1326SDarrick J. Wong if (ap->flags & XFS_BMAPI_COWFORK) { 33264b4c1326SDarrick J. Wong /* 33274b4c1326SDarrick J. Wong * COW fork blocks are in-core only and thus are treated as 33284b4c1326SDarrick J. Wong * in-core quota reservation (like delalloc blocks) even when 33294b4c1326SDarrick J. Wong * converted to real blocks. The quota reservation is not 33304b4c1326SDarrick J. Wong * accounted to disk until blocks are remapped to the data 33314b4c1326SDarrick J. Wong * fork. So if these blocks were previously delalloc, we 33324b4c1326SDarrick J. Wong * already have quota reservation and there's nothing to do 33334b4c1326SDarrick J. Wong * yet. 33344b4c1326SDarrick J. Wong */ 33354b4c1326SDarrick J. Wong if (ap->wasdel) 33364b4c1326SDarrick J. Wong return; 33374b4c1326SDarrick J. Wong 33384b4c1326SDarrick J. Wong /* 33394b4c1326SDarrick J. Wong * Otherwise, we've allocated blocks in a hole. The transaction 33404b4c1326SDarrick J. Wong * has acquired in-core quota reservation for this extent. 33414b4c1326SDarrick J. Wong * Rather than account these as real blocks, however, we reduce 33424b4c1326SDarrick J. Wong * the transaction quota reservation based on the allocation. 33434b4c1326SDarrick J. Wong * This essentially transfers the transaction quota reservation 33444b4c1326SDarrick J. Wong * to that of a delalloc extent. 33454b4c1326SDarrick J. Wong */ 33464b4c1326SDarrick J. Wong ap->ip->i_delayed_blks += args->len; 33474b4c1326SDarrick J. Wong xfs_trans_mod_dquot_byino(ap->tp, ap->ip, XFS_TRANS_DQ_RES_BLKS, 33484b4c1326SDarrick J. Wong -(long)args->len); 33494b4c1326SDarrick J. Wong return; 33504b4c1326SDarrick J. Wong } 33514b4c1326SDarrick J. Wong 33524b4c1326SDarrick J. Wong /* data/attr fork only */ 3353751f3767SDarrick J. Wong ap->ip->i_d.di_nblocks += args->len; 3354751f3767SDarrick J. Wong xfs_trans_log_inode(ap->tp, ap->ip, XFS_ILOG_CORE); 3355751f3767SDarrick J. Wong if (ap->wasdel) 3356751f3767SDarrick J. Wong ap->ip->i_delayed_blks -= args->len; 3357751f3767SDarrick J. Wong xfs_trans_mod_dquot_byino(ap->tp, ap->ip, 3358751f3767SDarrick J. Wong ap->wasdel ? XFS_TRANS_DQ_DELBCOUNT : XFS_TRANS_DQ_BCOUNT, 3359751f3767SDarrick J. Wong args->len); 3360751f3767SDarrick J. Wong } 3361751f3767SDarrick J. Wong 336230f712c9SDave Chinner STATIC int 336330f712c9SDave Chinner xfs_bmap_btalloc( 336430f712c9SDave Chinner struct xfs_bmalloca *ap) /* bmap alloc argument struct */ 336530f712c9SDave Chinner { 336630f712c9SDave Chinner xfs_mount_t *mp; /* mount point structure */ 336730f712c9SDave Chinner xfs_alloctype_t atype = 0; /* type for allocation routines */ 3368292378edSDave Chinner xfs_extlen_t align = 0; /* minimum allocation alignment */ 336930f712c9SDave Chinner xfs_agnumber_t fb_agno; /* ag number of ap->firstblock */ 337030f712c9SDave Chinner xfs_agnumber_t ag; 337130f712c9SDave Chinner xfs_alloc_arg_t args; 33726d8a45ceSDarrick J. Wong xfs_fileoff_t orig_offset; 33736d8a45ceSDarrick J. Wong xfs_extlen_t orig_length; 337430f712c9SDave Chinner xfs_extlen_t blen; 337530f712c9SDave Chinner xfs_extlen_t nextminlen = 0; 337630f712c9SDave Chinner int nullfb; /* true if ap->firstblock isn't set */ 337730f712c9SDave Chinner int isaligned; 337830f712c9SDave Chinner int tryagain; 337930f712c9SDave Chinner int error; 338030f712c9SDave Chinner int stripe_align; 338130f712c9SDave Chinner 338230f712c9SDave Chinner ASSERT(ap->length); 33836d8a45ceSDarrick J. Wong orig_offset = ap->offset; 33846d8a45ceSDarrick J. Wong orig_length = ap->length; 338530f712c9SDave Chinner 338630f712c9SDave Chinner mp = ap->ip->i_mount; 338730f712c9SDave Chinner 338830f712c9SDave Chinner /* stripe alignment for allocation is determined by mount parameters */ 338930f712c9SDave Chinner stripe_align = 0; 339030f712c9SDave Chinner if (mp->m_swidth && (mp->m_flags & XFS_MOUNT_SWALLOC)) 339130f712c9SDave Chinner stripe_align = mp->m_swidth; 339230f712c9SDave Chinner else if (mp->m_dalign) 339330f712c9SDave Chinner stripe_align = mp->m_dalign; 339430f712c9SDave Chinner 3395f7ca3522SDarrick J. Wong if (ap->flags & XFS_BMAPI_COWFORK) 3396f7ca3522SDarrick J. Wong align = xfs_get_cowextsz_hint(ap->ip); 3397f7ca3522SDarrick J. Wong else if (xfs_alloc_is_userdata(ap->datatype)) 3398292378edSDave Chinner align = xfs_get_extsz_hint(ap->ip); 3399493611ebSChristoph Hellwig if (align) { 340030f712c9SDave Chinner error = xfs_bmap_extsize_align(mp, &ap->got, &ap->prev, 340130f712c9SDave Chinner align, 0, ap->eof, 0, ap->conv, 340230f712c9SDave Chinner &ap->offset, &ap->length); 340330f712c9SDave Chinner ASSERT(!error); 340430f712c9SDave Chinner ASSERT(ap->length); 340530f712c9SDave Chinner } 340630f712c9SDave Chinner 340730f712c9SDave Chinner 340894c07b4dSBrian Foster nullfb = ap->tp->t_firstblock == NULLFSBLOCK; 340994c07b4dSBrian Foster fb_agno = nullfb ? NULLAGNUMBER : XFS_FSB_TO_AGNO(mp, 341094c07b4dSBrian Foster ap->tp->t_firstblock); 341130f712c9SDave Chinner if (nullfb) { 3412292378edSDave Chinner if (xfs_alloc_is_userdata(ap->datatype) && 3413292378edSDave Chinner xfs_inode_is_filestream(ap->ip)) { 341430f712c9SDave Chinner ag = xfs_filestream_lookup_ag(ap->ip); 341530f712c9SDave Chinner ag = (ag != NULLAGNUMBER) ? ag : 0; 341630f712c9SDave Chinner ap->blkno = XFS_AGB_TO_FSB(mp, ag, 0); 341730f712c9SDave Chinner } else { 341830f712c9SDave Chinner ap->blkno = XFS_INO_TO_FSB(mp, ap->ip->i_ino); 341930f712c9SDave Chinner } 342030f712c9SDave Chinner } else 342194c07b4dSBrian Foster ap->blkno = ap->tp->t_firstblock; 342230f712c9SDave Chinner 342330f712c9SDave Chinner xfs_bmap_adjacent(ap); 342430f712c9SDave Chinner 342530f712c9SDave Chinner /* 342630f712c9SDave Chinner * If allowed, use ap->blkno; otherwise must use firstblock since 342730f712c9SDave Chinner * it's in the right allocation group. 342830f712c9SDave Chinner */ 342930f712c9SDave Chinner if (nullfb || XFS_FSB_TO_AGNO(mp, ap->blkno) == fb_agno) 343030f712c9SDave Chinner ; 343130f712c9SDave Chinner else 343294c07b4dSBrian Foster ap->blkno = ap->tp->t_firstblock; 343330f712c9SDave Chinner /* 343430f712c9SDave Chinner * Normal allocation, done through xfs_alloc_vextent. 343530f712c9SDave Chinner */ 343630f712c9SDave Chinner tryagain = isaligned = 0; 343730f712c9SDave Chinner memset(&args, 0, sizeof(args)); 343830f712c9SDave Chinner args.tp = ap->tp; 343930f712c9SDave Chinner args.mp = mp; 344030f712c9SDave Chinner args.fsbno = ap->blkno; 3441340785ccSDarrick J. Wong xfs_rmap_skip_owner_update(&args.oinfo); 344230f712c9SDave Chinner 344330f712c9SDave Chinner /* Trim the allocation back to the maximum an AG can fit. */ 34449bb54cb5SDave Chinner args.maxlen = min(ap->length, mp->m_ag_max_usable); 344530f712c9SDave Chinner blen = 0; 344630f712c9SDave Chinner if (nullfb) { 344730f712c9SDave Chinner /* 344830f712c9SDave Chinner * Search for an allocation group with a single extent large 344930f712c9SDave Chinner * enough for the request. If one isn't found, then adjust 345030f712c9SDave Chinner * the minimum allocation size to the largest space found. 345130f712c9SDave Chinner */ 3452292378edSDave Chinner if (xfs_alloc_is_userdata(ap->datatype) && 3453292378edSDave Chinner xfs_inode_is_filestream(ap->ip)) 345430f712c9SDave Chinner error = xfs_bmap_btalloc_filestreams(ap, &args, &blen); 345530f712c9SDave Chinner else 345630f712c9SDave Chinner error = xfs_bmap_btalloc_nullfb(ap, &args, &blen); 345730f712c9SDave Chinner if (error) 345830f712c9SDave Chinner return error; 34593e3673e3SBrian Foster } else if (ap->tp->t_dfops->dop_low) { 346030f712c9SDave Chinner if (xfs_inode_is_filestream(ap->ip)) 346130f712c9SDave Chinner args.type = XFS_ALLOCTYPE_FIRST_AG; 346230f712c9SDave Chinner else 346330f712c9SDave Chinner args.type = XFS_ALLOCTYPE_START_BNO; 346430f712c9SDave Chinner args.total = args.minlen = ap->minlen; 346530f712c9SDave Chinner } else { 346630f712c9SDave Chinner args.type = XFS_ALLOCTYPE_NEAR_BNO; 346730f712c9SDave Chinner args.total = ap->total; 346830f712c9SDave Chinner args.minlen = ap->minlen; 346930f712c9SDave Chinner } 347030f712c9SDave Chinner /* apply extent size hints if obtained earlier */ 3471493611ebSChristoph Hellwig if (align) { 347230f712c9SDave Chinner args.prod = align; 34730703a8e1SDave Chinner div_u64_rem(ap->offset, args.prod, &args.mod); 34740703a8e1SDave Chinner if (args.mod) 34750703a8e1SDave Chinner args.mod = args.prod - args.mod; 347609cbfeafSKirill A. Shutemov } else if (mp->m_sb.sb_blocksize >= PAGE_SIZE) { 347730f712c9SDave Chinner args.prod = 1; 347830f712c9SDave Chinner args.mod = 0; 347930f712c9SDave Chinner } else { 348009cbfeafSKirill A. Shutemov args.prod = PAGE_SIZE >> mp->m_sb.sb_blocklog; 34810703a8e1SDave Chinner div_u64_rem(ap->offset, args.prod, &args.mod); 34820703a8e1SDave Chinner if (args.mod) 34830703a8e1SDave Chinner args.mod = args.prod - args.mod; 348430f712c9SDave Chinner } 348530f712c9SDave Chinner /* 348630f712c9SDave Chinner * If we are not low on available data blocks, and the 348730f712c9SDave Chinner * underlying logical volume manager is a stripe, and 348830f712c9SDave Chinner * the file offset is zero then try to allocate data 348930f712c9SDave Chinner * blocks on stripe unit boundary. 349030f712c9SDave Chinner * NOTE: ap->aeof is only set if the allocation length 349130f712c9SDave Chinner * is >= the stripe unit and the allocation offset is 349230f712c9SDave Chinner * at the end of file. 349330f712c9SDave Chinner */ 34943e3673e3SBrian Foster if (!ap->tp->t_dfops->dop_low && ap->aeof) { 349530f712c9SDave Chinner if (!ap->offset) { 349630f712c9SDave Chinner args.alignment = stripe_align; 349730f712c9SDave Chinner atype = args.type; 349830f712c9SDave Chinner isaligned = 1; 349930f712c9SDave Chinner /* 350030f712c9SDave Chinner * Adjust for alignment 350130f712c9SDave Chinner */ 350230f712c9SDave Chinner if (blen > args.alignment && blen <= args.maxlen) 350330f712c9SDave Chinner args.minlen = blen - args.alignment; 350430f712c9SDave Chinner args.minalignslop = 0; 350530f712c9SDave Chinner } else { 350630f712c9SDave Chinner /* 350730f712c9SDave Chinner * First try an exact bno allocation. 350830f712c9SDave Chinner * If it fails then do a near or start bno 350930f712c9SDave Chinner * allocation with alignment turned on. 351030f712c9SDave Chinner */ 351130f712c9SDave Chinner atype = args.type; 351230f712c9SDave Chinner tryagain = 1; 351330f712c9SDave Chinner args.type = XFS_ALLOCTYPE_THIS_BNO; 351430f712c9SDave Chinner args.alignment = 1; 351530f712c9SDave Chinner /* 351630f712c9SDave Chinner * Compute the minlen+alignment for the 351730f712c9SDave Chinner * next case. Set slop so that the value 351830f712c9SDave Chinner * of minlen+alignment+slop doesn't go up 351930f712c9SDave Chinner * between the calls. 352030f712c9SDave Chinner */ 352130f712c9SDave Chinner if (blen > stripe_align && blen <= args.maxlen) 352230f712c9SDave Chinner nextminlen = blen - stripe_align; 352330f712c9SDave Chinner else 352430f712c9SDave Chinner nextminlen = args.minlen; 352530f712c9SDave Chinner if (nextminlen + stripe_align > args.minlen + 1) 352630f712c9SDave Chinner args.minalignslop = 352730f712c9SDave Chinner nextminlen + stripe_align - 352830f712c9SDave Chinner args.minlen - 1; 352930f712c9SDave Chinner else 353030f712c9SDave Chinner args.minalignslop = 0; 353130f712c9SDave Chinner } 353230f712c9SDave Chinner } else { 353330f712c9SDave Chinner args.alignment = 1; 353430f712c9SDave Chinner args.minalignslop = 0; 353530f712c9SDave Chinner } 353630f712c9SDave Chinner args.minleft = ap->minleft; 353730f712c9SDave Chinner args.wasdel = ap->wasdel; 35383fd129b6SDarrick J. Wong args.resv = XFS_AG_RESV_NONE; 3539292378edSDave Chinner args.datatype = ap->datatype; 3540292378edSDave Chinner if (ap->datatype & XFS_ALLOC_USERDATA_ZERO) 35413fbbbea3SDave Chinner args.ip = ap->ip; 35423fbbbea3SDave Chinner 35433fbbbea3SDave Chinner error = xfs_alloc_vextent(&args); 35443fbbbea3SDave Chinner if (error) 354530f712c9SDave Chinner return error; 35463fbbbea3SDave Chinner 354730f712c9SDave Chinner if (tryagain && args.fsbno == NULLFSBLOCK) { 354830f712c9SDave Chinner /* 354930f712c9SDave Chinner * Exact allocation failed. Now try with alignment 355030f712c9SDave Chinner * turned on. 355130f712c9SDave Chinner */ 355230f712c9SDave Chinner args.type = atype; 355330f712c9SDave Chinner args.fsbno = ap->blkno; 355430f712c9SDave Chinner args.alignment = stripe_align; 355530f712c9SDave Chinner args.minlen = nextminlen; 355630f712c9SDave Chinner args.minalignslop = 0; 355730f712c9SDave Chinner isaligned = 1; 355830f712c9SDave Chinner if ((error = xfs_alloc_vextent(&args))) 355930f712c9SDave Chinner return error; 356030f712c9SDave Chinner } 356130f712c9SDave Chinner if (isaligned && args.fsbno == NULLFSBLOCK) { 356230f712c9SDave Chinner /* 356330f712c9SDave Chinner * allocation failed, so turn off alignment and 356430f712c9SDave Chinner * try again. 356530f712c9SDave Chinner */ 356630f712c9SDave Chinner args.type = atype; 356730f712c9SDave Chinner args.fsbno = ap->blkno; 356830f712c9SDave Chinner args.alignment = 0; 356930f712c9SDave Chinner if ((error = xfs_alloc_vextent(&args))) 357030f712c9SDave Chinner return error; 357130f712c9SDave Chinner } 357230f712c9SDave Chinner if (args.fsbno == NULLFSBLOCK && nullfb && 357330f712c9SDave Chinner args.minlen > ap->minlen) { 357430f712c9SDave Chinner args.minlen = ap->minlen; 357530f712c9SDave Chinner args.type = XFS_ALLOCTYPE_START_BNO; 357630f712c9SDave Chinner args.fsbno = ap->blkno; 357730f712c9SDave Chinner if ((error = xfs_alloc_vextent(&args))) 357830f712c9SDave Chinner return error; 357930f712c9SDave Chinner } 358030f712c9SDave Chinner if (args.fsbno == NULLFSBLOCK && nullfb) { 358130f712c9SDave Chinner args.fsbno = 0; 358230f712c9SDave Chinner args.type = XFS_ALLOCTYPE_FIRST_AG; 358330f712c9SDave Chinner args.total = ap->minlen; 358430f712c9SDave Chinner if ((error = xfs_alloc_vextent(&args))) 358530f712c9SDave Chinner return error; 35863e3673e3SBrian Foster ap->tp->t_dfops->dop_low = true; 358730f712c9SDave Chinner } 358830f712c9SDave Chinner if (args.fsbno != NULLFSBLOCK) { 358930f712c9SDave Chinner /* 359030f712c9SDave Chinner * check the allocation happened at the same or higher AG than 359130f712c9SDave Chinner * the first block that was allocated. 359230f712c9SDave Chinner */ 359394c07b4dSBrian Foster ASSERT(ap->tp->t_firstblock == NULLFSBLOCK || 359494c07b4dSBrian Foster XFS_FSB_TO_AGNO(mp, ap->tp->t_firstblock) <= 3595410d17f6SChristoph Hellwig XFS_FSB_TO_AGNO(mp, args.fsbno)); 359630f712c9SDave Chinner 359730f712c9SDave Chinner ap->blkno = args.fsbno; 359894c07b4dSBrian Foster if (ap->tp->t_firstblock == NULLFSBLOCK) 359994c07b4dSBrian Foster ap->tp->t_firstblock = args.fsbno; 3600410d17f6SChristoph Hellwig ASSERT(nullfb || fb_agno <= args.agno); 360130f712c9SDave Chinner ap->length = args.len; 36026d8a45ceSDarrick J. Wong /* 36036d8a45ceSDarrick J. Wong * If the extent size hint is active, we tried to round the 36046d8a45ceSDarrick J. Wong * caller's allocation request offset down to extsz and the 36056d8a45ceSDarrick J. Wong * length up to another extsz boundary. If we found a free 36066d8a45ceSDarrick J. Wong * extent we mapped it in starting at this new offset. If the 36076d8a45ceSDarrick J. Wong * newly mapped space isn't long enough to cover any of the 36086d8a45ceSDarrick J. Wong * range of offsets that was originally requested, move the 36096d8a45ceSDarrick J. Wong * mapping up so that we can fill as much of the caller's 36106d8a45ceSDarrick J. Wong * original request as possible. Free space is apparently 36116d8a45ceSDarrick J. Wong * very fragmented so we're unlikely to be able to satisfy the 36126d8a45ceSDarrick J. Wong * hints anyway. 36136d8a45ceSDarrick J. Wong */ 36146d8a45ceSDarrick J. Wong if (ap->length <= orig_length) 36156d8a45ceSDarrick J. Wong ap->offset = orig_offset; 36166d8a45ceSDarrick J. Wong else if (ap->offset + ap->length < orig_offset + orig_length) 36176d8a45ceSDarrick J. Wong ap->offset = orig_offset + orig_length - ap->length; 3618751f3767SDarrick J. Wong xfs_bmap_btalloc_accounting(ap, &args); 361930f712c9SDave Chinner } else { 362030f712c9SDave Chinner ap->blkno = NULLFSBLOCK; 362130f712c9SDave Chinner ap->length = 0; 362230f712c9SDave Chinner } 362330f712c9SDave Chinner return 0; 362430f712c9SDave Chinner } 362530f712c9SDave Chinner 362630f712c9SDave Chinner /* 362730f712c9SDave Chinner * xfs_bmap_alloc is called by xfs_bmapi to allocate an extent for a file. 362830f712c9SDave Chinner * It figures out where to ask the underlying allocator to put the new extent. 362930f712c9SDave Chinner */ 363030f712c9SDave Chinner STATIC int 363130f712c9SDave Chinner xfs_bmap_alloc( 363230f712c9SDave Chinner struct xfs_bmalloca *ap) /* bmap alloc argument struct */ 363330f712c9SDave Chinner { 3634292378edSDave Chinner if (XFS_IS_REALTIME_INODE(ap->ip) && 3635292378edSDave Chinner xfs_alloc_is_userdata(ap->datatype)) 363630f712c9SDave Chinner return xfs_bmap_rtalloc(ap); 363730f712c9SDave Chinner return xfs_bmap_btalloc(ap); 363830f712c9SDave Chinner } 363930f712c9SDave Chinner 36400a0af28cSDarrick J. Wong /* Trim extent to fit a logical block range. */ 36410a0af28cSDarrick J. Wong void 36420a0af28cSDarrick J. Wong xfs_trim_extent( 36430a0af28cSDarrick J. Wong struct xfs_bmbt_irec *irec, 36440a0af28cSDarrick J. Wong xfs_fileoff_t bno, 36450a0af28cSDarrick J. Wong xfs_filblks_t len) 36460a0af28cSDarrick J. Wong { 36470a0af28cSDarrick J. Wong xfs_fileoff_t distance; 36480a0af28cSDarrick J. Wong xfs_fileoff_t end = bno + len; 36490a0af28cSDarrick J. Wong 36500a0af28cSDarrick J. Wong if (irec->br_startoff + irec->br_blockcount <= bno || 36510a0af28cSDarrick J. Wong irec->br_startoff >= end) { 36520a0af28cSDarrick J. Wong irec->br_blockcount = 0; 36530a0af28cSDarrick J. Wong return; 36540a0af28cSDarrick J. Wong } 36550a0af28cSDarrick J. Wong 36560a0af28cSDarrick J. Wong if (irec->br_startoff < bno) { 36570a0af28cSDarrick J. Wong distance = bno - irec->br_startoff; 36580a0af28cSDarrick J. Wong if (isnullstartblock(irec->br_startblock)) 36590a0af28cSDarrick J. Wong irec->br_startblock = DELAYSTARTBLOCK; 36600a0af28cSDarrick J. Wong if (irec->br_startblock != DELAYSTARTBLOCK && 36610a0af28cSDarrick J. Wong irec->br_startblock != HOLESTARTBLOCK) 36620a0af28cSDarrick J. Wong irec->br_startblock += distance; 36630a0af28cSDarrick J. Wong irec->br_startoff += distance; 36640a0af28cSDarrick J. Wong irec->br_blockcount -= distance; 36650a0af28cSDarrick J. Wong } 36660a0af28cSDarrick J. Wong 36670a0af28cSDarrick J. Wong if (end < irec->br_startoff + irec->br_blockcount) { 36680a0af28cSDarrick J. Wong distance = irec->br_startoff + irec->br_blockcount - end; 36690a0af28cSDarrick J. Wong irec->br_blockcount -= distance; 36700a0af28cSDarrick J. Wong } 36710a0af28cSDarrick J. Wong } 36720a0af28cSDarrick J. Wong 367340214d12SBrian Foster /* trim extent to within eof */ 367440214d12SBrian Foster void 367540214d12SBrian Foster xfs_trim_extent_eof( 367640214d12SBrian Foster struct xfs_bmbt_irec *irec, 367740214d12SBrian Foster struct xfs_inode *ip) 367840214d12SBrian Foster 367940214d12SBrian Foster { 368040214d12SBrian Foster xfs_trim_extent(irec, 0, XFS_B_TO_FSB(ip->i_mount, 368140214d12SBrian Foster i_size_read(VFS_I(ip)))); 368240214d12SBrian Foster } 368340214d12SBrian Foster 368430f712c9SDave Chinner /* 368530f712c9SDave Chinner * Trim the returned map to the required bounds 368630f712c9SDave Chinner */ 368730f712c9SDave Chinner STATIC void 368830f712c9SDave Chinner xfs_bmapi_trim_map( 368930f712c9SDave Chinner struct xfs_bmbt_irec *mval, 369030f712c9SDave Chinner struct xfs_bmbt_irec *got, 369130f712c9SDave Chinner xfs_fileoff_t *bno, 369230f712c9SDave Chinner xfs_filblks_t len, 369330f712c9SDave Chinner xfs_fileoff_t obno, 369430f712c9SDave Chinner xfs_fileoff_t end, 369530f712c9SDave Chinner int n, 369630f712c9SDave Chinner int flags) 369730f712c9SDave Chinner { 369830f712c9SDave Chinner if ((flags & XFS_BMAPI_ENTIRE) || 369930f712c9SDave Chinner got->br_startoff + got->br_blockcount <= obno) { 370030f712c9SDave Chinner *mval = *got; 370130f712c9SDave Chinner if (isnullstartblock(got->br_startblock)) 370230f712c9SDave Chinner mval->br_startblock = DELAYSTARTBLOCK; 370330f712c9SDave Chinner return; 370430f712c9SDave Chinner } 370530f712c9SDave Chinner 370630f712c9SDave Chinner if (obno > *bno) 370730f712c9SDave Chinner *bno = obno; 370830f712c9SDave Chinner ASSERT((*bno >= obno) || (n == 0)); 370930f712c9SDave Chinner ASSERT(*bno < end); 371030f712c9SDave Chinner mval->br_startoff = *bno; 371130f712c9SDave Chinner if (isnullstartblock(got->br_startblock)) 371230f712c9SDave Chinner mval->br_startblock = DELAYSTARTBLOCK; 371330f712c9SDave Chinner else 371430f712c9SDave Chinner mval->br_startblock = got->br_startblock + 371530f712c9SDave Chinner (*bno - got->br_startoff); 371630f712c9SDave Chinner /* 371730f712c9SDave Chinner * Return the minimum of what we got and what we asked for for 371830f712c9SDave Chinner * the length. We can use the len variable here because it is 371930f712c9SDave Chinner * modified below and we could have been there before coming 372030f712c9SDave Chinner * here if the first part of the allocation didn't overlap what 372130f712c9SDave Chinner * was asked for. 372230f712c9SDave Chinner */ 372330f712c9SDave Chinner mval->br_blockcount = XFS_FILBLKS_MIN(end - *bno, 372430f712c9SDave Chinner got->br_blockcount - (*bno - got->br_startoff)); 372530f712c9SDave Chinner mval->br_state = got->br_state; 372630f712c9SDave Chinner ASSERT(mval->br_blockcount <= len); 372730f712c9SDave Chinner return; 372830f712c9SDave Chinner } 372930f712c9SDave Chinner 373030f712c9SDave Chinner /* 373130f712c9SDave Chinner * Update and validate the extent map to return 373230f712c9SDave Chinner */ 373330f712c9SDave Chinner STATIC void 373430f712c9SDave Chinner xfs_bmapi_update_map( 373530f712c9SDave Chinner struct xfs_bmbt_irec **map, 373630f712c9SDave Chinner xfs_fileoff_t *bno, 373730f712c9SDave Chinner xfs_filblks_t *len, 373830f712c9SDave Chinner xfs_fileoff_t obno, 373930f712c9SDave Chinner xfs_fileoff_t end, 374030f712c9SDave Chinner int *n, 374130f712c9SDave Chinner int flags) 374230f712c9SDave Chinner { 374330f712c9SDave Chinner xfs_bmbt_irec_t *mval = *map; 374430f712c9SDave Chinner 374530f712c9SDave Chinner ASSERT((flags & XFS_BMAPI_ENTIRE) || 374630f712c9SDave Chinner ((mval->br_startoff + mval->br_blockcount) <= end)); 374730f712c9SDave Chinner ASSERT((flags & XFS_BMAPI_ENTIRE) || (mval->br_blockcount <= *len) || 374830f712c9SDave Chinner (mval->br_startoff < obno)); 374930f712c9SDave Chinner 375030f712c9SDave Chinner *bno = mval->br_startoff + mval->br_blockcount; 375130f712c9SDave Chinner *len = end - *bno; 375230f712c9SDave Chinner if (*n > 0 && mval->br_startoff == mval[-1].br_startoff) { 375330f712c9SDave Chinner /* update previous map with new information */ 375430f712c9SDave Chinner ASSERT(mval->br_startblock == mval[-1].br_startblock); 375530f712c9SDave Chinner ASSERT(mval->br_blockcount > mval[-1].br_blockcount); 375630f712c9SDave Chinner ASSERT(mval->br_state == mval[-1].br_state); 375730f712c9SDave Chinner mval[-1].br_blockcount = mval->br_blockcount; 375830f712c9SDave Chinner mval[-1].br_state = mval->br_state; 375930f712c9SDave Chinner } else if (*n > 0 && mval->br_startblock != DELAYSTARTBLOCK && 376030f712c9SDave Chinner mval[-1].br_startblock != DELAYSTARTBLOCK && 376130f712c9SDave Chinner mval[-1].br_startblock != HOLESTARTBLOCK && 376230f712c9SDave Chinner mval->br_startblock == mval[-1].br_startblock + 376330f712c9SDave Chinner mval[-1].br_blockcount && 3764c3a2f9ffSChristoph Hellwig mval[-1].br_state == mval->br_state) { 376530f712c9SDave Chinner ASSERT(mval->br_startoff == 376630f712c9SDave Chinner mval[-1].br_startoff + mval[-1].br_blockcount); 376730f712c9SDave Chinner mval[-1].br_blockcount += mval->br_blockcount; 376830f712c9SDave Chinner } else if (*n > 0 && 376930f712c9SDave Chinner mval->br_startblock == DELAYSTARTBLOCK && 377030f712c9SDave Chinner mval[-1].br_startblock == DELAYSTARTBLOCK && 377130f712c9SDave Chinner mval->br_startoff == 377230f712c9SDave Chinner mval[-1].br_startoff + mval[-1].br_blockcount) { 377330f712c9SDave Chinner mval[-1].br_blockcount += mval->br_blockcount; 377430f712c9SDave Chinner mval[-1].br_state = mval->br_state; 377530f712c9SDave Chinner } else if (!((*n == 0) && 377630f712c9SDave Chinner ((mval->br_startoff + mval->br_blockcount) <= 377730f712c9SDave Chinner obno))) { 377830f712c9SDave Chinner mval++; 377930f712c9SDave Chinner (*n)++; 378030f712c9SDave Chinner } 378130f712c9SDave Chinner *map = mval; 378230f712c9SDave Chinner } 378330f712c9SDave Chinner 378430f712c9SDave Chinner /* 378530f712c9SDave Chinner * Map file blocks to filesystem blocks without allocation. 378630f712c9SDave Chinner */ 378730f712c9SDave Chinner int 378830f712c9SDave Chinner xfs_bmapi_read( 378930f712c9SDave Chinner struct xfs_inode *ip, 379030f712c9SDave Chinner xfs_fileoff_t bno, 379130f712c9SDave Chinner xfs_filblks_t len, 379230f712c9SDave Chinner struct xfs_bmbt_irec *mval, 379330f712c9SDave Chinner int *nmap, 379430f712c9SDave Chinner int flags) 379530f712c9SDave Chinner { 379630f712c9SDave Chinner struct xfs_mount *mp = ip->i_mount; 379730f712c9SDave Chinner struct xfs_ifork *ifp; 379830f712c9SDave Chinner struct xfs_bmbt_irec got; 379930f712c9SDave Chinner xfs_fileoff_t obno; 380030f712c9SDave Chinner xfs_fileoff_t end; 3801b2b1712aSChristoph Hellwig struct xfs_iext_cursor icur; 380230f712c9SDave Chinner int error; 3803334f3423SChristoph Hellwig bool eof = false; 380430f712c9SDave Chinner int n = 0; 38053993baebSDarrick J. Wong int whichfork = xfs_bmapi_whichfork(flags); 380630f712c9SDave Chinner 380730f712c9SDave Chinner ASSERT(*nmap >= 1); 380830f712c9SDave Chinner ASSERT(!(flags & ~(XFS_BMAPI_ATTRFORK|XFS_BMAPI_ENTIRE| 3809c3a2f9ffSChristoph Hellwig XFS_BMAPI_COWFORK))); 381030f712c9SDave Chinner ASSERT(xfs_isilocked(ip, XFS_ILOCK_SHARED|XFS_ILOCK_EXCL)); 381130f712c9SDave Chinner 381230f712c9SDave Chinner if (unlikely(XFS_TEST_ERROR( 381330f712c9SDave Chinner (XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS && 381430f712c9SDave Chinner XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE), 38159e24cfd0SDarrick J. Wong mp, XFS_ERRTAG_BMAPIFORMAT))) { 381630f712c9SDave Chinner XFS_ERROR_REPORT("xfs_bmapi_read", XFS_ERRLEVEL_LOW, mp); 38172451337dSDave Chinner return -EFSCORRUPTED; 381830f712c9SDave Chinner } 381930f712c9SDave Chinner 382030f712c9SDave Chinner if (XFS_FORCED_SHUTDOWN(mp)) 38212451337dSDave Chinner return -EIO; 382230f712c9SDave Chinner 3823ff6d6af2SBill O'Donnell XFS_STATS_INC(mp, xs_blk_mapr); 382430f712c9SDave Chinner 382530f712c9SDave Chinner ifp = XFS_IFORK_PTR(ip, whichfork); 382630f712c9SDave Chinner 38273993baebSDarrick J. Wong /* No CoW fork? Return a hole. */ 38283993baebSDarrick J. Wong if (whichfork == XFS_COW_FORK && !ifp) { 38293993baebSDarrick J. Wong mval->br_startoff = bno; 38303993baebSDarrick J. Wong mval->br_startblock = HOLESTARTBLOCK; 38313993baebSDarrick J. Wong mval->br_blockcount = len; 38323993baebSDarrick J. Wong mval->br_state = XFS_EXT_NORM; 38333993baebSDarrick J. Wong *nmap = 1; 38343993baebSDarrick J. Wong return 0; 38353993baebSDarrick J. Wong } 38363993baebSDarrick J. Wong 383730f712c9SDave Chinner if (!(ifp->if_flags & XFS_IFEXTENTS)) { 383830f712c9SDave Chinner error = xfs_iread_extents(NULL, ip, whichfork); 383930f712c9SDave Chinner if (error) 384030f712c9SDave Chinner return error; 384130f712c9SDave Chinner } 384230f712c9SDave Chinner 3843b2b1712aSChristoph Hellwig if (!xfs_iext_lookup_extent(ip, ifp, bno, &icur, &got)) 3844334f3423SChristoph Hellwig eof = true; 384530f712c9SDave Chinner end = bno + len; 384630f712c9SDave Chinner obno = bno; 384730f712c9SDave Chinner 384830f712c9SDave Chinner while (bno < end && n < *nmap) { 384930f712c9SDave Chinner /* Reading past eof, act as though there's a hole up to end. */ 385030f712c9SDave Chinner if (eof) 385130f712c9SDave Chinner got.br_startoff = end; 385230f712c9SDave Chinner if (got.br_startoff > bno) { 385330f712c9SDave Chinner /* Reading in a hole. */ 385430f712c9SDave Chinner mval->br_startoff = bno; 385530f712c9SDave Chinner mval->br_startblock = HOLESTARTBLOCK; 385630f712c9SDave Chinner mval->br_blockcount = 385730f712c9SDave Chinner XFS_FILBLKS_MIN(len, got.br_startoff - bno); 385830f712c9SDave Chinner mval->br_state = XFS_EXT_NORM; 385930f712c9SDave Chinner bno += mval->br_blockcount; 386030f712c9SDave Chinner len -= mval->br_blockcount; 386130f712c9SDave Chinner mval++; 386230f712c9SDave Chinner n++; 386330f712c9SDave Chinner continue; 386430f712c9SDave Chinner } 386530f712c9SDave Chinner 386630f712c9SDave Chinner /* set up the extent map to return. */ 386730f712c9SDave Chinner xfs_bmapi_trim_map(mval, &got, &bno, len, obno, end, n, flags); 386830f712c9SDave Chinner xfs_bmapi_update_map(&mval, &bno, &len, obno, end, &n, flags); 386930f712c9SDave Chinner 387030f712c9SDave Chinner /* If we're done, stop now. */ 387130f712c9SDave Chinner if (bno >= end || n >= *nmap) 387230f712c9SDave Chinner break; 387330f712c9SDave Chinner 387430f712c9SDave Chinner /* Else go on to the next record. */ 3875b2b1712aSChristoph Hellwig if (!xfs_iext_next_extent(ifp, &icur, &got)) 3876334f3423SChristoph Hellwig eof = true; 387730f712c9SDave Chinner } 387830f712c9SDave Chinner *nmap = n; 387930f712c9SDave Chinner return 0; 388030f712c9SDave Chinner } 388130f712c9SDave Chinner 3882f65e6fadSBrian Foster /* 3883f65e6fadSBrian Foster * Add a delayed allocation extent to an inode. Blocks are reserved from the 3884f65e6fadSBrian Foster * global pool and the extent inserted into the inode in-core extent tree. 3885f65e6fadSBrian Foster * 3886f65e6fadSBrian Foster * On entry, got refers to the first extent beyond the offset of the extent to 3887f65e6fadSBrian Foster * allocate or eof is specified if no such extent exists. On return, got refers 3888f65e6fadSBrian Foster * to the extent record that was inserted to the inode fork. 3889f65e6fadSBrian Foster * 3890f65e6fadSBrian Foster * Note that the allocated extent may have been merged with contiguous extents 3891f65e6fadSBrian Foster * during insertion into the inode fork. Thus, got does not reflect the current 3892f65e6fadSBrian Foster * state of the inode fork on return. If necessary, the caller can use lastx to 3893f65e6fadSBrian Foster * look up the updated record in the inode fork. 3894f65e6fadSBrian Foster */ 389551446f5bSChristoph Hellwig int 389630f712c9SDave Chinner xfs_bmapi_reserve_delalloc( 389730f712c9SDave Chinner struct xfs_inode *ip, 3898be51f811SDarrick J. Wong int whichfork, 3899974ae922SBrian Foster xfs_fileoff_t off, 390030f712c9SDave Chinner xfs_filblks_t len, 3901974ae922SBrian Foster xfs_filblks_t prealloc, 390230f712c9SDave Chinner struct xfs_bmbt_irec *got, 3903b2b1712aSChristoph Hellwig struct xfs_iext_cursor *icur, 390430f712c9SDave Chinner int eof) 390530f712c9SDave Chinner { 390630f712c9SDave Chinner struct xfs_mount *mp = ip->i_mount; 3907be51f811SDarrick J. Wong struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, whichfork); 390830f712c9SDave Chinner xfs_extlen_t alen; 390930f712c9SDave Chinner xfs_extlen_t indlen; 391030f712c9SDave Chinner int error; 3911974ae922SBrian Foster xfs_fileoff_t aoff = off; 391230f712c9SDave Chinner 3913974ae922SBrian Foster /* 3914974ae922SBrian Foster * Cap the alloc length. Keep track of prealloc so we know whether to 3915974ae922SBrian Foster * tag the inode before we return. 3916974ae922SBrian Foster */ 3917974ae922SBrian Foster alen = XFS_FILBLKS_MIN(len + prealloc, MAXEXTLEN); 391830f712c9SDave Chinner if (!eof) 391930f712c9SDave Chinner alen = XFS_FILBLKS_MIN(alen, got->br_startoff - aoff); 3920974ae922SBrian Foster if (prealloc && alen >= len) 3921974ae922SBrian Foster prealloc = alen - len; 392230f712c9SDave Chinner 392330f712c9SDave Chinner /* Figure out the extent size, adjust alen */ 39246ca30729SShan Hai if (whichfork == XFS_COW_FORK) { 392565c5f419SChristoph Hellwig struct xfs_bmbt_irec prev; 39266ca30729SShan Hai xfs_extlen_t extsz = xfs_get_cowextsz_hint(ip); 392765c5f419SChristoph Hellwig 3928b2b1712aSChristoph Hellwig if (!xfs_iext_peek_prev_extent(ifp, icur, &prev)) 392965c5f419SChristoph Hellwig prev.br_startoff = NULLFILEOFF; 393065c5f419SChristoph Hellwig 39316ca30729SShan Hai error = xfs_bmap_extsize_align(mp, got, &prev, extsz, 0, eof, 393230f712c9SDave Chinner 1, 0, &aoff, &alen); 393330f712c9SDave Chinner ASSERT(!error); 393430f712c9SDave Chinner } 393530f712c9SDave Chinner 393630f712c9SDave Chinner /* 393730f712c9SDave Chinner * Make a transaction-less quota reservation for delayed allocation 393830f712c9SDave Chinner * blocks. This number gets adjusted later. We return if we haven't 393930f712c9SDave Chinner * allocated blocks already inside this loop. 394030f712c9SDave Chinner */ 394130f712c9SDave Chinner error = xfs_trans_reserve_quota_nblks(NULL, ip, (long)alen, 0, 39426ca30729SShan Hai XFS_QMOPT_RES_REGBLKS); 394330f712c9SDave Chinner if (error) 394430f712c9SDave Chinner return error; 394530f712c9SDave Chinner 394630f712c9SDave Chinner /* 394730f712c9SDave Chinner * Split changing sb for alen and indlen since they could be coming 394830f712c9SDave Chinner * from different places. 394930f712c9SDave Chinner */ 395030f712c9SDave Chinner indlen = (xfs_extlen_t)xfs_bmap_worst_indlen(ip, alen); 395130f712c9SDave Chinner ASSERT(indlen > 0); 395230f712c9SDave Chinner 39530d485adaSDave Chinner error = xfs_mod_fdblocks(mp, -((int64_t)alen), false); 395430f712c9SDave Chinner if (error) 395530f712c9SDave Chinner goto out_unreserve_quota; 395630f712c9SDave Chinner 39570d485adaSDave Chinner error = xfs_mod_fdblocks(mp, -((int64_t)indlen), false); 395830f712c9SDave Chinner if (error) 395930f712c9SDave Chinner goto out_unreserve_blocks; 396030f712c9SDave Chinner 396130f712c9SDave Chinner 396230f712c9SDave Chinner ip->i_delayed_blks += alen; 396330f712c9SDave Chinner 396430f712c9SDave Chinner got->br_startoff = aoff; 396530f712c9SDave Chinner got->br_startblock = nullstartblock(indlen); 396630f712c9SDave Chinner got->br_blockcount = alen; 396730f712c9SDave Chinner got->br_state = XFS_EXT_NORM; 396830f712c9SDave Chinner 3969b2b1712aSChristoph Hellwig xfs_bmap_add_extent_hole_delay(ip, whichfork, icur, got); 397030f712c9SDave Chinner 3971974ae922SBrian Foster /* 3972974ae922SBrian Foster * Tag the inode if blocks were preallocated. Note that COW fork 3973974ae922SBrian Foster * preallocation can occur at the start or end of the extent, even when 3974974ae922SBrian Foster * prealloc == 0, so we must also check the aligned offset and length. 3975974ae922SBrian Foster */ 3976974ae922SBrian Foster if (whichfork == XFS_DATA_FORK && prealloc) 3977974ae922SBrian Foster xfs_inode_set_eofblocks_tag(ip); 3978974ae922SBrian Foster if (whichfork == XFS_COW_FORK && (prealloc || aoff < off || alen > len)) 3979974ae922SBrian Foster xfs_inode_set_cowblocks_tag(ip); 3980974ae922SBrian Foster 398130f712c9SDave Chinner return 0; 398230f712c9SDave Chinner 398330f712c9SDave Chinner out_unreserve_blocks: 39840d485adaSDave Chinner xfs_mod_fdblocks(mp, alen, false); 398530f712c9SDave Chinner out_unreserve_quota: 398630f712c9SDave Chinner if (XFS_IS_QUOTA_ON(mp)) 39876ca30729SShan Hai xfs_trans_unreserve_quota_nblks(NULL, ip, (long)alen, 0, 39886ca30729SShan Hai XFS_QMOPT_RES_REGBLKS); 398930f712c9SDave Chinner return error; 399030f712c9SDave Chinner } 399130f712c9SDave Chinner 39927f8a058fSDave Chinner static int 39937f8a058fSDave Chinner xfs_bmapi_allocate( 399430f712c9SDave Chinner struct xfs_bmalloca *bma) 399530f712c9SDave Chinner { 399630f712c9SDave Chinner struct xfs_mount *mp = bma->ip->i_mount; 399760b4984fSDarrick J. Wong int whichfork = xfs_bmapi_whichfork(bma->flags); 399830f712c9SDave Chinner struct xfs_ifork *ifp = XFS_IFORK_PTR(bma->ip, whichfork); 399930f712c9SDave Chinner int tmp_logflags = 0; 400030f712c9SDave Chinner int error; 400130f712c9SDave Chinner 400230f712c9SDave Chinner ASSERT(bma->length > 0); 400330f712c9SDave Chinner 400430f712c9SDave Chinner /* 400530f712c9SDave Chinner * For the wasdelay case, we could also just allocate the stuff asked 400630f712c9SDave Chinner * for in this bmap call but that wouldn't be as good. 400730f712c9SDave Chinner */ 400830f712c9SDave Chinner if (bma->wasdel) { 400930f712c9SDave Chinner bma->length = (xfs_extlen_t)bma->got.br_blockcount; 401030f712c9SDave Chinner bma->offset = bma->got.br_startoff; 4011b2b1712aSChristoph Hellwig xfs_iext_peek_prev_extent(ifp, &bma->icur, &bma->prev); 401230f712c9SDave Chinner } else { 401330f712c9SDave Chinner bma->length = XFS_FILBLKS_MIN(bma->length, MAXEXTLEN); 401430f712c9SDave Chinner if (!bma->eof) 401530f712c9SDave Chinner bma->length = XFS_FILBLKS_MIN(bma->length, 401630f712c9SDave Chinner bma->got.br_startoff - bma->offset); 401730f712c9SDave Chinner } 401830f712c9SDave Chinner 401930f712c9SDave Chinner /* 4020292378edSDave Chinner * Set the data type being allocated. For the data fork, the first data 4021292378edSDave Chinner * in the file is treated differently to all other allocations. For the 4022292378edSDave Chinner * attribute fork, we only need to ensure the allocated range is not on 4023292378edSDave Chinner * the busy list. 402430f712c9SDave Chinner */ 402530f712c9SDave Chinner if (!(bma->flags & XFS_BMAPI_METADATA)) { 4026292378edSDave Chinner bma->datatype = XFS_ALLOC_NOBUSY; 4027292378edSDave Chinner if (whichfork == XFS_DATA_FORK) { 4028292378edSDave Chinner if (bma->offset == 0) 4029292378edSDave Chinner bma->datatype |= XFS_ALLOC_INITIAL_USER_DATA; 4030292378edSDave Chinner else 4031292378edSDave Chinner bma->datatype |= XFS_ALLOC_USERDATA; 4032292378edSDave Chinner } 40333fbbbea3SDave Chinner if (bma->flags & XFS_BMAPI_ZERO) 4034292378edSDave Chinner bma->datatype |= XFS_ALLOC_USERDATA_ZERO; 403530f712c9SDave Chinner } 403630f712c9SDave Chinner 403730f712c9SDave Chinner bma->minlen = (bma->flags & XFS_BMAPI_CONTIG) ? bma->length : 1; 403830f712c9SDave Chinner 403930f712c9SDave Chinner /* 404030f712c9SDave Chinner * Only want to do the alignment at the eof if it is userdata and 404130f712c9SDave Chinner * allocation length is larger than a stripe unit. 404230f712c9SDave Chinner */ 404330f712c9SDave Chinner if (mp->m_dalign && bma->length >= mp->m_dalign && 404430f712c9SDave Chinner !(bma->flags & XFS_BMAPI_METADATA) && whichfork == XFS_DATA_FORK) { 404530f712c9SDave Chinner error = xfs_bmap_isaeof(bma, whichfork); 404630f712c9SDave Chinner if (error) 404730f712c9SDave Chinner return error; 404830f712c9SDave Chinner } 404930f712c9SDave Chinner 405030f712c9SDave Chinner error = xfs_bmap_alloc(bma); 405130f712c9SDave Chinner if (error) 405230f712c9SDave Chinner return error; 405330f712c9SDave Chinner 405430f712c9SDave Chinner if (bma->blkno == NULLFSBLOCK) 405530f712c9SDave Chinner return 0; 4056cf612de7SBrian Foster if ((ifp->if_flags & XFS_IFBROOT) && !bma->cur) 405730f712c9SDave Chinner bma->cur = xfs_bmbt_init_cursor(mp, bma->tp, bma->ip, whichfork); 405830f712c9SDave Chinner /* 405930f712c9SDave Chinner * Bump the number of extents we've allocated 406030f712c9SDave Chinner * in this call. 406130f712c9SDave Chinner */ 406230f712c9SDave Chinner bma->nallocs++; 406330f712c9SDave Chinner 406430f712c9SDave Chinner if (bma->cur) 406530f712c9SDave Chinner bma->cur->bc_private.b.flags = 406630f712c9SDave Chinner bma->wasdel ? XFS_BTCUR_BPRV_WASDEL : 0; 406730f712c9SDave Chinner 406830f712c9SDave Chinner bma->got.br_startoff = bma->offset; 406930f712c9SDave Chinner bma->got.br_startblock = bma->blkno; 407030f712c9SDave Chinner bma->got.br_blockcount = bma->length; 407130f712c9SDave Chinner bma->got.br_state = XFS_EXT_NORM; 407230f712c9SDave Chinner 407330f712c9SDave Chinner /* 407405a630d7SDarrick J. Wong * In the data fork, a wasdelay extent has been initialized, so 407505a630d7SDarrick J. Wong * shouldn't be flagged as unwritten. 407605a630d7SDarrick J. Wong * 407705a630d7SDarrick J. Wong * For the cow fork, however, we convert delalloc reservations 407805a630d7SDarrick J. Wong * (extents allocated for speculative preallocation) to 407905a630d7SDarrick J. Wong * allocated unwritten extents, and only convert the unwritten 408005a630d7SDarrick J. Wong * extents to real extents when we're about to write the data. 408130f712c9SDave Chinner */ 408205a630d7SDarrick J. Wong if ((!bma->wasdel || (bma->flags & XFS_BMAPI_COWFORK)) && 408305a630d7SDarrick J. Wong (bma->flags & XFS_BMAPI_PREALLOC) && 408430f712c9SDave Chinner xfs_sb_version_hasextflgbit(&mp->m_sb)) 408530f712c9SDave Chinner bma->got.br_state = XFS_EXT_UNWRITTEN; 408630f712c9SDave Chinner 408730f712c9SDave Chinner if (bma->wasdel) 408860b4984fSDarrick J. Wong error = xfs_bmap_add_extent_delay_real(bma, whichfork); 408930f712c9SDave Chinner else 40906d04558fSChristoph Hellwig error = xfs_bmap_add_extent_hole_real(bma->tp, bma->ip, 4091b2b1712aSChristoph Hellwig whichfork, &bma->icur, &bma->cur, &bma->got, 409292f9da30SBrian Foster &bma->logflags, bma->flags); 409330f712c9SDave Chinner 409430f712c9SDave Chinner bma->logflags |= tmp_logflags; 409530f712c9SDave Chinner if (error) 409630f712c9SDave Chinner return error; 409730f712c9SDave Chinner 409830f712c9SDave Chinner /* 409930f712c9SDave Chinner * Update our extent pointer, given that xfs_bmap_add_extent_delay_real 410030f712c9SDave Chinner * or xfs_bmap_add_extent_hole_real might have merged it into one of 410130f712c9SDave Chinner * the neighbouring ones. 410230f712c9SDave Chinner */ 4103b2b1712aSChristoph Hellwig xfs_iext_get_extent(ifp, &bma->icur, &bma->got); 410430f712c9SDave Chinner 410530f712c9SDave Chinner ASSERT(bma->got.br_startoff <= bma->offset); 410630f712c9SDave Chinner ASSERT(bma->got.br_startoff + bma->got.br_blockcount >= 410730f712c9SDave Chinner bma->offset + bma->length); 410830f712c9SDave Chinner ASSERT(bma->got.br_state == XFS_EXT_NORM || 410930f712c9SDave Chinner bma->got.br_state == XFS_EXT_UNWRITTEN); 411030f712c9SDave Chinner return 0; 411130f712c9SDave Chinner } 411230f712c9SDave Chinner 411330f712c9SDave Chinner STATIC int 411430f712c9SDave Chinner xfs_bmapi_convert_unwritten( 411530f712c9SDave Chinner struct xfs_bmalloca *bma, 411630f712c9SDave Chinner struct xfs_bmbt_irec *mval, 411730f712c9SDave Chinner xfs_filblks_t len, 411830f712c9SDave Chinner int flags) 411930f712c9SDave Chinner { 41203993baebSDarrick J. Wong int whichfork = xfs_bmapi_whichfork(flags); 412130f712c9SDave Chinner struct xfs_ifork *ifp = XFS_IFORK_PTR(bma->ip, whichfork); 412230f712c9SDave Chinner int tmp_logflags = 0; 412330f712c9SDave Chinner int error; 412430f712c9SDave Chinner 412530f712c9SDave Chinner /* check if we need to do unwritten->real conversion */ 412630f712c9SDave Chinner if (mval->br_state == XFS_EXT_UNWRITTEN && 412730f712c9SDave Chinner (flags & XFS_BMAPI_PREALLOC)) 412830f712c9SDave Chinner return 0; 412930f712c9SDave Chinner 413030f712c9SDave Chinner /* check if we need to do real->unwritten conversion */ 413130f712c9SDave Chinner if (mval->br_state == XFS_EXT_NORM && 413230f712c9SDave Chinner (flags & (XFS_BMAPI_PREALLOC | XFS_BMAPI_CONVERT)) != 413330f712c9SDave Chinner (XFS_BMAPI_PREALLOC | XFS_BMAPI_CONVERT)) 413430f712c9SDave Chinner return 0; 413530f712c9SDave Chinner 413630f712c9SDave Chinner /* 413730f712c9SDave Chinner * Modify (by adding) the state flag, if writing. 413830f712c9SDave Chinner */ 413930f712c9SDave Chinner ASSERT(mval->br_blockcount <= len); 414030f712c9SDave Chinner if ((ifp->if_flags & XFS_IFBROOT) && !bma->cur) { 414130f712c9SDave Chinner bma->cur = xfs_bmbt_init_cursor(bma->ip->i_mount, bma->tp, 414230f712c9SDave Chinner bma->ip, whichfork); 414330f712c9SDave Chinner } 414430f712c9SDave Chinner mval->br_state = (mval->br_state == XFS_EXT_UNWRITTEN) 414530f712c9SDave Chinner ? XFS_EXT_NORM : XFS_EXT_UNWRITTEN; 414630f712c9SDave Chinner 41473fbbbea3SDave Chinner /* 41483fbbbea3SDave Chinner * Before insertion into the bmbt, zero the range being converted 41493fbbbea3SDave Chinner * if required. 41503fbbbea3SDave Chinner */ 41513fbbbea3SDave Chinner if (flags & XFS_BMAPI_ZERO) { 41523fbbbea3SDave Chinner error = xfs_zero_extent(bma->ip, mval->br_startblock, 41533fbbbea3SDave Chinner mval->br_blockcount); 41543fbbbea3SDave Chinner if (error) 41553fbbbea3SDave Chinner return error; 41563fbbbea3SDave Chinner } 41573fbbbea3SDave Chinner 415805a630d7SDarrick J. Wong error = xfs_bmap_add_extent_unwritten_real(bma->tp, bma->ip, whichfork, 415992f9da30SBrian Foster &bma->icur, &bma->cur, mval, &tmp_logflags); 41602e588a46SBrian Foster /* 41612e588a46SBrian Foster * Log the inode core unconditionally in the unwritten extent conversion 41622e588a46SBrian Foster * path because the conversion might not have done so (e.g., if the 41632e588a46SBrian Foster * extent count hasn't changed). We need to make sure the inode is dirty 41642e588a46SBrian Foster * in the transaction for the sake of fsync(), even if nothing has 41652e588a46SBrian Foster * changed, because fsync() will not force the log for this transaction 41662e588a46SBrian Foster * unless it sees the inode pinned. 416705a630d7SDarrick J. Wong * 416805a630d7SDarrick J. Wong * Note: If we're only converting cow fork extents, there aren't 416905a630d7SDarrick J. Wong * any on-disk updates to make, so we don't need to log anything. 41702e588a46SBrian Foster */ 417105a630d7SDarrick J. Wong if (whichfork != XFS_COW_FORK) 41722e588a46SBrian Foster bma->logflags |= tmp_logflags | XFS_ILOG_CORE; 417330f712c9SDave Chinner if (error) 417430f712c9SDave Chinner return error; 417530f712c9SDave Chinner 417630f712c9SDave Chinner /* 417730f712c9SDave Chinner * Update our extent pointer, given that 417830f712c9SDave Chinner * xfs_bmap_add_extent_unwritten_real might have merged it into one 417930f712c9SDave Chinner * of the neighbouring ones. 418030f712c9SDave Chinner */ 4181b2b1712aSChristoph Hellwig xfs_iext_get_extent(ifp, &bma->icur, &bma->got); 418230f712c9SDave Chinner 418330f712c9SDave Chinner /* 418430f712c9SDave Chinner * We may have combined previously unwritten space with written space, 418530f712c9SDave Chinner * so generate another request. 418630f712c9SDave Chinner */ 418730f712c9SDave Chinner if (mval->br_blockcount < len) 41882451337dSDave Chinner return -EAGAIN; 418930f712c9SDave Chinner return 0; 419030f712c9SDave Chinner } 419130f712c9SDave Chinner 419230f712c9SDave Chinner /* 419330f712c9SDave Chinner * Map file blocks to filesystem blocks, and allocate blocks or convert the 419430f712c9SDave Chinner * extent state if necessary. Details behaviour is controlled by the flags 419530f712c9SDave Chinner * parameter. Only allocates blocks from a single allocation group, to avoid 419630f712c9SDave Chinner * locking problems. 419730f712c9SDave Chinner */ 419830f712c9SDave Chinner int 419930f712c9SDave Chinner xfs_bmapi_write( 420030f712c9SDave Chinner struct xfs_trans *tp, /* transaction pointer */ 420130f712c9SDave Chinner struct xfs_inode *ip, /* incore inode */ 420230f712c9SDave Chinner xfs_fileoff_t bno, /* starting file offs. mapped */ 420330f712c9SDave Chinner xfs_filblks_t len, /* length to map in file */ 420430f712c9SDave Chinner int flags, /* XFS_BMAPI_... */ 420530f712c9SDave Chinner xfs_extlen_t total, /* total blocks needed */ 420630f712c9SDave Chinner struct xfs_bmbt_irec *mval, /* output: map values */ 42076e702a5dSBrian Foster int *nmap) /* i/o: mval size/count */ 420830f712c9SDave Chinner { 420930f712c9SDave Chinner struct xfs_mount *mp = ip->i_mount; 421030f712c9SDave Chinner struct xfs_ifork *ifp; 421130f712c9SDave Chinner struct xfs_bmalloca bma = { NULL }; /* args for xfs_bmap_alloc */ 421230f712c9SDave Chinner xfs_fileoff_t end; /* end of mapped file region */ 42132d58f6efSChristoph Hellwig bool eof = false; /* after the end of extents */ 421430f712c9SDave Chinner int error; /* error return */ 421530f712c9SDave Chinner int n; /* current extent index */ 421630f712c9SDave Chinner xfs_fileoff_t obno; /* old block number (offset) */ 421730f712c9SDave Chinner int whichfork; /* data or attr fork */ 421830f712c9SDave Chinner 421930f712c9SDave Chinner #ifdef DEBUG 422030f712c9SDave Chinner xfs_fileoff_t orig_bno; /* original block number value */ 422130f712c9SDave Chinner int orig_flags; /* original flags arg value */ 422230f712c9SDave Chinner xfs_filblks_t orig_len; /* original value of len arg */ 422330f712c9SDave Chinner struct xfs_bmbt_irec *orig_mval; /* original value of mval */ 422430f712c9SDave Chinner int orig_nmap; /* original value of *nmap */ 422530f712c9SDave Chinner 422630f712c9SDave Chinner orig_bno = bno; 422730f712c9SDave Chinner orig_len = len; 422830f712c9SDave Chinner orig_flags = flags; 422930f712c9SDave Chinner orig_mval = mval; 423030f712c9SDave Chinner orig_nmap = *nmap; 423130f712c9SDave Chinner #endif 423260b4984fSDarrick J. Wong whichfork = xfs_bmapi_whichfork(flags); 423330f712c9SDave Chinner 423430f712c9SDave Chinner ASSERT(*nmap >= 1); 423530f712c9SDave Chinner ASSERT(*nmap <= XFS_BMAP_MAX_NMAP); 423605a630d7SDarrick J. Wong ASSERT(tp != NULL || 423705a630d7SDarrick J. Wong (flags & (XFS_BMAPI_CONVERT | XFS_BMAPI_COWFORK)) == 423805a630d7SDarrick J. Wong (XFS_BMAPI_CONVERT | XFS_BMAPI_COWFORK)); 423930f712c9SDave Chinner ASSERT(len > 0); 424030f712c9SDave Chinner ASSERT(XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_LOCAL); 424130f712c9SDave Chinner ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL)); 42426ebd5a44SChristoph Hellwig ASSERT(!(flags & XFS_BMAPI_REMAP)); 424330f712c9SDave Chinner 42443fbbbea3SDave Chinner /* zeroing is for currently only for data extents, not metadata */ 42453fbbbea3SDave Chinner ASSERT((flags & (XFS_BMAPI_METADATA | XFS_BMAPI_ZERO)) != 42463fbbbea3SDave Chinner (XFS_BMAPI_METADATA | XFS_BMAPI_ZERO)); 42473fbbbea3SDave Chinner /* 42483fbbbea3SDave Chinner * we can allocate unwritten extents or pre-zero allocated blocks, 42493fbbbea3SDave Chinner * but it makes no sense to do both at once. This would result in 42503fbbbea3SDave Chinner * zeroing the unwritten extent twice, but it still being an 42513fbbbea3SDave Chinner * unwritten extent.... 42523fbbbea3SDave Chinner */ 42533fbbbea3SDave Chinner ASSERT((flags & (XFS_BMAPI_PREALLOC | XFS_BMAPI_ZERO)) != 42543fbbbea3SDave Chinner (XFS_BMAPI_PREALLOC | XFS_BMAPI_ZERO)); 42553fbbbea3SDave Chinner 425630f712c9SDave Chinner if (unlikely(XFS_TEST_ERROR( 425730f712c9SDave Chinner (XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS && 425830f712c9SDave Chinner XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE), 42599e24cfd0SDarrick J. Wong mp, XFS_ERRTAG_BMAPIFORMAT))) { 426030f712c9SDave Chinner XFS_ERROR_REPORT("xfs_bmapi_write", XFS_ERRLEVEL_LOW, mp); 42612451337dSDave Chinner return -EFSCORRUPTED; 426230f712c9SDave Chinner } 426330f712c9SDave Chinner 426430f712c9SDave Chinner if (XFS_FORCED_SHUTDOWN(mp)) 42652451337dSDave Chinner return -EIO; 426630f712c9SDave Chinner 426730f712c9SDave Chinner ifp = XFS_IFORK_PTR(ip, whichfork); 426830f712c9SDave Chinner 4269ff6d6af2SBill O'Donnell XFS_STATS_INC(mp, xs_blk_mapw); 427030f712c9SDave Chinner 4271a7beabeaSBrian Foster if (!tp || tp->t_firstblock == NULLFSBLOCK) { 427230f712c9SDave Chinner if (XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_BTREE) 427330f712c9SDave Chinner bma.minleft = be16_to_cpu(ifp->if_broot->bb_level) + 1; 427430f712c9SDave Chinner else 427530f712c9SDave Chinner bma.minleft = 1; 427630f712c9SDave Chinner } else { 427730f712c9SDave Chinner bma.minleft = 0; 427830f712c9SDave Chinner } 427930f712c9SDave Chinner 428030f712c9SDave Chinner if (!(ifp->if_flags & XFS_IFEXTENTS)) { 428130f712c9SDave Chinner error = xfs_iread_extents(tp, ip, whichfork); 428230f712c9SDave Chinner if (error) 428330f712c9SDave Chinner goto error0; 428430f712c9SDave Chinner } 428530f712c9SDave Chinner 428630f712c9SDave Chinner n = 0; 428730f712c9SDave Chinner end = bno + len; 428830f712c9SDave Chinner obno = bno; 428930f712c9SDave Chinner 4290b2b1712aSChristoph Hellwig if (!xfs_iext_lookup_extent(ip, ifp, bno, &bma.icur, &bma.got)) 42912d58f6efSChristoph Hellwig eof = true; 4292b2b1712aSChristoph Hellwig if (!xfs_iext_peek_prev_extent(ifp, &bma.icur, &bma.prev)) 42932d58f6efSChristoph Hellwig bma.prev.br_startoff = NULLFILEOFF; 429430f712c9SDave Chinner bma.tp = tp; 429530f712c9SDave Chinner bma.ip = ip; 429630f712c9SDave Chinner bma.total = total; 4297292378edSDave Chinner bma.datatype = 0; 42983e3673e3SBrian Foster ASSERT(!tp || tp->t_dfops); 429930f712c9SDave Chinner 430030f712c9SDave Chinner while (bno < end && n < *nmap) { 4301d2b3964aSChristoph Hellwig bool need_alloc = false, wasdelay = false; 430230f712c9SDave Chinner 4303be78ff0eSDarrick J. Wong /* in hole or beyond EOF? */ 4304d2b3964aSChristoph Hellwig if (eof || bma.got.br_startoff > bno) { 4305be78ff0eSDarrick J. Wong /* 4306be78ff0eSDarrick J. Wong * CoW fork conversions should /never/ hit EOF or 4307be78ff0eSDarrick J. Wong * holes. There should always be something for us 4308be78ff0eSDarrick J. Wong * to work on. 4309be78ff0eSDarrick J. Wong */ 4310be78ff0eSDarrick J. Wong ASSERT(!((flags & XFS_BMAPI_CONVERT) && 4311be78ff0eSDarrick J. Wong (flags & XFS_BMAPI_COWFORK))); 4312be78ff0eSDarrick J. Wong 4313d2b3964aSChristoph Hellwig if (flags & XFS_BMAPI_DELALLOC) { 4314d2b3964aSChristoph Hellwig /* 4315d2b3964aSChristoph Hellwig * For the COW fork we can reasonably get a 4316d2b3964aSChristoph Hellwig * request for converting an extent that races 4317d2b3964aSChristoph Hellwig * with other threads already having converted 4318d2b3964aSChristoph Hellwig * part of it, as there converting COW to 4319d2b3964aSChristoph Hellwig * regular blocks is not protected using the 4320d2b3964aSChristoph Hellwig * IOLOCK. 4321d2b3964aSChristoph Hellwig */ 4322d2b3964aSChristoph Hellwig ASSERT(flags & XFS_BMAPI_COWFORK); 4323d2b3964aSChristoph Hellwig if (!(flags & XFS_BMAPI_COWFORK)) { 4324d2b3964aSChristoph Hellwig error = -EIO; 4325d2b3964aSChristoph Hellwig goto error0; 4326d2b3964aSChristoph Hellwig } 4327d2b3964aSChristoph Hellwig 4328d2b3964aSChristoph Hellwig if (eof || bno >= end) 4329d2b3964aSChristoph Hellwig break; 4330d2b3964aSChristoph Hellwig } else { 4331d2b3964aSChristoph Hellwig need_alloc = true; 4332d2b3964aSChristoph Hellwig } 43336ebd5a44SChristoph Hellwig } else if (isnullstartblock(bma.got.br_startblock)) { 4334d2b3964aSChristoph Hellwig wasdelay = true; 4335d2b3964aSChristoph Hellwig } 4336f65306eaSDarrick J. Wong 4337f65306eaSDarrick J. Wong /* 433830f712c9SDave Chinner * First, deal with the hole before the allocated space 433930f712c9SDave Chinner * that we found, if any. 434030f712c9SDave Chinner */ 4341b121459cSChristoph Hellwig if ((need_alloc || wasdelay) && 4342b121459cSChristoph Hellwig !(flags & XFS_BMAPI_CONVERT_ONLY)) { 434330f712c9SDave Chinner bma.eof = eof; 434430f712c9SDave Chinner bma.conv = !!(flags & XFS_BMAPI_CONVERT); 434530f712c9SDave Chinner bma.wasdel = wasdelay; 434630f712c9SDave Chinner bma.offset = bno; 434730f712c9SDave Chinner bma.flags = flags; 434830f712c9SDave Chinner 434930f712c9SDave Chinner /* 435030f712c9SDave Chinner * There's a 32/64 bit type mismatch between the 435130f712c9SDave Chinner * allocation length request (which can be 64 bits in 435230f712c9SDave Chinner * length) and the bma length request, which is 435330f712c9SDave Chinner * xfs_extlen_t and therefore 32 bits. Hence we have to 435430f712c9SDave Chinner * check for 32-bit overflows and handle them here. 435530f712c9SDave Chinner */ 435630f712c9SDave Chinner if (len > (xfs_filblks_t)MAXEXTLEN) 435730f712c9SDave Chinner bma.length = MAXEXTLEN; 435830f712c9SDave Chinner else 435930f712c9SDave Chinner bma.length = len; 436030f712c9SDave Chinner 436130f712c9SDave Chinner ASSERT(len > 0); 436230f712c9SDave Chinner ASSERT(bma.length > 0); 436330f712c9SDave Chinner error = xfs_bmapi_allocate(&bma); 436430f712c9SDave Chinner if (error) 436530f712c9SDave Chinner goto error0; 436630f712c9SDave Chinner if (bma.blkno == NULLFSBLOCK) 436730f712c9SDave Chinner break; 4368174edb0eSDarrick J. Wong 4369174edb0eSDarrick J. Wong /* 4370174edb0eSDarrick J. Wong * If this is a CoW allocation, record the data in 4371174edb0eSDarrick J. Wong * the refcount btree for orphan recovery. 4372174edb0eSDarrick J. Wong */ 4373174edb0eSDarrick J. Wong if (whichfork == XFS_COW_FORK) { 43746e702a5dSBrian Foster error = xfs_refcount_alloc_cow_extent(mp, 43756e702a5dSBrian Foster tp->t_dfops, bma.blkno, 43766e702a5dSBrian Foster bma.length); 4377174edb0eSDarrick J. Wong if (error) 4378174edb0eSDarrick J. Wong goto error0; 4379174edb0eSDarrick J. Wong } 438030f712c9SDave Chinner } 438130f712c9SDave Chinner 438230f712c9SDave Chinner /* Deal with the allocated space we found. */ 438330f712c9SDave Chinner xfs_bmapi_trim_map(mval, &bma.got, &bno, len, obno, 438430f712c9SDave Chinner end, n, flags); 438530f712c9SDave Chinner 438630f712c9SDave Chinner /* Execute unwritten extent conversion if necessary */ 438730f712c9SDave Chinner error = xfs_bmapi_convert_unwritten(&bma, mval, len, flags); 43882451337dSDave Chinner if (error == -EAGAIN) 438930f712c9SDave Chinner continue; 439030f712c9SDave Chinner if (error) 439130f712c9SDave Chinner goto error0; 439230f712c9SDave Chinner 439330f712c9SDave Chinner /* update the extent map to return */ 439430f712c9SDave Chinner xfs_bmapi_update_map(&mval, &bno, &len, obno, end, &n, flags); 439530f712c9SDave Chinner 439630f712c9SDave Chinner /* 439730f712c9SDave Chinner * If we're done, stop now. Stop when we've allocated 439830f712c9SDave Chinner * XFS_BMAP_MAX_NMAP extents no matter what. Otherwise 439930f712c9SDave Chinner * the transaction may get too big. 440030f712c9SDave Chinner */ 440130f712c9SDave Chinner if (bno >= end || n >= *nmap || bma.nallocs >= *nmap) 440230f712c9SDave Chinner break; 440330f712c9SDave Chinner 440430f712c9SDave Chinner /* Else go on to the next record. */ 440530f712c9SDave Chinner bma.prev = bma.got; 4406b2b1712aSChristoph Hellwig if (!xfs_iext_next_extent(ifp, &bma.icur, &bma.got)) 44072d58f6efSChristoph Hellwig eof = true; 440830f712c9SDave Chinner } 440930f712c9SDave Chinner *nmap = n; 441030f712c9SDave Chinner 441130f712c9SDave Chinner /* 441230f712c9SDave Chinner * Transform from btree to extents, give it cur. 441330f712c9SDave Chinner */ 441430f712c9SDave Chinner if (xfs_bmap_wants_extents(ip, whichfork)) { 441530f712c9SDave Chinner int tmp_logflags = 0; 441630f712c9SDave Chinner 441730f712c9SDave Chinner ASSERT(bma.cur); 441830f712c9SDave Chinner error = xfs_bmap_btree_to_extents(tp, ip, bma.cur, 441930f712c9SDave Chinner &tmp_logflags, whichfork); 442030f712c9SDave Chinner bma.logflags |= tmp_logflags; 442130f712c9SDave Chinner if (error) 442230f712c9SDave Chinner goto error0; 442330f712c9SDave Chinner } 442430f712c9SDave Chinner 442530f712c9SDave Chinner ASSERT(XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE || 442630f712c9SDave Chinner XFS_IFORK_NEXTENTS(ip, whichfork) > 442730f712c9SDave Chinner XFS_IFORK_MAXEXT(ip, whichfork)); 442830f712c9SDave Chinner error = 0; 442930f712c9SDave Chinner error0: 443030f712c9SDave Chinner /* 443130f712c9SDave Chinner * Log everything. Do this after conversion, there's no point in 443230f712c9SDave Chinner * logging the extent records if we've converted to btree format. 443330f712c9SDave Chinner */ 443430f712c9SDave Chinner if ((bma.logflags & xfs_ilog_fext(whichfork)) && 443530f712c9SDave Chinner XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS) 443630f712c9SDave Chinner bma.logflags &= ~xfs_ilog_fext(whichfork); 443730f712c9SDave Chinner else if ((bma.logflags & xfs_ilog_fbroot(whichfork)) && 443830f712c9SDave Chinner XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE) 443930f712c9SDave Chinner bma.logflags &= ~xfs_ilog_fbroot(whichfork); 444030f712c9SDave Chinner /* 444130f712c9SDave Chinner * Log whatever the flags say, even if error. Otherwise we might miss 444230f712c9SDave Chinner * detecting a case where the data is changed, there's an error, 444330f712c9SDave Chinner * and it's not logged so we don't shutdown when we should. 444430f712c9SDave Chinner */ 444530f712c9SDave Chinner if (bma.logflags) 444630f712c9SDave Chinner xfs_trans_log_inode(tp, ip, bma.logflags); 444730f712c9SDave Chinner 444830f712c9SDave Chinner if (bma.cur) { 44490b04b6b8SDarrick J. Wong xfs_btree_del_cursor(bma.cur, error); 445030f712c9SDave Chinner } 445130f712c9SDave Chinner if (!error) 445230f712c9SDave Chinner xfs_bmap_validate_ret(orig_bno, orig_len, orig_flags, orig_mval, 445330f712c9SDave Chinner orig_nmap, *nmap); 445430f712c9SDave Chinner return error; 445530f712c9SDave Chinner } 445630f712c9SDave Chinner 44577cf199baSDarrick J. Wong int 44586ebd5a44SChristoph Hellwig xfs_bmapi_remap( 44596ebd5a44SChristoph Hellwig struct xfs_trans *tp, 44606ebd5a44SChristoph Hellwig struct xfs_inode *ip, 44616ebd5a44SChristoph Hellwig xfs_fileoff_t bno, 44626ebd5a44SChristoph Hellwig xfs_filblks_t len, 44636ebd5a44SChristoph Hellwig xfs_fsblock_t startblock, 44647cf199baSDarrick J. Wong int flags) 44656ebd5a44SChristoph Hellwig { 44666ebd5a44SChristoph Hellwig struct xfs_mount *mp = ip->i_mount; 44677cf199baSDarrick J. Wong struct xfs_ifork *ifp; 44686ebd5a44SChristoph Hellwig struct xfs_btree_cur *cur = NULL; 44696ebd5a44SChristoph Hellwig struct xfs_bmbt_irec got; 4470b2b1712aSChristoph Hellwig struct xfs_iext_cursor icur; 44717cf199baSDarrick J. Wong int whichfork = xfs_bmapi_whichfork(flags); 44726ebd5a44SChristoph Hellwig int logflags = 0, error; 44736ebd5a44SChristoph Hellwig 44747cf199baSDarrick J. Wong ifp = XFS_IFORK_PTR(ip, whichfork); 44756ebd5a44SChristoph Hellwig ASSERT(len > 0); 44766ebd5a44SChristoph Hellwig ASSERT(len <= (xfs_filblks_t)MAXEXTLEN); 44776ebd5a44SChristoph Hellwig ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL)); 44787644bd98SDarrick J. Wong ASSERT(!(flags & ~(XFS_BMAPI_ATTRFORK | XFS_BMAPI_PREALLOC | 44797644bd98SDarrick J. Wong XFS_BMAPI_NORMAP))); 44807644bd98SDarrick J. Wong ASSERT((flags & (XFS_BMAPI_ATTRFORK | XFS_BMAPI_PREALLOC)) != 44817644bd98SDarrick J. Wong (XFS_BMAPI_ATTRFORK | XFS_BMAPI_PREALLOC)); 44826ebd5a44SChristoph Hellwig 44836ebd5a44SChristoph Hellwig if (unlikely(XFS_TEST_ERROR( 44847cf199baSDarrick J. Wong (XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS && 44857cf199baSDarrick J. Wong XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE), 44869e24cfd0SDarrick J. Wong mp, XFS_ERRTAG_BMAPIFORMAT))) { 44876ebd5a44SChristoph Hellwig XFS_ERROR_REPORT("xfs_bmapi_remap", XFS_ERRLEVEL_LOW, mp); 44886ebd5a44SChristoph Hellwig return -EFSCORRUPTED; 44896ebd5a44SChristoph Hellwig } 44906ebd5a44SChristoph Hellwig 44916ebd5a44SChristoph Hellwig if (XFS_FORCED_SHUTDOWN(mp)) 44926ebd5a44SChristoph Hellwig return -EIO; 44936ebd5a44SChristoph Hellwig 44946ebd5a44SChristoph Hellwig if (!(ifp->if_flags & XFS_IFEXTENTS)) { 44957cf199baSDarrick J. Wong error = xfs_iread_extents(tp, ip, whichfork); 44966ebd5a44SChristoph Hellwig if (error) 44976ebd5a44SChristoph Hellwig return error; 44986ebd5a44SChristoph Hellwig } 44996ebd5a44SChristoph Hellwig 4500b2b1712aSChristoph Hellwig if (xfs_iext_lookup_extent(ip, ifp, bno, &icur, &got)) { 45016ebd5a44SChristoph Hellwig /* make sure we only reflink into a hole. */ 45026ebd5a44SChristoph Hellwig ASSERT(got.br_startoff > bno); 45036ebd5a44SChristoph Hellwig ASSERT(got.br_startoff - bno >= len); 45046ebd5a44SChristoph Hellwig } 45056ebd5a44SChristoph Hellwig 4506bf8eadbaSChristoph Hellwig ip->i_d.di_nblocks += len; 4507bf8eadbaSChristoph Hellwig xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE); 45086ebd5a44SChristoph Hellwig 45096ebd5a44SChristoph Hellwig if (ifp->if_flags & XFS_IFBROOT) { 45107cf199baSDarrick J. Wong cur = xfs_bmbt_init_cursor(mp, tp, ip, whichfork); 45116ebd5a44SChristoph Hellwig cur->bc_private.b.flags = 0; 45126ebd5a44SChristoph Hellwig } 45136ebd5a44SChristoph Hellwig 45146ebd5a44SChristoph Hellwig got.br_startoff = bno; 45156ebd5a44SChristoph Hellwig got.br_startblock = startblock; 45166ebd5a44SChristoph Hellwig got.br_blockcount = len; 45177644bd98SDarrick J. Wong if (flags & XFS_BMAPI_PREALLOC) 45187644bd98SDarrick J. Wong got.br_state = XFS_EXT_UNWRITTEN; 45197644bd98SDarrick J. Wong else 45206ebd5a44SChristoph Hellwig got.br_state = XFS_EXT_NORM; 45216ebd5a44SChristoph Hellwig 45227cf199baSDarrick J. Wong error = xfs_bmap_add_extent_hole_real(tp, ip, whichfork, &icur, 452392f9da30SBrian Foster &cur, &got, &logflags, flags); 45246ebd5a44SChristoph Hellwig if (error) 45256ebd5a44SChristoph Hellwig goto error0; 45266ebd5a44SChristoph Hellwig 45277cf199baSDarrick J. Wong if (xfs_bmap_wants_extents(ip, whichfork)) { 45286ebd5a44SChristoph Hellwig int tmp_logflags = 0; 45296ebd5a44SChristoph Hellwig 45306ebd5a44SChristoph Hellwig error = xfs_bmap_btree_to_extents(tp, ip, cur, 45317cf199baSDarrick J. Wong &tmp_logflags, whichfork); 45326ebd5a44SChristoph Hellwig logflags |= tmp_logflags; 45336ebd5a44SChristoph Hellwig } 45346ebd5a44SChristoph Hellwig 45356ebd5a44SChristoph Hellwig error0: 45366ebd5a44SChristoph Hellwig if (ip->i_d.di_format != XFS_DINODE_FMT_EXTENTS) 45376ebd5a44SChristoph Hellwig logflags &= ~XFS_ILOG_DEXT; 45386ebd5a44SChristoph Hellwig else if (ip->i_d.di_format != XFS_DINODE_FMT_BTREE) 45396ebd5a44SChristoph Hellwig logflags &= ~XFS_ILOG_DBROOT; 45406ebd5a44SChristoph Hellwig 45416ebd5a44SChristoph Hellwig if (logflags) 45426ebd5a44SChristoph Hellwig xfs_trans_log_inode(tp, ip, logflags); 45430b04b6b8SDarrick J. Wong if (cur) 45440b04b6b8SDarrick J. Wong xfs_btree_del_cursor(cur, error); 45456ebd5a44SChristoph Hellwig return error; 45466ebd5a44SChristoph Hellwig } 45476ebd5a44SChristoph Hellwig 454830f712c9SDave Chinner /* 4549a9bd24acSBrian Foster * When a delalloc extent is split (e.g., due to a hole punch), the original 4550a9bd24acSBrian Foster * indlen reservation must be shared across the two new extents that are left 4551a9bd24acSBrian Foster * behind. 4552a9bd24acSBrian Foster * 4553a9bd24acSBrian Foster * Given the original reservation and the worst case indlen for the two new 4554a9bd24acSBrian Foster * extents (as calculated by xfs_bmap_worst_indlen()), split the original 4555d34999c9SBrian Foster * reservation fairly across the two new extents. If necessary, steal available 4556d34999c9SBrian Foster * blocks from a deleted extent to make up a reservation deficiency (e.g., if 4557d34999c9SBrian Foster * ores == 1). The number of stolen blocks is returned. The availability and 4558d34999c9SBrian Foster * subsequent accounting of stolen blocks is the responsibility of the caller. 4559a9bd24acSBrian Foster */ 4560d34999c9SBrian Foster static xfs_filblks_t 4561a9bd24acSBrian Foster xfs_bmap_split_indlen( 4562a9bd24acSBrian Foster xfs_filblks_t ores, /* original res. */ 4563a9bd24acSBrian Foster xfs_filblks_t *indlen1, /* ext1 worst indlen */ 4564d34999c9SBrian Foster xfs_filblks_t *indlen2, /* ext2 worst indlen */ 4565d34999c9SBrian Foster xfs_filblks_t avail) /* stealable blocks */ 4566a9bd24acSBrian Foster { 4567a9bd24acSBrian Foster xfs_filblks_t len1 = *indlen1; 4568a9bd24acSBrian Foster xfs_filblks_t len2 = *indlen2; 4569a9bd24acSBrian Foster xfs_filblks_t nres = len1 + len2; /* new total res. */ 4570d34999c9SBrian Foster xfs_filblks_t stolen = 0; 457175d65361SBrian Foster xfs_filblks_t resfactor; 4572a9bd24acSBrian Foster 4573a9bd24acSBrian Foster /* 4574d34999c9SBrian Foster * Steal as many blocks as we can to try and satisfy the worst case 4575d34999c9SBrian Foster * indlen for both new extents. 4576d34999c9SBrian Foster */ 457775d65361SBrian Foster if (ores < nres && avail) 457875d65361SBrian Foster stolen = XFS_FILBLKS_MIN(nres - ores, avail); 457975d65361SBrian Foster ores += stolen; 458075d65361SBrian Foster 458175d65361SBrian Foster /* nothing else to do if we've satisfied the new reservation */ 458275d65361SBrian Foster if (ores >= nres) 458375d65361SBrian Foster return stolen; 4584d34999c9SBrian Foster 4585d34999c9SBrian Foster /* 458675d65361SBrian Foster * We can't meet the total required reservation for the two extents. 458775d65361SBrian Foster * Calculate the percent of the overall shortage between both extents 458875d65361SBrian Foster * and apply this percentage to each of the requested indlen values. 458975d65361SBrian Foster * This distributes the shortage fairly and reduces the chances that one 459075d65361SBrian Foster * of the two extents is left with nothing when extents are repeatedly 459175d65361SBrian Foster * split. 4592a9bd24acSBrian Foster */ 459375d65361SBrian Foster resfactor = (ores * 100); 459475d65361SBrian Foster do_div(resfactor, nres); 459575d65361SBrian Foster len1 *= resfactor; 459675d65361SBrian Foster do_div(len1, 100); 459775d65361SBrian Foster len2 *= resfactor; 459875d65361SBrian Foster do_div(len2, 100); 459975d65361SBrian Foster ASSERT(len1 + len2 <= ores); 460075d65361SBrian Foster ASSERT(len1 < *indlen1 && len2 < *indlen2); 460175d65361SBrian Foster 460275d65361SBrian Foster /* 460375d65361SBrian Foster * Hand out the remainder to each extent. If one of the two reservations 460475d65361SBrian Foster * is zero, we want to make sure that one gets a block first. The loop 460575d65361SBrian Foster * below starts with len1, so hand len2 a block right off the bat if it 460675d65361SBrian Foster * is zero. 460775d65361SBrian Foster */ 460875d65361SBrian Foster ores -= (len1 + len2); 460975d65361SBrian Foster ASSERT((*indlen1 - len1) + (*indlen2 - len2) >= ores); 461075d65361SBrian Foster if (ores && !len2 && *indlen2) { 461175d65361SBrian Foster len2++; 461275d65361SBrian Foster ores--; 4613a9bd24acSBrian Foster } 461475d65361SBrian Foster while (ores) { 461575d65361SBrian Foster if (len1 < *indlen1) { 461675d65361SBrian Foster len1++; 461775d65361SBrian Foster ores--; 461875d65361SBrian Foster } 461975d65361SBrian Foster if (!ores) 4620a9bd24acSBrian Foster break; 462175d65361SBrian Foster if (len2 < *indlen2) { 462275d65361SBrian Foster len2++; 462375d65361SBrian Foster ores--; 4624a9bd24acSBrian Foster } 4625a9bd24acSBrian Foster } 4626a9bd24acSBrian Foster 4627a9bd24acSBrian Foster *indlen1 = len1; 4628a9bd24acSBrian Foster *indlen2 = len2; 4629d34999c9SBrian Foster 4630d34999c9SBrian Foster return stolen; 4631a9bd24acSBrian Foster } 4632a9bd24acSBrian Foster 4633fa5c836cSChristoph Hellwig int 4634fa5c836cSChristoph Hellwig xfs_bmap_del_extent_delay( 4635fa5c836cSChristoph Hellwig struct xfs_inode *ip, 4636fa5c836cSChristoph Hellwig int whichfork, 4637b2b1712aSChristoph Hellwig struct xfs_iext_cursor *icur, 4638fa5c836cSChristoph Hellwig struct xfs_bmbt_irec *got, 4639fa5c836cSChristoph Hellwig struct xfs_bmbt_irec *del) 4640fa5c836cSChristoph Hellwig { 4641fa5c836cSChristoph Hellwig struct xfs_mount *mp = ip->i_mount; 4642fa5c836cSChristoph Hellwig struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, whichfork); 4643fa5c836cSChristoph Hellwig struct xfs_bmbt_irec new; 4644fa5c836cSChristoph Hellwig int64_t da_old, da_new, da_diff = 0; 4645fa5c836cSChristoph Hellwig xfs_fileoff_t del_endoff, got_endoff; 4646fa5c836cSChristoph Hellwig xfs_filblks_t got_indlen, new_indlen, stolen; 4647060ea65bSChristoph Hellwig int state = xfs_bmap_fork_to_state(whichfork); 4648060ea65bSChristoph Hellwig int error = 0; 4649fa5c836cSChristoph Hellwig bool isrt; 4650fa5c836cSChristoph Hellwig 4651fa5c836cSChristoph Hellwig XFS_STATS_INC(mp, xs_del_exlist); 4652fa5c836cSChristoph Hellwig 4653fa5c836cSChristoph Hellwig isrt = (whichfork == XFS_DATA_FORK) && XFS_IS_REALTIME_INODE(ip); 4654fa5c836cSChristoph Hellwig del_endoff = del->br_startoff + del->br_blockcount; 4655fa5c836cSChristoph Hellwig got_endoff = got->br_startoff + got->br_blockcount; 4656fa5c836cSChristoph Hellwig da_old = startblockval(got->br_startblock); 4657fa5c836cSChristoph Hellwig da_new = 0; 4658fa5c836cSChristoph Hellwig 4659fa5c836cSChristoph Hellwig ASSERT(del->br_blockcount > 0); 4660fa5c836cSChristoph Hellwig ASSERT(got->br_startoff <= del->br_startoff); 4661fa5c836cSChristoph Hellwig ASSERT(got_endoff >= del_endoff); 4662fa5c836cSChristoph Hellwig 4663fa5c836cSChristoph Hellwig if (isrt) { 46644f1adf33SEric Sandeen uint64_t rtexts = XFS_FSB_TO_B(mp, del->br_blockcount); 4665fa5c836cSChristoph Hellwig 4666fa5c836cSChristoph Hellwig do_div(rtexts, mp->m_sb.sb_rextsize); 4667fa5c836cSChristoph Hellwig xfs_mod_frextents(mp, rtexts); 4668fa5c836cSChristoph Hellwig } 4669fa5c836cSChristoph Hellwig 4670fa5c836cSChristoph Hellwig /* 4671fa5c836cSChristoph Hellwig * Update the inode delalloc counter now and wait to update the 4672fa5c836cSChristoph Hellwig * sb counters as we might have to borrow some blocks for the 4673fa5c836cSChristoph Hellwig * indirect block accounting. 4674fa5c836cSChristoph Hellwig */ 46754fd29ec4SDarrick J. Wong error = xfs_trans_reserve_quota_nblks(NULL, ip, 46764fd29ec4SDarrick J. Wong -((long)del->br_blockcount), 0, 4677fa5c836cSChristoph Hellwig isrt ? XFS_QMOPT_RES_RTBLKS : XFS_QMOPT_RES_REGBLKS); 46784fd29ec4SDarrick J. Wong if (error) 46794fd29ec4SDarrick J. Wong return error; 4680fa5c836cSChristoph Hellwig ip->i_delayed_blks -= del->br_blockcount; 4681fa5c836cSChristoph Hellwig 4682fa5c836cSChristoph Hellwig if (got->br_startoff == del->br_startoff) 46830173c689SChristoph Hellwig state |= BMAP_LEFT_FILLING; 4684fa5c836cSChristoph Hellwig if (got_endoff == del_endoff) 46850173c689SChristoph Hellwig state |= BMAP_RIGHT_FILLING; 4686fa5c836cSChristoph Hellwig 46870173c689SChristoph Hellwig switch (state & (BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING)) { 46880173c689SChristoph Hellwig case BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING: 4689fa5c836cSChristoph Hellwig /* 4690fa5c836cSChristoph Hellwig * Matches the whole extent. Delete the entry. 4691fa5c836cSChristoph Hellwig */ 4692c38ccf59SChristoph Hellwig xfs_iext_remove(ip, icur, state); 4693b2b1712aSChristoph Hellwig xfs_iext_prev(ifp, icur); 4694fa5c836cSChristoph Hellwig break; 46950173c689SChristoph Hellwig case BMAP_LEFT_FILLING: 4696fa5c836cSChristoph Hellwig /* 4697fa5c836cSChristoph Hellwig * Deleting the first part of the extent. 4698fa5c836cSChristoph Hellwig */ 4699fa5c836cSChristoph Hellwig got->br_startoff = del_endoff; 4700fa5c836cSChristoph Hellwig got->br_blockcount -= del->br_blockcount; 4701fa5c836cSChristoph Hellwig da_new = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(ip, 4702fa5c836cSChristoph Hellwig got->br_blockcount), da_old); 4703fa5c836cSChristoph Hellwig got->br_startblock = nullstartblock((int)da_new); 4704b2b1712aSChristoph Hellwig xfs_iext_update_extent(ip, state, icur, got); 4705fa5c836cSChristoph Hellwig break; 47060173c689SChristoph Hellwig case BMAP_RIGHT_FILLING: 4707fa5c836cSChristoph Hellwig /* 4708fa5c836cSChristoph Hellwig * Deleting the last part of the extent. 4709fa5c836cSChristoph Hellwig */ 4710fa5c836cSChristoph Hellwig got->br_blockcount = got->br_blockcount - del->br_blockcount; 4711fa5c836cSChristoph Hellwig da_new = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(ip, 4712fa5c836cSChristoph Hellwig got->br_blockcount), da_old); 4713fa5c836cSChristoph Hellwig got->br_startblock = nullstartblock((int)da_new); 4714b2b1712aSChristoph Hellwig xfs_iext_update_extent(ip, state, icur, got); 4715fa5c836cSChristoph Hellwig break; 4716fa5c836cSChristoph Hellwig case 0: 4717fa5c836cSChristoph Hellwig /* 4718fa5c836cSChristoph Hellwig * Deleting the middle of the extent. 4719fa5c836cSChristoph Hellwig * 4720fa5c836cSChristoph Hellwig * Distribute the original indlen reservation across the two new 4721fa5c836cSChristoph Hellwig * extents. Steal blocks from the deleted extent if necessary. 4722fa5c836cSChristoph Hellwig * Stealing blocks simply fudges the fdblocks accounting below. 4723fa5c836cSChristoph Hellwig * Warn if either of the new indlen reservations is zero as this 4724fa5c836cSChristoph Hellwig * can lead to delalloc problems. 4725fa5c836cSChristoph Hellwig */ 4726fa5c836cSChristoph Hellwig got->br_blockcount = del->br_startoff - got->br_startoff; 4727fa5c836cSChristoph Hellwig got_indlen = xfs_bmap_worst_indlen(ip, got->br_blockcount); 4728fa5c836cSChristoph Hellwig 4729fa5c836cSChristoph Hellwig new.br_blockcount = got_endoff - del_endoff; 4730fa5c836cSChristoph Hellwig new_indlen = xfs_bmap_worst_indlen(ip, new.br_blockcount); 4731fa5c836cSChristoph Hellwig 4732fa5c836cSChristoph Hellwig WARN_ON_ONCE(!got_indlen || !new_indlen); 4733fa5c836cSChristoph Hellwig stolen = xfs_bmap_split_indlen(da_old, &got_indlen, &new_indlen, 4734fa5c836cSChristoph Hellwig del->br_blockcount); 4735fa5c836cSChristoph Hellwig 4736fa5c836cSChristoph Hellwig got->br_startblock = nullstartblock((int)got_indlen); 4737fa5c836cSChristoph Hellwig 4738fa5c836cSChristoph Hellwig new.br_startoff = del_endoff; 4739fa5c836cSChristoph Hellwig new.br_state = got->br_state; 4740fa5c836cSChristoph Hellwig new.br_startblock = nullstartblock((int)new_indlen); 4741fa5c836cSChristoph Hellwig 4742b2b1712aSChristoph Hellwig xfs_iext_update_extent(ip, state, icur, got); 4743b2b1712aSChristoph Hellwig xfs_iext_next(ifp, icur); 47440254c2f2SChristoph Hellwig xfs_iext_insert(ip, icur, &new, state); 4745fa5c836cSChristoph Hellwig 4746fa5c836cSChristoph Hellwig da_new = got_indlen + new_indlen - stolen; 4747fa5c836cSChristoph Hellwig del->br_blockcount -= stolen; 4748fa5c836cSChristoph Hellwig break; 4749fa5c836cSChristoph Hellwig } 4750fa5c836cSChristoph Hellwig 4751fa5c836cSChristoph Hellwig ASSERT(da_old >= da_new); 4752fa5c836cSChristoph Hellwig da_diff = da_old - da_new; 4753fa5c836cSChristoph Hellwig if (!isrt) 4754fa5c836cSChristoph Hellwig da_diff += del->br_blockcount; 4755fa5c836cSChristoph Hellwig if (da_diff) 4756fa5c836cSChristoph Hellwig xfs_mod_fdblocks(mp, da_diff, false); 4757fa5c836cSChristoph Hellwig return error; 4758fa5c836cSChristoph Hellwig } 4759fa5c836cSChristoph Hellwig 4760fa5c836cSChristoph Hellwig void 4761fa5c836cSChristoph Hellwig xfs_bmap_del_extent_cow( 4762fa5c836cSChristoph Hellwig struct xfs_inode *ip, 4763b2b1712aSChristoph Hellwig struct xfs_iext_cursor *icur, 4764fa5c836cSChristoph Hellwig struct xfs_bmbt_irec *got, 4765fa5c836cSChristoph Hellwig struct xfs_bmbt_irec *del) 4766fa5c836cSChristoph Hellwig { 4767fa5c836cSChristoph Hellwig struct xfs_mount *mp = ip->i_mount; 4768fa5c836cSChristoph Hellwig struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, XFS_COW_FORK); 4769fa5c836cSChristoph Hellwig struct xfs_bmbt_irec new; 4770fa5c836cSChristoph Hellwig xfs_fileoff_t del_endoff, got_endoff; 4771fa5c836cSChristoph Hellwig int state = BMAP_COWFORK; 4772fa5c836cSChristoph Hellwig 4773fa5c836cSChristoph Hellwig XFS_STATS_INC(mp, xs_del_exlist); 4774fa5c836cSChristoph Hellwig 4775fa5c836cSChristoph Hellwig del_endoff = del->br_startoff + del->br_blockcount; 4776fa5c836cSChristoph Hellwig got_endoff = got->br_startoff + got->br_blockcount; 4777fa5c836cSChristoph Hellwig 4778fa5c836cSChristoph Hellwig ASSERT(del->br_blockcount > 0); 4779fa5c836cSChristoph Hellwig ASSERT(got->br_startoff <= del->br_startoff); 4780fa5c836cSChristoph Hellwig ASSERT(got_endoff >= del_endoff); 4781fa5c836cSChristoph Hellwig ASSERT(!isnullstartblock(got->br_startblock)); 4782fa5c836cSChristoph Hellwig 4783fa5c836cSChristoph Hellwig if (got->br_startoff == del->br_startoff) 47840173c689SChristoph Hellwig state |= BMAP_LEFT_FILLING; 4785fa5c836cSChristoph Hellwig if (got_endoff == del_endoff) 47860173c689SChristoph Hellwig state |= BMAP_RIGHT_FILLING; 4787fa5c836cSChristoph Hellwig 47880173c689SChristoph Hellwig switch (state & (BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING)) { 47890173c689SChristoph Hellwig case BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING: 4790fa5c836cSChristoph Hellwig /* 4791fa5c836cSChristoph Hellwig * Matches the whole extent. Delete the entry. 4792fa5c836cSChristoph Hellwig */ 4793c38ccf59SChristoph Hellwig xfs_iext_remove(ip, icur, state); 4794b2b1712aSChristoph Hellwig xfs_iext_prev(ifp, icur); 4795fa5c836cSChristoph Hellwig break; 47960173c689SChristoph Hellwig case BMAP_LEFT_FILLING: 4797fa5c836cSChristoph Hellwig /* 4798fa5c836cSChristoph Hellwig * Deleting the first part of the extent. 4799fa5c836cSChristoph Hellwig */ 4800fa5c836cSChristoph Hellwig got->br_startoff = del_endoff; 4801fa5c836cSChristoph Hellwig got->br_blockcount -= del->br_blockcount; 4802fa5c836cSChristoph Hellwig got->br_startblock = del->br_startblock + del->br_blockcount; 4803b2b1712aSChristoph Hellwig xfs_iext_update_extent(ip, state, icur, got); 4804fa5c836cSChristoph Hellwig break; 48050173c689SChristoph Hellwig case BMAP_RIGHT_FILLING: 4806fa5c836cSChristoph Hellwig /* 4807fa5c836cSChristoph Hellwig * Deleting the last part of the extent. 4808fa5c836cSChristoph Hellwig */ 4809fa5c836cSChristoph Hellwig got->br_blockcount -= del->br_blockcount; 4810b2b1712aSChristoph Hellwig xfs_iext_update_extent(ip, state, icur, got); 4811fa5c836cSChristoph Hellwig break; 4812fa5c836cSChristoph Hellwig case 0: 4813fa5c836cSChristoph Hellwig /* 4814fa5c836cSChristoph Hellwig * Deleting the middle of the extent. 4815fa5c836cSChristoph Hellwig */ 4816fa5c836cSChristoph Hellwig got->br_blockcount = del->br_startoff - got->br_startoff; 4817fa5c836cSChristoph Hellwig 4818fa5c836cSChristoph Hellwig new.br_startoff = del_endoff; 4819fa5c836cSChristoph Hellwig new.br_blockcount = got_endoff - del_endoff; 4820fa5c836cSChristoph Hellwig new.br_state = got->br_state; 4821fa5c836cSChristoph Hellwig new.br_startblock = del->br_startblock + del->br_blockcount; 4822fa5c836cSChristoph Hellwig 4823b2b1712aSChristoph Hellwig xfs_iext_update_extent(ip, state, icur, got); 4824b2b1712aSChristoph Hellwig xfs_iext_next(ifp, icur); 48250254c2f2SChristoph Hellwig xfs_iext_insert(ip, icur, &new, state); 4826fa5c836cSChristoph Hellwig break; 4827fa5c836cSChristoph Hellwig } 48284b4c1326SDarrick J. Wong ip->i_delayed_blks -= del->br_blockcount; 4829fa5c836cSChristoph Hellwig } 4830fa5c836cSChristoph Hellwig 4831a9bd24acSBrian Foster /* 483230f712c9SDave Chinner * Called by xfs_bmapi to update file extent records and the btree 4833e1d7553fSChristoph Hellwig * after removing space. 483430f712c9SDave Chinner */ 483530f712c9SDave Chinner STATIC int /* error */ 4836e1d7553fSChristoph Hellwig xfs_bmap_del_extent_real( 483730f712c9SDave Chinner xfs_inode_t *ip, /* incore inode pointer */ 483830f712c9SDave Chinner xfs_trans_t *tp, /* current transaction pointer */ 4839b2b1712aSChristoph Hellwig struct xfs_iext_cursor *icur, 484030f712c9SDave Chinner xfs_btree_cur_t *cur, /* if null, not a btree */ 484130f712c9SDave Chinner xfs_bmbt_irec_t *del, /* data to remove from extents */ 484230f712c9SDave Chinner int *logflagsp, /* inode logging flags */ 48434847acf8SDarrick J. Wong int whichfork, /* data or attr fork */ 48444847acf8SDarrick J. Wong int bflags) /* bmapi flags */ 484530f712c9SDave Chinner { 484630f712c9SDave Chinner xfs_fsblock_t del_endblock=0; /* first block past del */ 484730f712c9SDave Chinner xfs_fileoff_t del_endoff; /* first offset past del */ 484830f712c9SDave Chinner int do_fx; /* free extent at end of routine */ 484930f712c9SDave Chinner int error; /* error return value */ 48501b24b633SChristoph Hellwig int flags = 0;/* inode logging flags */ 485148fd52b1SChristoph Hellwig struct xfs_bmbt_irec got; /* current extent entry */ 485230f712c9SDave Chinner xfs_fileoff_t got_endoff; /* first offset past got */ 485330f712c9SDave Chinner int i; /* temp state */ 485430f712c9SDave Chinner xfs_ifork_t *ifp; /* inode fork pointer */ 485530f712c9SDave Chinner xfs_mount_t *mp; /* mount structure */ 485630f712c9SDave Chinner xfs_filblks_t nblks; /* quota/sb block count */ 485730f712c9SDave Chinner xfs_bmbt_irec_t new; /* new record to be inserted */ 485830f712c9SDave Chinner /* REFERENCED */ 485930f712c9SDave Chinner uint qfield; /* quota field to update */ 4860060ea65bSChristoph Hellwig int state = xfs_bmap_fork_to_state(whichfork); 486148fd52b1SChristoph Hellwig struct xfs_bmbt_irec old; 486281ba8f3eSBrian Foster struct xfs_defer_ops *dfops = tp ? tp->t_dfops : NULL; 486330f712c9SDave Chinner 4864ff6d6af2SBill O'Donnell mp = ip->i_mount; 4865ff6d6af2SBill O'Donnell XFS_STATS_INC(mp, xs_del_exlist); 486630f712c9SDave Chinner 486730f712c9SDave Chinner ifp = XFS_IFORK_PTR(ip, whichfork); 486830f712c9SDave Chinner ASSERT(del->br_blockcount > 0); 4869b2b1712aSChristoph Hellwig xfs_iext_get_extent(ifp, icur, &got); 487030f712c9SDave Chinner ASSERT(got.br_startoff <= del->br_startoff); 487130f712c9SDave Chinner del_endoff = del->br_startoff + del->br_blockcount; 487230f712c9SDave Chinner got_endoff = got.br_startoff + got.br_blockcount; 487330f712c9SDave Chinner ASSERT(got_endoff >= del_endoff); 4874e1d7553fSChristoph Hellwig ASSERT(!isnullstartblock(got.br_startblock)); 487530f712c9SDave Chinner qfield = 0; 487630f712c9SDave Chinner error = 0; 4877e1d7553fSChristoph Hellwig 48781b24b633SChristoph Hellwig /* 48791b24b633SChristoph Hellwig * If it's the case where the directory code is running with no block 48801b24b633SChristoph Hellwig * reservation, and the deleted block is in the middle of its extent, 48811b24b633SChristoph Hellwig * and the resulting insert of an extent would cause transformation to 48821b24b633SChristoph Hellwig * btree format, then reject it. The calling code will then swap blocks 48831b24b633SChristoph Hellwig * around instead. We have to do this now, rather than waiting for the 48841b24b633SChristoph Hellwig * conversion to btree format, since the transaction will be dirty then. 48851b24b633SChristoph Hellwig */ 48861b24b633SChristoph Hellwig if (tp->t_blk_res == 0 && 48871b24b633SChristoph Hellwig XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_EXTENTS && 48881b24b633SChristoph Hellwig XFS_IFORK_NEXTENTS(ip, whichfork) >= 48891b24b633SChristoph Hellwig XFS_IFORK_MAXEXT(ip, whichfork) && 48901b24b633SChristoph Hellwig del->br_startoff > got.br_startoff && del_endoff < got_endoff) 48911b24b633SChristoph Hellwig return -ENOSPC; 48921b24b633SChristoph Hellwig 48931b24b633SChristoph Hellwig flags = XFS_ILOG_CORE; 489430f712c9SDave Chinner if (whichfork == XFS_DATA_FORK && XFS_IS_REALTIME_INODE(ip)) { 489530f712c9SDave Chinner xfs_fsblock_t bno; 489630f712c9SDave Chinner xfs_filblks_t len; 48970703a8e1SDave Chinner xfs_extlen_t mod; 489830f712c9SDave Chinner 48990703a8e1SDave Chinner bno = div_u64_rem(del->br_startblock, mp->m_sb.sb_rextsize, 49000703a8e1SDave Chinner &mod); 49010703a8e1SDave Chinner ASSERT(mod == 0); 49020703a8e1SDave Chinner len = div_u64_rem(del->br_blockcount, mp->m_sb.sb_rextsize, 49030703a8e1SDave Chinner &mod); 49040703a8e1SDave Chinner ASSERT(mod == 0); 49050703a8e1SDave Chinner 490630f712c9SDave Chinner error = xfs_rtfree_extent(tp, bno, (xfs_extlen_t)len); 490730f712c9SDave Chinner if (error) 490830f712c9SDave Chinner goto done; 490930f712c9SDave Chinner do_fx = 0; 491030f712c9SDave Chinner nblks = len * mp->m_sb.sb_rextsize; 491130f712c9SDave Chinner qfield = XFS_TRANS_DQ_RTBCOUNT; 4912e1d7553fSChristoph Hellwig } else { 491330f712c9SDave Chinner do_fx = 1; 491430f712c9SDave Chinner nblks = del->br_blockcount; 491530f712c9SDave Chinner qfield = XFS_TRANS_DQ_BCOUNT; 491630f712c9SDave Chinner } 4917e1d7553fSChristoph Hellwig 491830f712c9SDave Chinner del_endblock = del->br_startblock + del->br_blockcount; 491930f712c9SDave Chinner if (cur) { 4920e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(cur, &got, &i); 4921e1d7553fSChristoph Hellwig if (error) 492230f712c9SDave Chinner goto done; 4923c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 492430f712c9SDave Chinner } 4925340785ccSDarrick J. Wong 4926491f6f8aSChristoph Hellwig if (got.br_startoff == del->br_startoff) 4927491f6f8aSChristoph Hellwig state |= BMAP_LEFT_FILLING; 4928491f6f8aSChristoph Hellwig if (got_endoff == del_endoff) 4929491f6f8aSChristoph Hellwig state |= BMAP_RIGHT_FILLING; 4930491f6f8aSChristoph Hellwig 4931491f6f8aSChristoph Hellwig switch (state & (BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING)) { 4932491f6f8aSChristoph Hellwig case BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING: 493330f712c9SDave Chinner /* 493430f712c9SDave Chinner * Matches the whole extent. Delete the entry. 493530f712c9SDave Chinner */ 4936c38ccf59SChristoph Hellwig xfs_iext_remove(ip, icur, state); 4937b2b1712aSChristoph Hellwig xfs_iext_prev(ifp, icur); 493830f712c9SDave Chinner XFS_IFORK_NEXT_SET(ip, whichfork, 493930f712c9SDave Chinner XFS_IFORK_NEXTENTS(ip, whichfork) - 1); 494030f712c9SDave Chinner flags |= XFS_ILOG_CORE; 494130f712c9SDave Chinner if (!cur) { 494230f712c9SDave Chinner flags |= xfs_ilog_fext(whichfork); 494330f712c9SDave Chinner break; 494430f712c9SDave Chinner } 494530f712c9SDave Chinner if ((error = xfs_btree_delete(cur, &i))) 494630f712c9SDave Chinner goto done; 4947c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 494830f712c9SDave Chinner break; 4949491f6f8aSChristoph Hellwig case BMAP_LEFT_FILLING: 495030f712c9SDave Chinner /* 495130f712c9SDave Chinner * Deleting the first part of the extent. 495230f712c9SDave Chinner */ 495348fd52b1SChristoph Hellwig got.br_startoff = del_endoff; 495448fd52b1SChristoph Hellwig got.br_startblock = del_endblock; 495548fd52b1SChristoph Hellwig got.br_blockcount -= del->br_blockcount; 4956b2b1712aSChristoph Hellwig xfs_iext_update_extent(ip, state, icur, &got); 495730f712c9SDave Chinner if (!cur) { 495830f712c9SDave Chinner flags |= xfs_ilog_fext(whichfork); 495930f712c9SDave Chinner break; 496030f712c9SDave Chinner } 4961a67d00a5SChristoph Hellwig error = xfs_bmbt_update(cur, &got); 496248fd52b1SChristoph Hellwig if (error) 496330f712c9SDave Chinner goto done; 496430f712c9SDave Chinner break; 4965491f6f8aSChristoph Hellwig case BMAP_RIGHT_FILLING: 496630f712c9SDave Chinner /* 496730f712c9SDave Chinner * Deleting the last part of the extent. 496830f712c9SDave Chinner */ 496948fd52b1SChristoph Hellwig got.br_blockcount -= del->br_blockcount; 4970b2b1712aSChristoph Hellwig xfs_iext_update_extent(ip, state, icur, &got); 497130f712c9SDave Chinner if (!cur) { 497230f712c9SDave Chinner flags |= xfs_ilog_fext(whichfork); 497330f712c9SDave Chinner break; 497430f712c9SDave Chinner } 4975a67d00a5SChristoph Hellwig error = xfs_bmbt_update(cur, &got); 497648fd52b1SChristoph Hellwig if (error) 497730f712c9SDave Chinner goto done; 497830f712c9SDave Chinner break; 497930f712c9SDave Chinner case 0: 498030f712c9SDave Chinner /* 498130f712c9SDave Chinner * Deleting the middle of the extent. 498230f712c9SDave Chinner */ 498348fd52b1SChristoph Hellwig old = got; 4984ca5d8e5bSChristoph Hellwig 498548fd52b1SChristoph Hellwig got.br_blockcount = del->br_startoff - got.br_startoff; 4986b2b1712aSChristoph Hellwig xfs_iext_update_extent(ip, state, icur, &got); 498748fd52b1SChristoph Hellwig 498830f712c9SDave Chinner new.br_startoff = del_endoff; 498948fd52b1SChristoph Hellwig new.br_blockcount = got_endoff - del_endoff; 499030f712c9SDave Chinner new.br_state = got.br_state; 499130f712c9SDave Chinner new.br_startblock = del_endblock; 499248fd52b1SChristoph Hellwig 499330f712c9SDave Chinner flags |= XFS_ILOG_CORE; 499430f712c9SDave Chinner if (cur) { 4995a67d00a5SChristoph Hellwig error = xfs_bmbt_update(cur, &got); 4996e1d7553fSChristoph Hellwig if (error) 499730f712c9SDave Chinner goto done; 4998e1d7553fSChristoph Hellwig error = xfs_btree_increment(cur, 0, &i); 4999e1d7553fSChristoph Hellwig if (error) 500030f712c9SDave Chinner goto done; 500130f712c9SDave Chinner cur->bc_rec.b = new; 500230f712c9SDave Chinner error = xfs_btree_insert(cur, &i); 50032451337dSDave Chinner if (error && error != -ENOSPC) 500430f712c9SDave Chinner goto done; 500530f712c9SDave Chinner /* 5006e1d7553fSChristoph Hellwig * If get no-space back from btree insert, it tried a 5007e1d7553fSChristoph Hellwig * split, and we have a zero block reservation. Fix up 5008e1d7553fSChristoph Hellwig * our state and return the error. 500930f712c9SDave Chinner */ 50102451337dSDave Chinner if (error == -ENOSPC) { 501130f712c9SDave Chinner /* 5012e1d7553fSChristoph Hellwig * Reset the cursor, don't trust it after any 5013e1d7553fSChristoph Hellwig * insert operation. 501430f712c9SDave Chinner */ 5015e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(cur, &got, &i); 5016e1d7553fSChristoph Hellwig if (error) 501730f712c9SDave Chinner goto done; 5018e1d7553fSChristoph Hellwig XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 501930f712c9SDave Chinner /* 502030f712c9SDave Chinner * Update the btree record back 502130f712c9SDave Chinner * to the original value. 502230f712c9SDave Chinner */ 5023a67d00a5SChristoph Hellwig error = xfs_bmbt_update(cur, &old); 5024e1d7553fSChristoph Hellwig if (error) 502530f712c9SDave Chinner goto done; 502630f712c9SDave Chinner /* 502730f712c9SDave Chinner * Reset the extent record back 502830f712c9SDave Chinner * to the original value. 502930f712c9SDave Chinner */ 5030b2b1712aSChristoph Hellwig xfs_iext_update_extent(ip, state, icur, &old); 503130f712c9SDave Chinner flags = 0; 50322451337dSDave Chinner error = -ENOSPC; 503330f712c9SDave Chinner goto done; 503430f712c9SDave Chinner } 5035c29aad41SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done); 503630f712c9SDave Chinner } else 503730f712c9SDave Chinner flags |= xfs_ilog_fext(whichfork); 503830f712c9SDave Chinner XFS_IFORK_NEXT_SET(ip, whichfork, 503930f712c9SDave Chinner XFS_IFORK_NEXTENTS(ip, whichfork) + 1); 5040b2b1712aSChristoph Hellwig xfs_iext_next(ifp, icur); 50410254c2f2SChristoph Hellwig xfs_iext_insert(ip, icur, &new, state); 504230f712c9SDave Chinner break; 504330f712c9SDave Chinner } 50449c194644SDarrick J. Wong 50459c194644SDarrick J. Wong /* remove reverse mapping */ 50469c194644SDarrick J. Wong error = xfs_rmap_unmap_extent(mp, dfops, ip, whichfork, del); 50479c194644SDarrick J. Wong if (error) 50489c194644SDarrick J. Wong goto done; 50499c194644SDarrick J. Wong 505030f712c9SDave Chinner /* 505130f712c9SDave Chinner * If we need to, add to list of extents to delete. 505230f712c9SDave Chinner */ 50534847acf8SDarrick J. Wong if (do_fx && !(bflags & XFS_BMAPI_REMAP)) { 505462aab20fSDarrick J. Wong if (xfs_is_reflink_inode(ip) && whichfork == XFS_DATA_FORK) { 505562aab20fSDarrick J. Wong error = xfs_refcount_decrease_extent(mp, dfops, del); 505662aab20fSDarrick J. Wong if (error) 505762aab20fSDarrick J. Wong goto done; 5058fcb762f5SBrian Foster } else { 50594e529339SBrian Foster __xfs_bmap_add_free(mp, dfops, del->br_startblock, 50604e529339SBrian Foster del->br_blockcount, NULL, 50614e529339SBrian Foster (bflags & XFS_BMAPI_NODISCARD) || 50624e529339SBrian Foster del->br_state == XFS_EXT_UNWRITTEN); 5063fcb762f5SBrian Foster } 5064fcb762f5SBrian Foster } 506562aab20fSDarrick J. Wong 506630f712c9SDave Chinner /* 506730f712c9SDave Chinner * Adjust inode # blocks in the file. 506830f712c9SDave Chinner */ 506930f712c9SDave Chinner if (nblks) 507030f712c9SDave Chinner ip->i_d.di_nblocks -= nblks; 507130f712c9SDave Chinner /* 507230f712c9SDave Chinner * Adjust quota data. 507330f712c9SDave Chinner */ 50744847acf8SDarrick J. Wong if (qfield && !(bflags & XFS_BMAPI_REMAP)) 507530f712c9SDave Chinner xfs_trans_mod_dquot_byino(tp, ip, qfield, (long)-nblks); 507630f712c9SDave Chinner 507730f712c9SDave Chinner done: 507830f712c9SDave Chinner *logflagsp = flags; 507930f712c9SDave Chinner return error; 508030f712c9SDave Chinner } 508130f712c9SDave Chinner 508230f712c9SDave Chinner /* 508330f712c9SDave Chinner * Unmap (remove) blocks from a file. 508430f712c9SDave Chinner * If nexts is nonzero then the number of extents to remove is limited to 508530f712c9SDave Chinner * that value. If not all extents in the block range can be removed then 508630f712c9SDave Chinner * *done is set. 508730f712c9SDave Chinner */ 508830f712c9SDave Chinner int /* error */ 50894453593bSDarrick J. Wong __xfs_bunmapi( 5090ccd9d911SBrian Foster struct xfs_trans *tp, /* transaction pointer */ 509130f712c9SDave Chinner struct xfs_inode *ip, /* incore inode */ 50928280f6edSChristoph Hellwig xfs_fileoff_t start, /* first file offset deleted */ 50934453593bSDarrick J. Wong xfs_filblks_t *rlen, /* i/o: amount remaining */ 509430f712c9SDave Chinner int flags, /* misc flags */ 50952af52842SBrian Foster xfs_extnum_t nexts) /* number of extents max */ 509630f712c9SDave Chinner { 5097ccd9d911SBrian Foster struct xfs_btree_cur *cur; /* bmap btree cursor */ 5098ccd9d911SBrian Foster struct xfs_bmbt_irec del; /* extent being deleted */ 509930f712c9SDave Chinner int error; /* error return value */ 510030f712c9SDave Chinner xfs_extnum_t extno; /* extent number in list */ 5101ccd9d911SBrian Foster struct xfs_bmbt_irec got; /* current extent record */ 510230f712c9SDave Chinner xfs_ifork_t *ifp; /* inode fork pointer */ 510330f712c9SDave Chinner int isrt; /* freeing in rt area */ 510430f712c9SDave Chinner int logflags; /* transaction logging flags */ 510530f712c9SDave Chinner xfs_extlen_t mod; /* rt extent offset */ 5106ccd9d911SBrian Foster struct xfs_mount *mp; /* mount structure */ 510730f712c9SDave Chinner int tmp_logflags; /* partial logging flags */ 510830f712c9SDave Chinner int wasdel; /* was a delayed alloc extent */ 510930f712c9SDave Chinner int whichfork; /* data or attribute fork */ 511030f712c9SDave Chinner xfs_fsblock_t sum; 51114453593bSDarrick J. Wong xfs_filblks_t len = *rlen; /* length to unmap in file */ 5112e1a4e37cSDarrick J. Wong xfs_fileoff_t max_len; 51135b094d6dSChristoph Hellwig xfs_agnumber_t prev_agno = NULLAGNUMBER, agno; 51148280f6edSChristoph Hellwig xfs_fileoff_t end; 5115b2b1712aSChristoph Hellwig struct xfs_iext_cursor icur; 5116b2b1712aSChristoph Hellwig bool done = false; 511730f712c9SDave Chinner 51188280f6edSChristoph Hellwig trace_xfs_bunmap(ip, start, len, flags, _RET_IP_); 511930f712c9SDave Chinner 51203993baebSDarrick J. Wong whichfork = xfs_bmapi_whichfork(flags); 51213993baebSDarrick J. Wong ASSERT(whichfork != XFS_COW_FORK); 512230f712c9SDave Chinner ifp = XFS_IFORK_PTR(ip, whichfork); 512330f712c9SDave Chinner if (unlikely( 512430f712c9SDave Chinner XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS && 512530f712c9SDave Chinner XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE)) { 512630f712c9SDave Chinner XFS_ERROR_REPORT("xfs_bunmapi", XFS_ERRLEVEL_LOW, 512730f712c9SDave Chinner ip->i_mount); 51282451337dSDave Chinner return -EFSCORRUPTED; 512930f712c9SDave Chinner } 513030f712c9SDave Chinner mp = ip->i_mount; 513130f712c9SDave Chinner if (XFS_FORCED_SHUTDOWN(mp)) 51322451337dSDave Chinner return -EIO; 513330f712c9SDave Chinner 513430f712c9SDave Chinner ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL)); 513530f712c9SDave Chinner ASSERT(len > 0); 513630f712c9SDave Chinner ASSERT(nexts >= 0); 513730f712c9SDave Chinner 5138e1a4e37cSDarrick J. Wong /* 5139e1a4e37cSDarrick J. Wong * Guesstimate how many blocks we can unmap without running the risk of 5140e1a4e37cSDarrick J. Wong * blowing out the transaction with a mix of EFIs and reflink 5141e1a4e37cSDarrick J. Wong * adjustments. 5142e1a4e37cSDarrick J. Wong */ 51438c57b886SDarrick J. Wong if (tp && xfs_is_reflink_inode(ip) && whichfork == XFS_DATA_FORK) 5144e1a4e37cSDarrick J. Wong max_len = min(len, xfs_refcount_max_unmap(tp->t_log_res)); 5145e1a4e37cSDarrick J. Wong else 5146e1a4e37cSDarrick J. Wong max_len = len; 5147e1a4e37cSDarrick J. Wong 514830f712c9SDave Chinner if (!(ifp->if_flags & XFS_IFEXTENTS) && 514930f712c9SDave Chinner (error = xfs_iread_extents(tp, ip, whichfork))) 515030f712c9SDave Chinner return error; 51515d829300SEric Sandeen if (xfs_iext_count(ifp) == 0) { 51524453593bSDarrick J. Wong *rlen = 0; 515330f712c9SDave Chinner return 0; 515430f712c9SDave Chinner } 5155ff6d6af2SBill O'Donnell XFS_STATS_INC(mp, xs_blk_unmap); 515630f712c9SDave Chinner isrt = (whichfork == XFS_DATA_FORK) && XFS_IS_REALTIME_INODE(ip); 5157dc56015fSChristoph Hellwig end = start + len; 515830f712c9SDave Chinner 5159b2b1712aSChristoph Hellwig if (!xfs_iext_lookup_extent_before(ip, ifp, &end, &icur, &got)) { 5160dc56015fSChristoph Hellwig *rlen = 0; 5161dc56015fSChristoph Hellwig return 0; 516230f712c9SDave Chinner } 5163dc56015fSChristoph Hellwig end--; 51647efc7945SChristoph Hellwig 516530f712c9SDave Chinner logflags = 0; 516630f712c9SDave Chinner if (ifp->if_flags & XFS_IFBROOT) { 516730f712c9SDave Chinner ASSERT(XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_BTREE); 516830f712c9SDave Chinner cur = xfs_bmbt_init_cursor(mp, tp, ip, whichfork); 516930f712c9SDave Chinner cur->bc_private.b.flags = 0; 517030f712c9SDave Chinner } else 517130f712c9SDave Chinner cur = NULL; 517230f712c9SDave Chinner 517330f712c9SDave Chinner if (isrt) { 517430f712c9SDave Chinner /* 517530f712c9SDave Chinner * Synchronize by locking the bitmap inode. 517630f712c9SDave Chinner */ 5177f4a0660dSDarrick J. Wong xfs_ilock(mp->m_rbmip, XFS_ILOCK_EXCL|XFS_ILOCK_RTBITMAP); 517830f712c9SDave Chinner xfs_trans_ijoin(tp, mp->m_rbmip, XFS_ILOCK_EXCL); 5179f4a0660dSDarrick J. Wong xfs_ilock(mp->m_rsumip, XFS_ILOCK_EXCL|XFS_ILOCK_RTSUM); 5180f4a0660dSDarrick J. Wong xfs_trans_ijoin(tp, mp->m_rsumip, XFS_ILOCK_EXCL); 518130f712c9SDave Chinner } 518230f712c9SDave Chinner 518330f712c9SDave Chinner extno = 0; 5184b2b1712aSChristoph Hellwig while (end != (xfs_fileoff_t)-1 && end >= start && 5185e1a4e37cSDarrick J. Wong (nexts == 0 || extno < nexts) && max_len > 0) { 518630f712c9SDave Chinner /* 51878280f6edSChristoph Hellwig * Is the found extent after a hole in which end lives? 518830f712c9SDave Chinner * Just back up to the previous extent, if so. 518930f712c9SDave Chinner */ 5190b2b1712aSChristoph Hellwig if (got.br_startoff > end && 5191b2b1712aSChristoph Hellwig !xfs_iext_prev_extent(ifp, &icur, &got)) { 5192b2b1712aSChristoph Hellwig done = true; 519330f712c9SDave Chinner break; 519430f712c9SDave Chinner } 519530f712c9SDave Chinner /* 519630f712c9SDave Chinner * Is the last block of this extent before the range 519730f712c9SDave Chinner * we're supposed to delete? If so, we're done. 519830f712c9SDave Chinner */ 51998280f6edSChristoph Hellwig end = XFS_FILEOFF_MIN(end, 520030f712c9SDave Chinner got.br_startoff + got.br_blockcount - 1); 52018280f6edSChristoph Hellwig if (end < start) 520230f712c9SDave Chinner break; 520330f712c9SDave Chinner /* 520430f712c9SDave Chinner * Then deal with the (possibly delayed) allocated space 520530f712c9SDave Chinner * we found. 520630f712c9SDave Chinner */ 520730f712c9SDave Chinner del = got; 520830f712c9SDave Chinner wasdel = isnullstartblock(del.br_startblock); 52095b094d6dSChristoph Hellwig 52105b094d6dSChristoph Hellwig /* 52115b094d6dSChristoph Hellwig * Make sure we don't touch multiple AGF headers out of order 52125b094d6dSChristoph Hellwig * in a single transaction, as that could cause AB-BA deadlocks. 52135b094d6dSChristoph Hellwig */ 52145b094d6dSChristoph Hellwig if (!wasdel) { 52155b094d6dSChristoph Hellwig agno = XFS_FSB_TO_AGNO(mp, del.br_startblock); 52165b094d6dSChristoph Hellwig if (prev_agno != NULLAGNUMBER && prev_agno > agno) 52175b094d6dSChristoph Hellwig break; 52185b094d6dSChristoph Hellwig prev_agno = agno; 52195b094d6dSChristoph Hellwig } 522030f712c9SDave Chinner if (got.br_startoff < start) { 522130f712c9SDave Chinner del.br_startoff = start; 522230f712c9SDave Chinner del.br_blockcount -= start - got.br_startoff; 522330f712c9SDave Chinner if (!wasdel) 522430f712c9SDave Chinner del.br_startblock += start - got.br_startoff; 522530f712c9SDave Chinner } 52268280f6edSChristoph Hellwig if (del.br_startoff + del.br_blockcount > end + 1) 52278280f6edSChristoph Hellwig del.br_blockcount = end + 1 - del.br_startoff; 5228e1a4e37cSDarrick J. Wong 5229e1a4e37cSDarrick J. Wong /* How much can we safely unmap? */ 5230e1a4e37cSDarrick J. Wong if (max_len < del.br_blockcount) { 5231e1a4e37cSDarrick J. Wong del.br_startoff += del.br_blockcount - max_len; 5232e1a4e37cSDarrick J. Wong if (!wasdel) 5233e1a4e37cSDarrick J. Wong del.br_startblock += del.br_blockcount - max_len; 5234e1a4e37cSDarrick J. Wong del.br_blockcount = max_len; 5235e1a4e37cSDarrick J. Wong } 5236e1a4e37cSDarrick J. Wong 52370703a8e1SDave Chinner if (!isrt) 52380703a8e1SDave Chinner goto delete; 52390703a8e1SDave Chinner 524030f712c9SDave Chinner sum = del.br_startblock + del.br_blockcount; 52410703a8e1SDave Chinner div_u64_rem(sum, mp->m_sb.sb_rextsize, &mod); 52420703a8e1SDave Chinner if (mod) { 524330f712c9SDave Chinner /* 524430f712c9SDave Chinner * Realtime extent not lined up at the end. 524530f712c9SDave Chinner * The extent could have been split into written 524630f712c9SDave Chinner * and unwritten pieces, or we could just be 524730f712c9SDave Chinner * unmapping part of it. But we can't really 524830f712c9SDave Chinner * get rid of part of a realtime extent. 524930f712c9SDave Chinner */ 525030f712c9SDave Chinner if (del.br_state == XFS_EXT_UNWRITTEN || 525130f712c9SDave Chinner !xfs_sb_version_hasextflgbit(&mp->m_sb)) { 525230f712c9SDave Chinner /* 525330f712c9SDave Chinner * This piece is unwritten, or we're not 525430f712c9SDave Chinner * using unwritten extents. Skip over it. 525530f712c9SDave Chinner */ 52568280f6edSChristoph Hellwig ASSERT(end >= mod); 52578280f6edSChristoph Hellwig end -= mod > del.br_blockcount ? 525830f712c9SDave Chinner del.br_blockcount : mod; 5259b2b1712aSChristoph Hellwig if (end < got.br_startoff && 5260b2b1712aSChristoph Hellwig !xfs_iext_prev_extent(ifp, &icur, &got)) { 5261b2b1712aSChristoph Hellwig done = true; 5262b2b1712aSChristoph Hellwig break; 526330f712c9SDave Chinner } 526430f712c9SDave Chinner continue; 526530f712c9SDave Chinner } 526630f712c9SDave Chinner /* 526730f712c9SDave Chinner * It's written, turn it unwritten. 526830f712c9SDave Chinner * This is better than zeroing it. 526930f712c9SDave Chinner */ 527030f712c9SDave Chinner ASSERT(del.br_state == XFS_EXT_NORM); 5271a7e5d03bSChristoph Hellwig ASSERT(tp->t_blk_res > 0); 527230f712c9SDave Chinner /* 527330f712c9SDave Chinner * If this spans a realtime extent boundary, 527430f712c9SDave Chinner * chop it back to the start of the one we end at. 527530f712c9SDave Chinner */ 527630f712c9SDave Chinner if (del.br_blockcount > mod) { 527730f712c9SDave Chinner del.br_startoff += del.br_blockcount - mod; 527830f712c9SDave Chinner del.br_startblock += del.br_blockcount - mod; 527930f712c9SDave Chinner del.br_blockcount = mod; 528030f712c9SDave Chinner } 528130f712c9SDave Chinner del.br_state = XFS_EXT_UNWRITTEN; 528230f712c9SDave Chinner error = xfs_bmap_add_extent_unwritten_real(tp, ip, 5283b2b1712aSChristoph Hellwig whichfork, &icur, &cur, &del, 528492f9da30SBrian Foster &logflags); 528530f712c9SDave Chinner if (error) 528630f712c9SDave Chinner goto error0; 528730f712c9SDave Chinner goto nodelete; 528830f712c9SDave Chinner } 52890703a8e1SDave Chinner div_u64_rem(del.br_startblock, mp->m_sb.sb_rextsize, &mod); 52900703a8e1SDave Chinner if (mod) { 529130f712c9SDave Chinner /* 529230f712c9SDave Chinner * Realtime extent is lined up at the end but not 529330f712c9SDave Chinner * at the front. We'll get rid of full extents if 529430f712c9SDave Chinner * we can. 529530f712c9SDave Chinner */ 529630f712c9SDave Chinner mod = mp->m_sb.sb_rextsize - mod; 529730f712c9SDave Chinner if (del.br_blockcount > mod) { 529830f712c9SDave Chinner del.br_blockcount -= mod; 529930f712c9SDave Chinner del.br_startoff += mod; 530030f712c9SDave Chinner del.br_startblock += mod; 530130f712c9SDave Chinner } else if ((del.br_startoff == start && 530230f712c9SDave Chinner (del.br_state == XFS_EXT_UNWRITTEN || 5303a7e5d03bSChristoph Hellwig tp->t_blk_res == 0)) || 530430f712c9SDave Chinner !xfs_sb_version_hasextflgbit(&mp->m_sb)) { 530530f712c9SDave Chinner /* 530630f712c9SDave Chinner * Can't make it unwritten. There isn't 530730f712c9SDave Chinner * a full extent here so just skip it. 530830f712c9SDave Chinner */ 53098280f6edSChristoph Hellwig ASSERT(end >= del.br_blockcount); 53108280f6edSChristoph Hellwig end -= del.br_blockcount; 5311b2b1712aSChristoph Hellwig if (got.br_startoff > end && 5312b2b1712aSChristoph Hellwig !xfs_iext_prev_extent(ifp, &icur, &got)) { 5313b2b1712aSChristoph Hellwig done = true; 5314b2b1712aSChristoph Hellwig break; 5315b2b1712aSChristoph Hellwig } 531630f712c9SDave Chinner continue; 531730f712c9SDave Chinner } else if (del.br_state == XFS_EXT_UNWRITTEN) { 53187efc7945SChristoph Hellwig struct xfs_bmbt_irec prev; 53197efc7945SChristoph Hellwig 532030f712c9SDave Chinner /* 532130f712c9SDave Chinner * This one is already unwritten. 532230f712c9SDave Chinner * It must have a written left neighbor. 532330f712c9SDave Chinner * Unwrite the killed part of that one and 532430f712c9SDave Chinner * try again. 532530f712c9SDave Chinner */ 5326b2b1712aSChristoph Hellwig if (!xfs_iext_prev_extent(ifp, &icur, &prev)) 5327b2b1712aSChristoph Hellwig ASSERT(0); 532830f712c9SDave Chinner ASSERT(prev.br_state == XFS_EXT_NORM); 532930f712c9SDave Chinner ASSERT(!isnullstartblock(prev.br_startblock)); 533030f712c9SDave Chinner ASSERT(del.br_startblock == 533130f712c9SDave Chinner prev.br_startblock + prev.br_blockcount); 533230f712c9SDave Chinner if (prev.br_startoff < start) { 533330f712c9SDave Chinner mod = start - prev.br_startoff; 533430f712c9SDave Chinner prev.br_blockcount -= mod; 533530f712c9SDave Chinner prev.br_startblock += mod; 533630f712c9SDave Chinner prev.br_startoff = start; 533730f712c9SDave Chinner } 533830f712c9SDave Chinner prev.br_state = XFS_EXT_UNWRITTEN; 533930f712c9SDave Chinner error = xfs_bmap_add_extent_unwritten_real(tp, 5340b2b1712aSChristoph Hellwig ip, whichfork, &icur, &cur, 534192f9da30SBrian Foster &prev, &logflags); 534230f712c9SDave Chinner if (error) 534330f712c9SDave Chinner goto error0; 534430f712c9SDave Chinner goto nodelete; 534530f712c9SDave Chinner } else { 534630f712c9SDave Chinner ASSERT(del.br_state == XFS_EXT_NORM); 534730f712c9SDave Chinner del.br_state = XFS_EXT_UNWRITTEN; 534830f712c9SDave Chinner error = xfs_bmap_add_extent_unwritten_real(tp, 5349b2b1712aSChristoph Hellwig ip, whichfork, &icur, &cur, 535092f9da30SBrian Foster &del, &logflags); 535130f712c9SDave Chinner if (error) 535230f712c9SDave Chinner goto error0; 535330f712c9SDave Chinner goto nodelete; 535430f712c9SDave Chinner } 535530f712c9SDave Chinner } 535630f712c9SDave Chinner 53570703a8e1SDave Chinner delete: 5358e1d7553fSChristoph Hellwig if (wasdel) { 5359b2b1712aSChristoph Hellwig error = xfs_bmap_del_extent_delay(ip, whichfork, &icur, 5360e1d7553fSChristoph Hellwig &got, &del); 5361e1d7553fSChristoph Hellwig } else { 536281ba8f3eSBrian Foster error = xfs_bmap_del_extent_real(ip, tp, &icur, cur, 536381ba8f3eSBrian Foster &del, &tmp_logflags, whichfork, 5364e1d7553fSChristoph Hellwig flags); 536530f712c9SDave Chinner logflags |= tmp_logflags; 5366e1d7553fSChristoph Hellwig } 5367e1d7553fSChristoph Hellwig 536830f712c9SDave Chinner if (error) 536930f712c9SDave Chinner goto error0; 5370b2706a05SBrian Foster 5371e1a4e37cSDarrick J. Wong max_len -= del.br_blockcount; 53728280f6edSChristoph Hellwig end = del.br_startoff - 1; 537330f712c9SDave Chinner nodelete: 537430f712c9SDave Chinner /* 537530f712c9SDave Chinner * If not done go on to the next (previous) record. 537630f712c9SDave Chinner */ 53778280f6edSChristoph Hellwig if (end != (xfs_fileoff_t)-1 && end >= start) { 5378b2b1712aSChristoph Hellwig if (!xfs_iext_get_extent(ifp, &icur, &got) || 5379b2b1712aSChristoph Hellwig (got.br_startoff > end && 5380b2b1712aSChristoph Hellwig !xfs_iext_prev_extent(ifp, &icur, &got))) { 5381b2b1712aSChristoph Hellwig done = true; 5382b2b1712aSChristoph Hellwig break; 538330f712c9SDave Chinner } 538430f712c9SDave Chinner extno++; 538530f712c9SDave Chinner } 538630f712c9SDave Chinner } 5387b2b1712aSChristoph Hellwig if (done || end == (xfs_fileoff_t)-1 || end < start) 53884453593bSDarrick J. Wong *rlen = 0; 53894453593bSDarrick J. Wong else 53908280f6edSChristoph Hellwig *rlen = end - start + 1; 539130f712c9SDave Chinner 539230f712c9SDave Chinner /* 539330f712c9SDave Chinner * Convert to a btree if necessary. 539430f712c9SDave Chinner */ 539530f712c9SDave Chinner if (xfs_bmap_needs_btree(ip, whichfork)) { 539630f712c9SDave Chinner ASSERT(cur == NULL); 5397280253d2SBrian Foster error = xfs_bmap_extents_to_btree(tp, ip, &cur, 0, 5398280253d2SBrian Foster &tmp_logflags, whichfork); 539930f712c9SDave Chinner logflags |= tmp_logflags; 540030f712c9SDave Chinner if (error) 540130f712c9SDave Chinner goto error0; 540230f712c9SDave Chinner } 540330f712c9SDave Chinner /* 540430f712c9SDave Chinner * transform from btree to extents, give it cur 540530f712c9SDave Chinner */ 540630f712c9SDave Chinner else if (xfs_bmap_wants_extents(ip, whichfork)) { 540730f712c9SDave Chinner ASSERT(cur != NULL); 540830f712c9SDave Chinner error = xfs_bmap_btree_to_extents(tp, ip, cur, &tmp_logflags, 540930f712c9SDave Chinner whichfork); 541030f712c9SDave Chinner logflags |= tmp_logflags; 541130f712c9SDave Chinner if (error) 541230f712c9SDave Chinner goto error0; 541330f712c9SDave Chinner } 541430f712c9SDave Chinner /* 541530f712c9SDave Chinner * transform from extents to local? 541630f712c9SDave Chinner */ 541730f712c9SDave Chinner error = 0; 541830f712c9SDave Chinner error0: 541930f712c9SDave Chinner /* 542030f712c9SDave Chinner * Log everything. Do this after conversion, there's no point in 542130f712c9SDave Chinner * logging the extent records if we've converted to btree format. 542230f712c9SDave Chinner */ 542330f712c9SDave Chinner if ((logflags & xfs_ilog_fext(whichfork)) && 542430f712c9SDave Chinner XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS) 542530f712c9SDave Chinner logflags &= ~xfs_ilog_fext(whichfork); 542630f712c9SDave Chinner else if ((logflags & xfs_ilog_fbroot(whichfork)) && 542730f712c9SDave Chinner XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE) 542830f712c9SDave Chinner logflags &= ~xfs_ilog_fbroot(whichfork); 542930f712c9SDave Chinner /* 543030f712c9SDave Chinner * Log inode even in the error case, if the transaction 543130f712c9SDave Chinner * is dirty we'll need to shut down the filesystem. 543230f712c9SDave Chinner */ 543330f712c9SDave Chinner if (logflags) 543430f712c9SDave Chinner xfs_trans_log_inode(tp, ip, logflags); 543530f712c9SDave Chinner if (cur) { 5436cf612de7SBrian Foster if (!error) 543730f712c9SDave Chinner cur->bc_private.b.allocated = 0; 54380b04b6b8SDarrick J. Wong xfs_btree_del_cursor(cur, error); 543930f712c9SDave Chinner } 544030f712c9SDave Chinner return error; 544130f712c9SDave Chinner } 544230f712c9SDave Chinner 54434453593bSDarrick J. Wong /* Unmap a range of a file. */ 54444453593bSDarrick J. Wong int 54454453593bSDarrick J. Wong xfs_bunmapi( 54464453593bSDarrick J. Wong xfs_trans_t *tp, 54474453593bSDarrick J. Wong struct xfs_inode *ip, 54484453593bSDarrick J. Wong xfs_fileoff_t bno, 54494453593bSDarrick J. Wong xfs_filblks_t len, 54504453593bSDarrick J. Wong int flags, 54514453593bSDarrick J. Wong xfs_extnum_t nexts, 54524453593bSDarrick J. Wong int *done) 54534453593bSDarrick J. Wong { 54544453593bSDarrick J. Wong int error; 54554453593bSDarrick J. Wong 54562af52842SBrian Foster error = __xfs_bunmapi(tp, ip, bno, &len, flags, nexts); 54574453593bSDarrick J. Wong *done = (len == 0); 54584453593bSDarrick J. Wong return error; 54594453593bSDarrick J. Wong } 54604453593bSDarrick J. Wong 546130f712c9SDave Chinner /* 5462ddb19e31SBrian Foster * Determine whether an extent shift can be accomplished by a merge with the 5463ddb19e31SBrian Foster * extent that precedes the target hole of the shift. 5464ddb19e31SBrian Foster */ 5465ddb19e31SBrian Foster STATIC bool 5466ddb19e31SBrian Foster xfs_bmse_can_merge( 5467ddb19e31SBrian Foster struct xfs_bmbt_irec *left, /* preceding extent */ 5468ddb19e31SBrian Foster struct xfs_bmbt_irec *got, /* current extent to shift */ 5469ddb19e31SBrian Foster xfs_fileoff_t shift) /* shift fsb */ 5470ddb19e31SBrian Foster { 5471ddb19e31SBrian Foster xfs_fileoff_t startoff; 5472ddb19e31SBrian Foster 5473ddb19e31SBrian Foster startoff = got->br_startoff - shift; 5474ddb19e31SBrian Foster 5475ddb19e31SBrian Foster /* 5476ddb19e31SBrian Foster * The extent, once shifted, must be adjacent in-file and on-disk with 5477ddb19e31SBrian Foster * the preceding extent. 5478ddb19e31SBrian Foster */ 5479ddb19e31SBrian Foster if ((left->br_startoff + left->br_blockcount != startoff) || 5480ddb19e31SBrian Foster (left->br_startblock + left->br_blockcount != got->br_startblock) || 5481ddb19e31SBrian Foster (left->br_state != got->br_state) || 5482ddb19e31SBrian Foster (left->br_blockcount + got->br_blockcount > MAXEXTLEN)) 5483ddb19e31SBrian Foster return false; 5484ddb19e31SBrian Foster 5485ddb19e31SBrian Foster return true; 5486ddb19e31SBrian Foster } 5487ddb19e31SBrian Foster 5488ddb19e31SBrian Foster /* 5489ddb19e31SBrian Foster * A bmap extent shift adjusts the file offset of an extent to fill a preceding 5490ddb19e31SBrian Foster * hole in the file. If an extent shift would result in the extent being fully 5491ddb19e31SBrian Foster * adjacent to the extent that currently precedes the hole, we can merge with 5492ddb19e31SBrian Foster * the preceding extent rather than do the shift. 5493ddb19e31SBrian Foster * 5494ddb19e31SBrian Foster * This function assumes the caller has verified a shift-by-merge is possible 5495ddb19e31SBrian Foster * with the provided extents via xfs_bmse_can_merge(). 5496ddb19e31SBrian Foster */ 5497ddb19e31SBrian Foster STATIC int 5498ddb19e31SBrian Foster xfs_bmse_merge( 5499ddb19e31SBrian Foster struct xfs_inode *ip, 5500ddb19e31SBrian Foster int whichfork, 5501ddb19e31SBrian Foster xfs_fileoff_t shift, /* shift fsb */ 5502b2b1712aSChristoph Hellwig struct xfs_iext_cursor *icur, 55034da6b514SChristoph Hellwig struct xfs_bmbt_irec *got, /* extent to shift */ 55044da6b514SChristoph Hellwig struct xfs_bmbt_irec *left, /* preceding extent */ 5505ddb19e31SBrian Foster struct xfs_btree_cur *cur, 55064da6b514SChristoph Hellwig int *logflags, /* output */ 55074da6b514SChristoph Hellwig struct xfs_defer_ops *dfops) 5508ddb19e31SBrian Foster { 55094da6b514SChristoph Hellwig struct xfs_bmbt_irec new; 5510ddb19e31SBrian Foster xfs_filblks_t blockcount; 5511ddb19e31SBrian Foster int error, i; 55125fb5aeeeSEric Sandeen struct xfs_mount *mp = ip->i_mount; 5513ddb19e31SBrian Foster 55144da6b514SChristoph Hellwig blockcount = left->br_blockcount + got->br_blockcount; 5515ddb19e31SBrian Foster 5516ddb19e31SBrian Foster ASSERT(xfs_isilocked(ip, XFS_IOLOCK_EXCL)); 5517ddb19e31SBrian Foster ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL)); 55184da6b514SChristoph Hellwig ASSERT(xfs_bmse_can_merge(left, got, shift)); 5519ddb19e31SBrian Foster 55204da6b514SChristoph Hellwig new = *left; 55214da6b514SChristoph Hellwig new.br_blockcount = blockcount; 5522ddb19e31SBrian Foster 5523ddb19e31SBrian Foster /* 5524ddb19e31SBrian Foster * Update the on-disk extent count, the btree if necessary and log the 5525ddb19e31SBrian Foster * inode. 5526ddb19e31SBrian Foster */ 5527ddb19e31SBrian Foster XFS_IFORK_NEXT_SET(ip, whichfork, 5528ddb19e31SBrian Foster XFS_IFORK_NEXTENTS(ip, whichfork) - 1); 5529ddb19e31SBrian Foster *logflags |= XFS_ILOG_CORE; 5530ddb19e31SBrian Foster if (!cur) { 5531ddb19e31SBrian Foster *logflags |= XFS_ILOG_DEXT; 55324da6b514SChristoph Hellwig goto done; 5533ddb19e31SBrian Foster } 5534ddb19e31SBrian Foster 5535ddb19e31SBrian Foster /* lookup and remove the extent to merge */ 5536e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(cur, got, &i); 5537ddb19e31SBrian Foster if (error) 55384db431f5SDave Chinner return error; 55395fb5aeeeSEric Sandeen XFS_WANT_CORRUPTED_RETURN(mp, i == 1); 5540ddb19e31SBrian Foster 5541ddb19e31SBrian Foster error = xfs_btree_delete(cur, &i); 5542ddb19e31SBrian Foster if (error) 55434db431f5SDave Chinner return error; 55445fb5aeeeSEric Sandeen XFS_WANT_CORRUPTED_RETURN(mp, i == 1); 5545ddb19e31SBrian Foster 5546ddb19e31SBrian Foster /* lookup and update size of the previous extent */ 5547e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(cur, left, &i); 5548ddb19e31SBrian Foster if (error) 55494db431f5SDave Chinner return error; 55505fb5aeeeSEric Sandeen XFS_WANT_CORRUPTED_RETURN(mp, i == 1); 5551ddb19e31SBrian Foster 5552a67d00a5SChristoph Hellwig error = xfs_bmbt_update(cur, &new); 55534da6b514SChristoph Hellwig if (error) 55544da6b514SChristoph Hellwig return error; 5555ddb19e31SBrian Foster 55564da6b514SChristoph Hellwig done: 5557c38ccf59SChristoph Hellwig xfs_iext_remove(ip, icur, 0); 5558b2b1712aSChristoph Hellwig xfs_iext_prev(XFS_IFORK_PTR(ip, whichfork), icur); 5559b2b1712aSChristoph Hellwig xfs_iext_update_extent(ip, xfs_bmap_fork_to_state(whichfork), icur, 5560b2b1712aSChristoph Hellwig &new); 55614da6b514SChristoph Hellwig 55624cc1ee5eSDarrick J. Wong /* update reverse mapping. rmap functions merge the rmaps for us */ 55634da6b514SChristoph Hellwig error = xfs_rmap_unmap_extent(mp, dfops, ip, whichfork, got); 55644da6b514SChristoph Hellwig if (error) 55654da6b514SChristoph Hellwig return error; 55664cc1ee5eSDarrick J. Wong memcpy(&new, got, sizeof(new)); 55674cc1ee5eSDarrick J. Wong new.br_startoff = left->br_startoff + left->br_blockcount; 55684da6b514SChristoph Hellwig return xfs_rmap_map_extent(mp, dfops, ip, whichfork, &new); 5569ddb19e31SBrian Foster } 5570ddb19e31SBrian Foster 5571bf806280SChristoph Hellwig static int 5572bf806280SChristoph Hellwig xfs_bmap_shift_update_extent( 5573a979bdfeSBrian Foster struct xfs_inode *ip, 5574a979bdfeSBrian Foster int whichfork, 5575b2b1712aSChristoph Hellwig struct xfs_iext_cursor *icur, 55764da6b514SChristoph Hellwig struct xfs_bmbt_irec *got, 5577a979bdfeSBrian Foster struct xfs_btree_cur *cur, 5578a904b1caSNamjae Jeon int *logflags, 5579bf806280SChristoph Hellwig struct xfs_defer_ops *dfops, 5580bf806280SChristoph Hellwig xfs_fileoff_t startoff) 5581a979bdfeSBrian Foster { 5582bf806280SChristoph Hellwig struct xfs_mount *mp = ip->i_mount; 558311f75b3bSChristoph Hellwig struct xfs_bmbt_irec prev = *got; 5584bf806280SChristoph Hellwig int error, i; 5585a979bdfeSBrian Foster 5586a979bdfeSBrian Foster *logflags |= XFS_ILOG_CORE; 5587a979bdfeSBrian Foster 558811f75b3bSChristoph Hellwig got->br_startoff = startoff; 55894da6b514SChristoph Hellwig 55904da6b514SChristoph Hellwig if (cur) { 559111f75b3bSChristoph Hellwig error = xfs_bmbt_lookup_eq(cur, &prev, &i); 5592a979bdfeSBrian Foster if (error) 5593a979bdfeSBrian Foster return error; 55945fb5aeeeSEric Sandeen XFS_WANT_CORRUPTED_RETURN(mp, i == 1); 5595a979bdfeSBrian Foster 559611f75b3bSChristoph Hellwig error = xfs_bmbt_update(cur, got); 55979c194644SDarrick J. Wong if (error) 55989c194644SDarrick J. Wong return error; 55994da6b514SChristoph Hellwig } else { 56004da6b514SChristoph Hellwig *logflags |= XFS_ILOG_DEXT; 56014da6b514SChristoph Hellwig } 56029c194644SDarrick J. Wong 5603b2b1712aSChristoph Hellwig xfs_iext_update_extent(ip, xfs_bmap_fork_to_state(whichfork), icur, 5604b2b1712aSChristoph Hellwig got); 56054da6b514SChristoph Hellwig 56069c194644SDarrick J. Wong /* update reverse mapping */ 560711f75b3bSChristoph Hellwig error = xfs_rmap_unmap_extent(mp, dfops, ip, whichfork, &prev); 56089c194644SDarrick J. Wong if (error) 56099c194644SDarrick J. Wong return error; 561011f75b3bSChristoph Hellwig return xfs_rmap_map_extent(mp, dfops, ip, whichfork, got); 5611a979bdfeSBrian Foster } 5612a979bdfeSBrian Foster 561330f712c9SDave Chinner int 5614ecfea3f0SChristoph Hellwig xfs_bmap_collapse_extents( 561530f712c9SDave Chinner struct xfs_trans *tp, 561630f712c9SDave Chinner struct xfs_inode *ip, 5617a904b1caSNamjae Jeon xfs_fileoff_t *next_fsb, 561830f712c9SDave Chinner xfs_fileoff_t offset_shift_fsb, 5619333f950cSBrian Foster bool *done) 562030f712c9SDave Chinner { 5621ecfea3f0SChristoph Hellwig int whichfork = XFS_DATA_FORK; 5622ecfea3f0SChristoph Hellwig struct xfs_mount *mp = ip->i_mount; 5623ecfea3f0SChristoph Hellwig struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, whichfork); 5624ca446d88SBrian Foster struct xfs_btree_cur *cur = NULL; 5625bf806280SChristoph Hellwig struct xfs_bmbt_irec got, prev; 5626b2b1712aSChristoph Hellwig struct xfs_iext_cursor icur; 5627bf806280SChristoph Hellwig xfs_fileoff_t new_startoff; 562830f712c9SDave Chinner int error = 0; 5629ca446d88SBrian Foster int logflags = 0; 563030f712c9SDave Chinner 563130f712c9SDave Chinner if (unlikely(XFS_TEST_ERROR( 563230f712c9SDave Chinner (XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS && 563330f712c9SDave Chinner XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE), 56349e24cfd0SDarrick J. Wong mp, XFS_ERRTAG_BMAPIFORMAT))) { 5635ecfea3f0SChristoph Hellwig XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_LOW, mp); 56362451337dSDave Chinner return -EFSCORRUPTED; 563730f712c9SDave Chinner } 563830f712c9SDave Chinner 563930f712c9SDave Chinner if (XFS_FORCED_SHUTDOWN(mp)) 56402451337dSDave Chinner return -EIO; 564130f712c9SDave Chinner 5642ecfea3f0SChristoph Hellwig ASSERT(xfs_isilocked(ip, XFS_IOLOCK_EXCL | XFS_ILOCK_EXCL)); 564330f712c9SDave Chinner 564430f712c9SDave Chinner if (!(ifp->if_flags & XFS_IFEXTENTS)) { 564530f712c9SDave Chinner error = xfs_iread_extents(tp, ip, whichfork); 564630f712c9SDave Chinner if (error) 564730f712c9SDave Chinner return error; 564830f712c9SDave Chinner } 564930f712c9SDave Chinner 5650ddb19e31SBrian Foster if (ifp->if_flags & XFS_IFBROOT) { 5651ddb19e31SBrian Foster cur = xfs_bmbt_init_cursor(mp, tp, ip, whichfork); 5652ddb19e31SBrian Foster cur->bc_private.b.flags = 0; 5653ddb19e31SBrian Foster } 5654ddb19e31SBrian Foster 5655b2b1712aSChristoph Hellwig if (!xfs_iext_lookup_extent(ip, ifp, *next_fsb, &icur, &got)) { 5656ecfea3f0SChristoph Hellwig *done = true; 5657ecfea3f0SChristoph Hellwig goto del_cursor; 5658ecfea3f0SChristoph Hellwig } 5659d41c6172SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, !isnullstartblock(got.br_startblock), 5660d41c6172SEric Sandeen del_cursor); 5661ecfea3f0SChristoph Hellwig 5662bf806280SChristoph Hellwig new_startoff = got.br_startoff - offset_shift_fsb; 5663b2b1712aSChristoph Hellwig if (xfs_iext_peek_prev_extent(ifp, &icur, &prev)) { 5664bf806280SChristoph Hellwig if (new_startoff < prev.br_startoff + prev.br_blockcount) { 5665bf806280SChristoph Hellwig error = -EINVAL; 5666bf806280SChristoph Hellwig goto del_cursor; 5667bf806280SChristoph Hellwig } 5668bf806280SChristoph Hellwig 5669bf806280SChristoph Hellwig if (xfs_bmse_can_merge(&prev, &got, offset_shift_fsb)) { 5670bf806280SChristoph Hellwig error = xfs_bmse_merge(ip, whichfork, offset_shift_fsb, 5671b2b1712aSChristoph Hellwig &icur, &got, &prev, cur, &logflags, 5672f4a9cf97SBrian Foster tp->t_dfops); 5673ecfea3f0SChristoph Hellwig if (error) 5674ecfea3f0SChristoph Hellwig goto del_cursor; 5675bf806280SChristoph Hellwig goto done; 5676bf806280SChristoph Hellwig } 5677bf806280SChristoph Hellwig } else { 5678bf806280SChristoph Hellwig if (got.br_startoff < offset_shift_fsb) { 5679bf806280SChristoph Hellwig error = -EINVAL; 5680bf806280SChristoph Hellwig goto del_cursor; 5681bf806280SChristoph Hellwig } 5682bf806280SChristoph Hellwig } 5683bf806280SChristoph Hellwig 5684b2b1712aSChristoph Hellwig error = xfs_bmap_shift_update_extent(ip, whichfork, &icur, &got, cur, 5685f4a9cf97SBrian Foster &logflags, tp->t_dfops, new_startoff); 5686bf806280SChristoph Hellwig if (error) 5687bf806280SChristoph Hellwig goto del_cursor; 568840591bdbSChristoph Hellwig 568942630361SChristoph Hellwig done: 5690b2b1712aSChristoph Hellwig if (!xfs_iext_next_extent(ifp, &icur, &got)) { 5691ecfea3f0SChristoph Hellwig *done = true; 5692ecfea3f0SChristoph Hellwig goto del_cursor; 5693ecfea3f0SChristoph Hellwig } 5694ecfea3f0SChristoph Hellwig 5695ecfea3f0SChristoph Hellwig *next_fsb = got.br_startoff; 5696ecfea3f0SChristoph Hellwig del_cursor: 5697ecfea3f0SChristoph Hellwig if (cur) 56980b04b6b8SDarrick J. Wong xfs_btree_del_cursor(cur, error); 5699ecfea3f0SChristoph Hellwig if (logflags) 5700ecfea3f0SChristoph Hellwig xfs_trans_log_inode(tp, ip, logflags); 5701ecfea3f0SChristoph Hellwig return error; 5702ecfea3f0SChristoph Hellwig } 5703ecfea3f0SChristoph Hellwig 5704f62cb48eSDarrick J. Wong /* Make sure we won't be right-shifting an extent past the maximum bound. */ 5705f62cb48eSDarrick J. Wong int 5706f62cb48eSDarrick J. Wong xfs_bmap_can_insert_extents( 5707f62cb48eSDarrick J. Wong struct xfs_inode *ip, 5708f62cb48eSDarrick J. Wong xfs_fileoff_t off, 5709f62cb48eSDarrick J. Wong xfs_fileoff_t shift) 5710f62cb48eSDarrick J. Wong { 5711f62cb48eSDarrick J. Wong struct xfs_bmbt_irec got; 5712f62cb48eSDarrick J. Wong int is_empty; 5713f62cb48eSDarrick J. Wong int error = 0; 5714f62cb48eSDarrick J. Wong 5715f62cb48eSDarrick J. Wong ASSERT(xfs_isilocked(ip, XFS_IOLOCK_EXCL)); 5716f62cb48eSDarrick J. Wong 5717f62cb48eSDarrick J. Wong if (XFS_FORCED_SHUTDOWN(ip->i_mount)) 5718f62cb48eSDarrick J. Wong return -EIO; 5719f62cb48eSDarrick J. Wong 5720f62cb48eSDarrick J. Wong xfs_ilock(ip, XFS_ILOCK_EXCL); 5721f62cb48eSDarrick J. Wong error = xfs_bmap_last_extent(NULL, ip, XFS_DATA_FORK, &got, &is_empty); 5722f62cb48eSDarrick J. Wong if (!error && !is_empty && got.br_startoff >= off && 5723f62cb48eSDarrick J. Wong ((got.br_startoff + shift) & BMBT_STARTOFF_MASK) < got.br_startoff) 5724f62cb48eSDarrick J. Wong error = -EINVAL; 5725f62cb48eSDarrick J. Wong xfs_iunlock(ip, XFS_ILOCK_EXCL); 5726f62cb48eSDarrick J. Wong 5727f62cb48eSDarrick J. Wong return error; 5728f62cb48eSDarrick J. Wong } 5729f62cb48eSDarrick J. Wong 5730ecfea3f0SChristoph Hellwig int 5731ecfea3f0SChristoph Hellwig xfs_bmap_insert_extents( 5732ecfea3f0SChristoph Hellwig struct xfs_trans *tp, 5733ecfea3f0SChristoph Hellwig struct xfs_inode *ip, 5734ecfea3f0SChristoph Hellwig xfs_fileoff_t *next_fsb, 5735ecfea3f0SChristoph Hellwig xfs_fileoff_t offset_shift_fsb, 5736ecfea3f0SChristoph Hellwig bool *done, 5737333f950cSBrian Foster xfs_fileoff_t stop_fsb) 5738ecfea3f0SChristoph Hellwig { 5739ecfea3f0SChristoph Hellwig int whichfork = XFS_DATA_FORK; 5740ecfea3f0SChristoph Hellwig struct xfs_mount *mp = ip->i_mount; 5741ecfea3f0SChristoph Hellwig struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, whichfork); 5742ecfea3f0SChristoph Hellwig struct xfs_btree_cur *cur = NULL; 57435936dc54SChristoph Hellwig struct xfs_bmbt_irec got, next; 5744b2b1712aSChristoph Hellwig struct xfs_iext_cursor icur; 5745bf806280SChristoph Hellwig xfs_fileoff_t new_startoff; 5746ecfea3f0SChristoph Hellwig int error = 0; 5747ecfea3f0SChristoph Hellwig int logflags = 0; 5748ecfea3f0SChristoph Hellwig 5749ecfea3f0SChristoph Hellwig if (unlikely(XFS_TEST_ERROR( 5750ecfea3f0SChristoph Hellwig (XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS && 5751ecfea3f0SChristoph Hellwig XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE), 5752ecfea3f0SChristoph Hellwig mp, XFS_ERRTAG_BMAPIFORMAT))) { 5753ecfea3f0SChristoph Hellwig XFS_ERROR_REPORT(__func__, XFS_ERRLEVEL_LOW, mp); 5754ecfea3f0SChristoph Hellwig return -EFSCORRUPTED; 5755ecfea3f0SChristoph Hellwig } 5756ecfea3f0SChristoph Hellwig 5757ecfea3f0SChristoph Hellwig if (XFS_FORCED_SHUTDOWN(mp)) 5758ecfea3f0SChristoph Hellwig return -EIO; 5759ecfea3f0SChristoph Hellwig 5760ecfea3f0SChristoph Hellwig ASSERT(xfs_isilocked(ip, XFS_IOLOCK_EXCL | XFS_ILOCK_EXCL)); 5761ecfea3f0SChristoph Hellwig 5762ecfea3f0SChristoph Hellwig if (!(ifp->if_flags & XFS_IFEXTENTS)) { 5763ecfea3f0SChristoph Hellwig error = xfs_iread_extents(tp, ip, whichfork); 5764ecfea3f0SChristoph Hellwig if (error) 5765ecfea3f0SChristoph Hellwig return error; 5766ecfea3f0SChristoph Hellwig } 5767ecfea3f0SChristoph Hellwig 5768ecfea3f0SChristoph Hellwig if (ifp->if_flags & XFS_IFBROOT) { 5769ecfea3f0SChristoph Hellwig cur = xfs_bmbt_init_cursor(mp, tp, ip, whichfork); 5770ecfea3f0SChristoph Hellwig cur->bc_private.b.flags = 0; 5771ecfea3f0SChristoph Hellwig } 5772ecfea3f0SChristoph Hellwig 5773a904b1caSNamjae Jeon if (*next_fsb == NULLFSBLOCK) { 5774b2b1712aSChristoph Hellwig xfs_iext_last(ifp, &icur); 5775b2b1712aSChristoph Hellwig if (!xfs_iext_get_extent(ifp, &icur, &got) || 57765936dc54SChristoph Hellwig stop_fsb > got.br_startoff) { 5777ecfea3f0SChristoph Hellwig *done = true; 5778a904b1caSNamjae Jeon goto del_cursor; 5779a904b1caSNamjae Jeon } 578005b7c8abSChristoph Hellwig } else { 5781b2b1712aSChristoph Hellwig if (!xfs_iext_lookup_extent(ip, ifp, *next_fsb, &icur, &got)) { 5782ecfea3f0SChristoph Hellwig *done = true; 5783a904b1caSNamjae Jeon goto del_cursor; 5784a904b1caSNamjae Jeon } 578505b7c8abSChristoph Hellwig } 5786d41c6172SEric Sandeen XFS_WANT_CORRUPTED_GOTO(mp, !isnullstartblock(got.br_startblock), 5787d41c6172SEric Sandeen del_cursor); 5788a904b1caSNamjae Jeon 57895936dc54SChristoph Hellwig if (stop_fsb >= got.br_startoff + got.br_blockcount) { 5790a904b1caSNamjae Jeon error = -EIO; 5791a904b1caSNamjae Jeon goto del_cursor; 5792a904b1caSNamjae Jeon } 5793a904b1caSNamjae Jeon 5794bf806280SChristoph Hellwig new_startoff = got.br_startoff + offset_shift_fsb; 5795b2b1712aSChristoph Hellwig if (xfs_iext_peek_next_extent(ifp, &icur, &next)) { 5796bf806280SChristoph Hellwig if (new_startoff + got.br_blockcount > next.br_startoff) { 5797bf806280SChristoph Hellwig error = -EINVAL; 5798bf806280SChristoph Hellwig goto del_cursor; 5799bf806280SChristoph Hellwig } 5800bf806280SChristoph Hellwig 5801bf806280SChristoph Hellwig /* 5802bf806280SChristoph Hellwig * Unlike a left shift (which involves a hole punch), a right 5803bf806280SChristoph Hellwig * shift does not modify extent neighbors in any way. We should 5804bf806280SChristoph Hellwig * never find mergeable extents in this scenario. Check anyways 5805bf806280SChristoph Hellwig * and warn if we encounter two extents that could be one. 5806bf806280SChristoph Hellwig */ 5807bf806280SChristoph Hellwig if (xfs_bmse_can_merge(&got, &next, offset_shift_fsb)) 5808bf806280SChristoph Hellwig WARN_ON_ONCE(1); 5809bf806280SChristoph Hellwig } 5810bf806280SChristoph Hellwig 5811b2b1712aSChristoph Hellwig error = xfs_bmap_shift_update_extent(ip, whichfork, &icur, &got, cur, 5812f4a9cf97SBrian Foster &logflags, tp->t_dfops, new_startoff); 5813ddb19e31SBrian Foster if (error) 5814ddb19e31SBrian Foster goto del_cursor; 58155936dc54SChristoph Hellwig 5816b2b1712aSChristoph Hellwig if (!xfs_iext_prev_extent(ifp, &icur, &got) || 58175936dc54SChristoph Hellwig stop_fsb >= got.br_startoff + got.br_blockcount) { 5818ecfea3f0SChristoph Hellwig *done = true; 58196b18af0dSChristoph Hellwig goto del_cursor; 5820a904b1caSNamjae Jeon } 582130f712c9SDave Chinner 58222c845f5aSBrian Foster *next_fsb = got.br_startoff; 582330f712c9SDave Chinner del_cursor: 582430f712c9SDave Chinner if (cur) 58250b04b6b8SDarrick J. Wong xfs_btree_del_cursor(cur, error); 5826ca446d88SBrian Foster if (logflags) 582730f712c9SDave Chinner xfs_trans_log_inode(tp, ip, logflags); 582830f712c9SDave Chinner return error; 582930f712c9SDave Chinner } 5830a904b1caSNamjae Jeon 5831a904b1caSNamjae Jeon /* 5832b2b1712aSChristoph Hellwig * Splits an extent into two extents at split_fsb block such that it is the 5833b2b1712aSChristoph Hellwig * first block of the current_ext. @ext is a target extent to be split. 5834b2b1712aSChristoph Hellwig * @split_fsb is a block where the extents is split. If split_fsb lies in a 5835b2b1712aSChristoph Hellwig * hole or the first block of extents, just return 0. 5836a904b1caSNamjae Jeon */ 5837a904b1caSNamjae Jeon STATIC int 5838a904b1caSNamjae Jeon xfs_bmap_split_extent_at( 5839a904b1caSNamjae Jeon struct xfs_trans *tp, 5840a904b1caSNamjae Jeon struct xfs_inode *ip, 58414b77a088SBrian Foster xfs_fileoff_t split_fsb) 5842a904b1caSNamjae Jeon { 5843a904b1caSNamjae Jeon int whichfork = XFS_DATA_FORK; 5844a904b1caSNamjae Jeon struct xfs_btree_cur *cur = NULL; 5845a904b1caSNamjae Jeon struct xfs_bmbt_irec got; 5846a904b1caSNamjae Jeon struct xfs_bmbt_irec new; /* split extent */ 5847a904b1caSNamjae Jeon struct xfs_mount *mp = ip->i_mount; 5848a904b1caSNamjae Jeon struct xfs_ifork *ifp; 5849a904b1caSNamjae Jeon xfs_fsblock_t gotblkcnt; /* new block count for got */ 5850b2b1712aSChristoph Hellwig struct xfs_iext_cursor icur; 5851a904b1caSNamjae Jeon int error = 0; 5852a904b1caSNamjae Jeon int logflags = 0; 5853a904b1caSNamjae Jeon int i = 0; 5854a904b1caSNamjae Jeon 5855a904b1caSNamjae Jeon if (unlikely(XFS_TEST_ERROR( 5856a904b1caSNamjae Jeon (XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_EXTENTS && 5857a904b1caSNamjae Jeon XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE), 58589e24cfd0SDarrick J. Wong mp, XFS_ERRTAG_BMAPIFORMAT))) { 5859a904b1caSNamjae Jeon XFS_ERROR_REPORT("xfs_bmap_split_extent_at", 5860a904b1caSNamjae Jeon XFS_ERRLEVEL_LOW, mp); 5861a904b1caSNamjae Jeon return -EFSCORRUPTED; 5862a904b1caSNamjae Jeon } 5863a904b1caSNamjae Jeon 5864a904b1caSNamjae Jeon if (XFS_FORCED_SHUTDOWN(mp)) 5865a904b1caSNamjae Jeon return -EIO; 5866a904b1caSNamjae Jeon 5867a904b1caSNamjae Jeon ifp = XFS_IFORK_PTR(ip, whichfork); 5868a904b1caSNamjae Jeon if (!(ifp->if_flags & XFS_IFEXTENTS)) { 5869a904b1caSNamjae Jeon /* Read in all the extents */ 5870a904b1caSNamjae Jeon error = xfs_iread_extents(tp, ip, whichfork); 5871a904b1caSNamjae Jeon if (error) 5872a904b1caSNamjae Jeon return error; 5873a904b1caSNamjae Jeon } 5874a904b1caSNamjae Jeon 5875a904b1caSNamjae Jeon /* 58764c35445bSChristoph Hellwig * If there are not extents, or split_fsb lies in a hole we are done. 5877a904b1caSNamjae Jeon */ 5878b2b1712aSChristoph Hellwig if (!xfs_iext_lookup_extent(ip, ifp, split_fsb, &icur, &got) || 58794c35445bSChristoph Hellwig got.br_startoff >= split_fsb) 5880a904b1caSNamjae Jeon return 0; 5881a904b1caSNamjae Jeon 5882a904b1caSNamjae Jeon gotblkcnt = split_fsb - got.br_startoff; 5883a904b1caSNamjae Jeon new.br_startoff = split_fsb; 5884a904b1caSNamjae Jeon new.br_startblock = got.br_startblock + gotblkcnt; 5885a904b1caSNamjae Jeon new.br_blockcount = got.br_blockcount - gotblkcnt; 5886a904b1caSNamjae Jeon new.br_state = got.br_state; 5887a904b1caSNamjae Jeon 5888a904b1caSNamjae Jeon if (ifp->if_flags & XFS_IFBROOT) { 5889a904b1caSNamjae Jeon cur = xfs_bmbt_init_cursor(mp, tp, ip, whichfork); 5890a904b1caSNamjae Jeon cur->bc_private.b.flags = 0; 5891e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(cur, &got, &i); 5892a904b1caSNamjae Jeon if (error) 5893a904b1caSNamjae Jeon goto del_cursor; 5894a904b1caSNamjae Jeon XFS_WANT_CORRUPTED_GOTO(mp, i == 1, del_cursor); 5895a904b1caSNamjae Jeon } 5896a904b1caSNamjae Jeon 5897a904b1caSNamjae Jeon got.br_blockcount = gotblkcnt; 5898b2b1712aSChristoph Hellwig xfs_iext_update_extent(ip, xfs_bmap_fork_to_state(whichfork), &icur, 5899b2b1712aSChristoph Hellwig &got); 5900a904b1caSNamjae Jeon 5901a904b1caSNamjae Jeon logflags = XFS_ILOG_CORE; 5902a904b1caSNamjae Jeon if (cur) { 5903a67d00a5SChristoph Hellwig error = xfs_bmbt_update(cur, &got); 5904a904b1caSNamjae Jeon if (error) 5905a904b1caSNamjae Jeon goto del_cursor; 5906a904b1caSNamjae Jeon } else 5907a904b1caSNamjae Jeon logflags |= XFS_ILOG_DEXT; 5908a904b1caSNamjae Jeon 5909a904b1caSNamjae Jeon /* Add new extent */ 5910b2b1712aSChristoph Hellwig xfs_iext_next(ifp, &icur); 59110254c2f2SChristoph Hellwig xfs_iext_insert(ip, &icur, &new, 0); 5912a904b1caSNamjae Jeon XFS_IFORK_NEXT_SET(ip, whichfork, 5913a904b1caSNamjae Jeon XFS_IFORK_NEXTENTS(ip, whichfork) + 1); 5914a904b1caSNamjae Jeon 5915a904b1caSNamjae Jeon if (cur) { 5916e16cf9b0SChristoph Hellwig error = xfs_bmbt_lookup_eq(cur, &new, &i); 5917a904b1caSNamjae Jeon if (error) 5918a904b1caSNamjae Jeon goto del_cursor; 5919a904b1caSNamjae Jeon XFS_WANT_CORRUPTED_GOTO(mp, i == 0, del_cursor); 5920a904b1caSNamjae Jeon error = xfs_btree_insert(cur, &i); 5921a904b1caSNamjae Jeon if (error) 5922a904b1caSNamjae Jeon goto del_cursor; 5923a904b1caSNamjae Jeon XFS_WANT_CORRUPTED_GOTO(mp, i == 1, del_cursor); 5924a904b1caSNamjae Jeon } 5925a904b1caSNamjae Jeon 5926a904b1caSNamjae Jeon /* 5927a904b1caSNamjae Jeon * Convert to a btree if necessary. 5928a904b1caSNamjae Jeon */ 5929a904b1caSNamjae Jeon if (xfs_bmap_needs_btree(ip, whichfork)) { 5930a904b1caSNamjae Jeon int tmp_logflags; /* partial log flag return val */ 5931a904b1caSNamjae Jeon 5932a904b1caSNamjae Jeon ASSERT(cur == NULL); 5933280253d2SBrian Foster error = xfs_bmap_extents_to_btree(tp, ip, &cur, 0, 5934280253d2SBrian Foster &tmp_logflags, whichfork); 5935a904b1caSNamjae Jeon logflags |= tmp_logflags; 5936a904b1caSNamjae Jeon } 5937a904b1caSNamjae Jeon 5938a904b1caSNamjae Jeon del_cursor: 5939a904b1caSNamjae Jeon if (cur) { 5940a904b1caSNamjae Jeon cur->bc_private.b.allocated = 0; 59410b04b6b8SDarrick J. Wong xfs_btree_del_cursor(cur, error); 5942a904b1caSNamjae Jeon } 5943a904b1caSNamjae Jeon 5944a904b1caSNamjae Jeon if (logflags) 5945a904b1caSNamjae Jeon xfs_trans_log_inode(tp, ip, logflags); 5946a904b1caSNamjae Jeon return error; 5947a904b1caSNamjae Jeon } 5948a904b1caSNamjae Jeon 5949a904b1caSNamjae Jeon int 5950a904b1caSNamjae Jeon xfs_bmap_split_extent( 5951a904b1caSNamjae Jeon struct xfs_inode *ip, 5952a904b1caSNamjae Jeon xfs_fileoff_t split_fsb) 5953a904b1caSNamjae Jeon { 5954a904b1caSNamjae Jeon struct xfs_mount *mp = ip->i_mount; 5955a904b1caSNamjae Jeon struct xfs_trans *tp; 59562c3234d1SDarrick J. Wong struct xfs_defer_ops dfops; 5957a904b1caSNamjae Jeon int error; 5958a904b1caSNamjae Jeon 5959253f4911SChristoph Hellwig error = xfs_trans_alloc(mp, &M_RES(mp)->tr_write, 5960253f4911SChristoph Hellwig XFS_DIOSTRAT_SPACE_RES(mp, 0), 0, 0, &tp); 5961253f4911SChristoph Hellwig if (error) 5962a904b1caSNamjae Jeon return error; 59635fdd9794SBrian Foster xfs_defer_init(tp, &dfops); 5964a904b1caSNamjae Jeon 5965a904b1caSNamjae Jeon xfs_ilock(ip, XFS_ILOCK_EXCL); 5966a904b1caSNamjae Jeon xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL); 5967a904b1caSNamjae Jeon 59684b77a088SBrian Foster error = xfs_bmap_split_extent_at(tp, ip, split_fsb); 5969a904b1caSNamjae Jeon if (error) 5970a904b1caSNamjae Jeon goto out; 5971a904b1caSNamjae Jeon 59728ad7c629SChristoph Hellwig error = xfs_defer_finish(&tp, &dfops); 5973a904b1caSNamjae Jeon if (error) 5974a904b1caSNamjae Jeon goto out; 5975a904b1caSNamjae Jeon 597670393313SChristoph Hellwig return xfs_trans_commit(tp); 5977a904b1caSNamjae Jeon 5978a904b1caSNamjae Jeon out: 59792c3234d1SDarrick J. Wong xfs_defer_cancel(&dfops); 59804906e215SChristoph Hellwig xfs_trans_cancel(tp); 5981a904b1caSNamjae Jeon return error; 5982a904b1caSNamjae Jeon } 59839f3afb57SDarrick J. Wong 59849f3afb57SDarrick J. Wong /* Deferred mapping is only for real extents in the data fork. */ 59859f3afb57SDarrick J. Wong static bool 59869f3afb57SDarrick J. Wong xfs_bmap_is_update_needed( 59879f3afb57SDarrick J. Wong struct xfs_bmbt_irec *bmap) 59889f3afb57SDarrick J. Wong { 59899f3afb57SDarrick J. Wong return bmap->br_startblock != HOLESTARTBLOCK && 59909f3afb57SDarrick J. Wong bmap->br_startblock != DELAYSTARTBLOCK; 59919f3afb57SDarrick J. Wong } 59929f3afb57SDarrick J. Wong 59939f3afb57SDarrick J. Wong /* Record a bmap intent. */ 59949f3afb57SDarrick J. Wong static int 59959f3afb57SDarrick J. Wong __xfs_bmap_add( 59969f3afb57SDarrick J. Wong struct xfs_mount *mp, 59979f3afb57SDarrick J. Wong struct xfs_defer_ops *dfops, 59989f3afb57SDarrick J. Wong enum xfs_bmap_intent_type type, 59999f3afb57SDarrick J. Wong struct xfs_inode *ip, 60009f3afb57SDarrick J. Wong int whichfork, 60019f3afb57SDarrick J. Wong struct xfs_bmbt_irec *bmap) 60029f3afb57SDarrick J. Wong { 60039f3afb57SDarrick J. Wong int error; 60049f3afb57SDarrick J. Wong struct xfs_bmap_intent *bi; 60059f3afb57SDarrick J. Wong 60069f3afb57SDarrick J. Wong trace_xfs_bmap_defer(mp, 60079f3afb57SDarrick J. Wong XFS_FSB_TO_AGNO(mp, bmap->br_startblock), 60089f3afb57SDarrick J. Wong type, 60099f3afb57SDarrick J. Wong XFS_FSB_TO_AGBNO(mp, bmap->br_startblock), 60109f3afb57SDarrick J. Wong ip->i_ino, whichfork, 60119f3afb57SDarrick J. Wong bmap->br_startoff, 60129f3afb57SDarrick J. Wong bmap->br_blockcount, 60139f3afb57SDarrick J. Wong bmap->br_state); 60149f3afb57SDarrick J. Wong 60159f3afb57SDarrick J. Wong bi = kmem_alloc(sizeof(struct xfs_bmap_intent), KM_SLEEP | KM_NOFS); 60169f3afb57SDarrick J. Wong INIT_LIST_HEAD(&bi->bi_list); 60179f3afb57SDarrick J. Wong bi->bi_type = type; 60189f3afb57SDarrick J. Wong bi->bi_owner = ip; 60199f3afb57SDarrick J. Wong bi->bi_whichfork = whichfork; 60209f3afb57SDarrick J. Wong bi->bi_bmap = *bmap; 60219f3afb57SDarrick J. Wong 6022882d8785SChristoph Hellwig error = xfs_defer_ijoin(dfops, bi->bi_owner); 60239f3afb57SDarrick J. Wong if (error) { 60249f3afb57SDarrick J. Wong kmem_free(bi); 60259f3afb57SDarrick J. Wong return error; 60269f3afb57SDarrick J. Wong } 60279f3afb57SDarrick J. Wong 60289f3afb57SDarrick J. Wong xfs_defer_add(dfops, XFS_DEFER_OPS_TYPE_BMAP, &bi->bi_list); 60299f3afb57SDarrick J. Wong return 0; 60309f3afb57SDarrick J. Wong } 60319f3afb57SDarrick J. Wong 60329f3afb57SDarrick J. Wong /* Map an extent into a file. */ 60339f3afb57SDarrick J. Wong int 60349f3afb57SDarrick J. Wong xfs_bmap_map_extent( 60359f3afb57SDarrick J. Wong struct xfs_mount *mp, 60369f3afb57SDarrick J. Wong struct xfs_defer_ops *dfops, 60379f3afb57SDarrick J. Wong struct xfs_inode *ip, 60389f3afb57SDarrick J. Wong struct xfs_bmbt_irec *PREV) 60399f3afb57SDarrick J. Wong { 60409f3afb57SDarrick J. Wong if (!xfs_bmap_is_update_needed(PREV)) 60419f3afb57SDarrick J. Wong return 0; 60429f3afb57SDarrick J. Wong 60439f3afb57SDarrick J. Wong return __xfs_bmap_add(mp, dfops, XFS_BMAP_MAP, ip, 60449f3afb57SDarrick J. Wong XFS_DATA_FORK, PREV); 60459f3afb57SDarrick J. Wong } 60469f3afb57SDarrick J. Wong 60479f3afb57SDarrick J. Wong /* Unmap an extent out of a file. */ 60489f3afb57SDarrick J. Wong int 60499f3afb57SDarrick J. Wong xfs_bmap_unmap_extent( 60509f3afb57SDarrick J. Wong struct xfs_mount *mp, 60519f3afb57SDarrick J. Wong struct xfs_defer_ops *dfops, 60529f3afb57SDarrick J. Wong struct xfs_inode *ip, 60539f3afb57SDarrick J. Wong struct xfs_bmbt_irec *PREV) 60549f3afb57SDarrick J. Wong { 60559f3afb57SDarrick J. Wong if (!xfs_bmap_is_update_needed(PREV)) 60569f3afb57SDarrick J. Wong return 0; 60579f3afb57SDarrick J. Wong 60589f3afb57SDarrick J. Wong return __xfs_bmap_add(mp, dfops, XFS_BMAP_UNMAP, ip, 60599f3afb57SDarrick J. Wong XFS_DATA_FORK, PREV); 60609f3afb57SDarrick J. Wong } 60619f3afb57SDarrick J. Wong 60629f3afb57SDarrick J. Wong /* 60639f3afb57SDarrick J. Wong * Process one of the deferred bmap operations. We pass back the 60649f3afb57SDarrick J. Wong * btree cursor to maintain our lock on the bmapbt between calls. 60659f3afb57SDarrick J. Wong */ 60669f3afb57SDarrick J. Wong int 60679f3afb57SDarrick J. Wong xfs_bmap_finish_one( 60689f3afb57SDarrick J. Wong struct xfs_trans *tp, 60699f3afb57SDarrick J. Wong struct xfs_defer_ops *dfops, 60709f3afb57SDarrick J. Wong struct xfs_inode *ip, 60719f3afb57SDarrick J. Wong enum xfs_bmap_intent_type type, 60729f3afb57SDarrick J. Wong int whichfork, 60739f3afb57SDarrick J. Wong xfs_fileoff_t startoff, 60749f3afb57SDarrick J. Wong xfs_fsblock_t startblock, 6075e1a4e37cSDarrick J. Wong xfs_filblks_t *blockcount, 60769f3afb57SDarrick J. Wong xfs_exntst_t state) 60779f3afb57SDarrick J. Wong { 6078e1a4e37cSDarrick J. Wong int error = 0; 60799f3afb57SDarrick J. Wong 608037283797SBrian Foster ASSERT(tp->t_firstblock == NULLFSBLOCK); 60814c1a67bdSDarrick J. Wong 60829f3afb57SDarrick J. Wong trace_xfs_bmap_deferred(tp->t_mountp, 60839f3afb57SDarrick J. Wong XFS_FSB_TO_AGNO(tp->t_mountp, startblock), type, 60849f3afb57SDarrick J. Wong XFS_FSB_TO_AGBNO(tp->t_mountp, startblock), 6085e1a4e37cSDarrick J. Wong ip->i_ino, whichfork, startoff, *blockcount, state); 60869f3afb57SDarrick J. Wong 608739e07daaSChristoph Hellwig if (WARN_ON_ONCE(whichfork != XFS_DATA_FORK)) 60889f3afb57SDarrick J. Wong return -EFSCORRUPTED; 60899f3afb57SDarrick J. Wong 60909f3afb57SDarrick J. Wong if (XFS_TEST_ERROR(false, tp->t_mountp, 60919e24cfd0SDarrick J. Wong XFS_ERRTAG_BMAP_FINISH_ONE)) 60929f3afb57SDarrick J. Wong return -EIO; 60939f3afb57SDarrick J. Wong 60949f3afb57SDarrick J. Wong switch (type) { 60959f3afb57SDarrick J. Wong case XFS_BMAP_MAP: 6096ff3edf25SBrian Foster ASSERT(dfops == tp->t_dfops); 6097e1a4e37cSDarrick J. Wong error = xfs_bmapi_remap(tp, ip, startoff, *blockcount, 6098ff3edf25SBrian Foster startblock, 0); 6099e1a4e37cSDarrick J. Wong *blockcount = 0; 61009f3afb57SDarrick J. Wong break; 61019f3afb57SDarrick J. Wong case XFS_BMAP_UNMAP: 6102e1a4e37cSDarrick J. Wong error = __xfs_bunmapi(tp, ip, startoff, blockcount, 61032af52842SBrian Foster XFS_BMAPI_REMAP, 1); 61049f3afb57SDarrick J. Wong break; 61059f3afb57SDarrick J. Wong default: 61069f3afb57SDarrick J. Wong ASSERT(0); 61079f3afb57SDarrick J. Wong error = -EFSCORRUPTED; 61089f3afb57SDarrick J. Wong } 61099f3afb57SDarrick J. Wong 61109f3afb57SDarrick J. Wong return error; 61119f3afb57SDarrick J. Wong } 611230b0984dSDarrick J. Wong 611330b0984dSDarrick J. Wong /* Check that an inode's extent does not have invalid flags or bad ranges. */ 611430b0984dSDarrick J. Wong xfs_failaddr_t 611530b0984dSDarrick J. Wong xfs_bmap_validate_extent( 611630b0984dSDarrick J. Wong struct xfs_inode *ip, 611730b0984dSDarrick J. Wong int whichfork, 611830b0984dSDarrick J. Wong struct xfs_bmbt_irec *irec) 611930b0984dSDarrick J. Wong { 612030b0984dSDarrick J. Wong struct xfs_mount *mp = ip->i_mount; 612130b0984dSDarrick J. Wong xfs_fsblock_t endfsb; 612230b0984dSDarrick J. Wong bool isrt; 612330b0984dSDarrick J. Wong 612430b0984dSDarrick J. Wong isrt = XFS_IS_REALTIME_INODE(ip); 612530b0984dSDarrick J. Wong endfsb = irec->br_startblock + irec->br_blockcount - 1; 612630b0984dSDarrick J. Wong if (isrt) { 612730b0984dSDarrick J. Wong if (!xfs_verify_rtbno(mp, irec->br_startblock)) 612830b0984dSDarrick J. Wong return __this_address; 612930b0984dSDarrick J. Wong if (!xfs_verify_rtbno(mp, endfsb)) 613030b0984dSDarrick J. Wong return __this_address; 613130b0984dSDarrick J. Wong } else { 613230b0984dSDarrick J. Wong if (!xfs_verify_fsbno(mp, irec->br_startblock)) 613330b0984dSDarrick J. Wong return __this_address; 613430b0984dSDarrick J. Wong if (!xfs_verify_fsbno(mp, endfsb)) 613530b0984dSDarrick J. Wong return __this_address; 613630b0984dSDarrick J. Wong if (XFS_FSB_TO_AGNO(mp, irec->br_startblock) != 613730b0984dSDarrick J. Wong XFS_FSB_TO_AGNO(mp, endfsb)) 613830b0984dSDarrick J. Wong return __this_address; 613930b0984dSDarrick J. Wong } 614030b0984dSDarrick J. Wong if (irec->br_state != XFS_EXT_NORM) { 614130b0984dSDarrick J. Wong if (whichfork != XFS_DATA_FORK) 614230b0984dSDarrick J. Wong return __this_address; 614330b0984dSDarrick J. Wong if (!xfs_sb_version_hasextflgbit(&mp->m_sb)) 614430b0984dSDarrick J. Wong return __this_address; 614530b0984dSDarrick J. Wong } 614630b0984dSDarrick J. Wong return NULL; 614730b0984dSDarrick J. Wong } 6148