fs/xfs/libxfs/xfs_bmap.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (c) 2000-2006 Silicon Graphics, Inc.
   4  * All Rights Reserved.
   5  */
   6 #include "xfs.h"
   7 #include "xfs_fs.h"
   8 #include "xfs_shared.h"
   9 #include "xfs_format.h"
  10 #include "xfs_log_format.h"
  11 #include "xfs_trans_resv.h"
  12 #include "xfs_bit.h"
  13 #include "xfs_sb.h"
  14 #include "xfs_mount.h"
  15 #include "xfs_defer.h"
  16 #include "xfs_dir2.h"
  17 #include "xfs_inode.h"
  18 #include "xfs_btree.h"
  19 #include "xfs_trans.h"
  20 #include "xfs_alloc.h"
  21 #include "xfs_bmap.h"
  22 #include "xfs_bmap_util.h"
  23 #include "xfs_bmap_btree.h"
  24 #include "xfs_rtbitmap.h"
  25 #include "xfs_errortag.h"
  26 #include "xfs_error.h"
  27 #include "xfs_quota.h"
  28 #include "xfs_trans_space.h"
  29 #include "xfs_buf_item.h"
  30 #include "xfs_trace.h"
  31 #include "xfs_attr_leaf.h"
  32 #include "xfs_filestream.h"
  33 #include "xfs_rmap.h"
  34 #include "xfs_ag.h"
  35 #include "xfs_ag_resv.h"
  36 #include "xfs_refcount.h"
  37 #include "xfs_icache.h"
  38 #include "xfs_iomap.h"
  39 #include "xfs_health.h"
  40 #include "xfs_bmap_item.h"
  41 #include "xfs_symlink_remote.h"
  42
  43 struct kmem_cache               *xfs_bmap_intent_cache;
  44
  45 /*
  46  * Miscellaneous helper functions
  47  */
  48
  49 /*
  50  * Compute and fill in the value of the maximum depth of a bmap btree
  51  * in this filesystem.  Done once, during mount.
  52  */
  53 void
  54 xfs_bmap_compute_maxlevels(
  55         xfs_mount_t     *mp,            /* file system mount structure */
  56         int             whichfork)      /* data or attr fork */
  57 {
  58         uint64_t        maxblocks;      /* max blocks at this level */
  59         xfs_extnum_t    maxleafents;    /* max leaf entries possible */
  60         int             level;          /* btree level */
  61         int             maxrootrecs;    /* max records in root block */
  62         int             minleafrecs;    /* min records in leaf block */
  63         int             minnoderecs;    /* min records in node block */
  64         int             sz;             /* root block size */
  65
  66         /*
  67          * The maximum number of extents in a fork, hence the maximum number of
  68          * leaf entries, is controlled by the size of the on-disk extent count.
  69          *
  70          * Note that we can no longer assume that if we are in ATTR1 that the
  71          * fork offset of all the inodes will be
  72          * (xfs_default_attroffset(ip) >> 3) because we could have mounted with
  73          * ATTR2 and then mounted back with ATTR1, keeping the i_forkoff's fixed
  74          * but probably at various positions. Therefore, for both ATTR1 and
  75          * ATTR2 we have to assume the worst case scenario of a minimum size
  76          * available.
  77          */
  78         maxleafents = xfs_iext_max_nextents(xfs_has_large_extent_counts(mp),
  79                                 whichfork);
  80         if (whichfork == XFS_DATA_FORK)
  81                 sz = XFS_BMDR_SPACE_CALC(MINDBTPTRS);
  82         else
  83                 sz = XFS_BMDR_SPACE_CALC(MINABTPTRS);
  84
  85         maxrootrecs = xfs_bmdr_maxrecs(sz, 0);
  86         minleafrecs = mp->m_bmap_dmnr[0];
  87         minnoderecs = mp->m_bmap_dmnr[1];
  88         maxblocks = howmany_64(maxleafents, minleafrecs);
  89         for (level = 1; maxblocks > 1; level++) {
  90                 if (maxblocks <= maxrootrecs)
  91                         maxblocks = 1;
  92                 else
  93                         maxblocks = howmany_64(maxblocks, minnoderecs);
  94         }
  95         mp->m_bm_maxlevels[whichfork] = level;
  96         ASSERT(mp->m_bm_maxlevels[whichfork] <= xfs_bmbt_maxlevels_ondisk());
  97 }
  98
  99 unsigned int
 100 xfs_bmap_compute_attr_offset(
 101         struct xfs_mount        *mp)
 102 {
 103         if (mp->m_sb.sb_inodesize == 256)
 104                 return XFS_LITINO(mp) - XFS_BMDR_SPACE_CALC(MINABTPTRS);
 105         return XFS_BMDR_SPACE_CALC(6 * MINABTPTRS);
 106 }
 107
 108 STATIC int                              /* error */
 109 xfs_bmbt_lookup_eq(
 110         struct xfs_btree_cur    *cur,
 111         struct xfs_bmbt_irec    *irec,
 112         int                     *stat)  /* success/failure */
 113 {
 114         cur->bc_rec.b = *irec;
 115         return xfs_btree_lookup(cur, XFS_LOOKUP_EQ, stat);
 116 }
 117
 118 STATIC int                              /* error */
 119 xfs_bmbt_lookup_first(
 120         struct xfs_btree_cur    *cur,
 121         int                     *stat)  /* success/failure */
 122 {
 123         cur->bc_rec.b.br_startoff = 0;
 124         cur->bc_rec.b.br_startblock = 0;
 125         cur->bc_rec.b.br_blockcount = 0;
 126         return xfs_btree_lookup(cur, XFS_LOOKUP_GE, stat);
 127 }
 128
 129 /*
 130  * Check if the inode needs to be converted to btree format.
 131  */
 132 static inline bool xfs_bmap_needs_btree(struct xfs_inode *ip, int whichfork)
 133 {
 134         struct xfs_ifork *ifp = xfs_ifork_ptr(ip, whichfork);
 135
 136         return whichfork != XFS_COW_FORK &&
 137                 ifp->if_format == XFS_DINODE_FMT_EXTENTS &&
 138                 ifp->if_nextents > XFS_IFORK_MAXEXT(ip, whichfork);
 139 }
 140
 141 /*
 142  * Check if the inode should be converted to extent format.
 143  */
 144 static inline bool xfs_bmap_wants_extents(struct xfs_inode *ip, int whichfork)
 145 {
 146         struct xfs_ifork *ifp = xfs_ifork_ptr(ip, whichfork);
 147
 148         return whichfork != XFS_COW_FORK &&
 149                 ifp->if_format == XFS_DINODE_FMT_BTREE &&
 150                 ifp->if_nextents <= XFS_IFORK_MAXEXT(ip, whichfork);
 151 }
 152
 153 /*
 154  * Update the record referred to by cur to the value given by irec
 155  * This either works (return 0) or gets an EFSCORRUPTED error.
 156  */
 157 STATIC int
 158 xfs_bmbt_update(
 159         struct xfs_btree_cur    *cur,
 160         struct xfs_bmbt_irec    *irec)
 161 {
 162         union xfs_btree_rec     rec;
 163
 164         xfs_bmbt_disk_set_all(&rec.bmbt, irec);
 165         return xfs_btree_update(cur, &rec);
 166 }
 167
 168 /*
 169  * Compute the worst-case number of indirect blocks that will be used
 170  * for ip's delayed extent of length "len".
 171  */
 172 STATIC xfs_filblks_t
 173 xfs_bmap_worst_indlen(
 174         xfs_inode_t     *ip,            /* incore inode pointer */
 175         xfs_filblks_t   len)            /* delayed extent length */
 176 {
 177         int             level;          /* btree level number */
 178         int             maxrecs;        /* maximum record count at this level */
 179         xfs_mount_t     *mp;            /* mount structure */
 180         xfs_filblks_t   rval;           /* return value */
 181
 182         mp = ip->i_mount;
 183         maxrecs = mp->m_bmap_dmxr[0];
 184         for (level = 0, rval = 0;
 185              level < XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK);
 186              level++) {
 187                 len += maxrecs - 1;
 188                 do_div(len, maxrecs);
 189                 rval += len;
 190                 if (len == 1)
 191                         return rval + XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK) -
 192                                 level - 1;
 193                 if (level == 0)
 194                         maxrecs = mp->m_bmap_dmxr[1];
 195         }
 196         return rval;
 197 }
 198
 199 /*
 200  * Calculate the default attribute fork offset for newly created inodes.
 201  */
 202 uint
 203 xfs_default_attroffset(
 204         struct xfs_inode        *ip)
 205 {
 206         if (ip->i_df.if_format == XFS_DINODE_FMT_DEV)
 207                 return roundup(sizeof(xfs_dev_t), 8);
 208         return M_IGEO(ip->i_mount)->attr_fork_offset;
 209 }
 210
 211 /*
 212  * Helper routine to reset inode i_forkoff field when switching attribute fork
 213  * from local to extent format - we reset it where possible to make space
 214  * available for inline data fork extents.
 215  */
 216 STATIC void
 217 xfs_bmap_forkoff_reset(
 218         xfs_inode_t     *ip,
 219         int             whichfork)
 220 {
 221         if (whichfork == XFS_ATTR_FORK &&
 222             ip->i_df.if_format != XFS_DINODE_FMT_DEV &&
 223             ip->i_df.if_format != XFS_DINODE_FMT_BTREE) {
 224                 uint    dfl_forkoff = xfs_default_attroffset(ip) >> 3;
 225
 226                 if (dfl_forkoff > ip->i_forkoff)
 227                         ip->i_forkoff = dfl_forkoff;
 228         }
 229 }
 230
 231 static int
 232 xfs_bmap_read_buf(
 233         struct xfs_mount        *mp,            /* file system mount point */
 234         struct xfs_trans        *tp,            /* transaction pointer */
 235         xfs_fsblock_t           fsbno,          /* file system block number */
 236         struct xfs_buf          **bpp)          /* buffer for fsbno */
 237 {
 238         struct xfs_buf          *bp;            /* return value */
 239         int                     error;
 240
 241         if (!xfs_verify_fsbno(mp, fsbno))
 242                 return -EFSCORRUPTED;
 243         error = xfs_trans_read_buf(mp, tp, mp->m_ddev_targp,
 244                         XFS_FSB_TO_DADDR(mp, fsbno), mp->m_bsize, 0, &bp,
 245                         &xfs_bmbt_buf_ops);
 246         if (!error) {
 247                 xfs_buf_set_ref(bp, XFS_BMAP_BTREE_REF);
 248                 *bpp = bp;
 249         }
 250         return error;
 251 }
 252
 253 #ifdef DEBUG
 254 STATIC struct xfs_buf *
 255 xfs_bmap_get_bp(
 256         struct xfs_btree_cur    *cur,
 257         xfs_fsblock_t           bno)
 258 {
 259         struct xfs_log_item     *lip;
 260         int                     i;
 261
 262         if (!cur)
 263                 return NULL;
 264
 265         for (i = 0; i < cur->bc_maxlevels; i++) {
 266                 if (!cur->bc_levels[i].bp)
 267                         break;
 268                 if (xfs_buf_daddr(cur->bc_levels[i].bp) == bno)
 269                         return cur->bc_levels[i].bp;
 270         }
 271
 272         /* Chase down all the log items to see if the bp is there */
 273         list_for_each_entry(lip, &cur->bc_tp->t_items, li_trans) {
 274                 struct xfs_buf_log_item *bip = (struct xfs_buf_log_item *)lip;
 275
 276                 if (bip->bli_item.li_type == XFS_LI_BUF &&
 277                     xfs_buf_daddr(bip->bli_buf) == bno)
 278                         return bip->bli_buf;
 279         }
 280
 281         return NULL;
 282 }
 283
 284 STATIC void
 285 xfs_check_block(
 286         struct xfs_btree_block  *block,
 287         xfs_mount_t             *mp,
 288         int                     root,
 289         short                   sz)
 290 {
 291         int                     i, j, dmxr;
 292         __be64                  *pp, *thispa;   /* pointer to block address */
 293         xfs_bmbt_key_t          *prevp, *keyp;
 294
 295         ASSERT(be16_to_cpu(block->bb_level) > 0);
 296
 297         prevp = NULL;
 298         for( i = 1; i <= xfs_btree_get_numrecs(block); i++) {
 299                 dmxr = mp->m_bmap_dmxr[0];
 300                 keyp = XFS_BMBT_KEY_ADDR(mp, block, i);
 301
 302                 if (prevp) {
 303                         ASSERT(be64_to_cpu(prevp->br_startoff) <
 304                                be64_to_cpu(keyp->br_startoff));
 305                 }
 306                 prevp = keyp;
 307
 308                 /*
 309                  * Compare the block numbers to see if there are dups.
 310                  */
 311                 if (root)
 312                         pp = XFS_BMAP_BROOT_PTR_ADDR(mp, block, i, sz);
 313                 else
 314                         pp = XFS_BMBT_PTR_ADDR(mp, block, i, dmxr);
 315
 316                 for (j = i+1; j <= be16_to_cpu(block->bb_numrecs); j++) {
 317                         if (root)
 318                                 thispa = XFS_BMAP_BROOT_PTR_ADDR(mp, block, j, sz);
 319                         else
 320                                 thispa = XFS_BMBT_PTR_ADDR(mp, block, j, dmxr);
 321                         if (*thispa == *pp) {
 322                                 xfs_warn(mp, "%s: thispa(%d) == pp(%d) %lld",
 323                                         __func__, j, i,
 324                                         (unsigned long long)be64_to_cpu(*thispa));
 325                                 xfs_err(mp, "%s: ptrs are equal in node\n",
 326                                         __func__);
 327                                 xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
 328                         }
 329                 }
 330         }
 331 }
 332
 333 /*
 334  * Check that the extents for the inode ip are in the right order in all
 335  * btree leaves. THis becomes prohibitively expensive for large extent count
 336  * files, so don't bother with inodes that have more than 10,000 extents in
 337  * them. The btree record ordering checks will still be done, so for such large
 338  * bmapbt constructs that is going to catch most corruptions.
 339  */
 340 STATIC void
 341 xfs_bmap_check_leaf_extents(
 342         struct xfs_btree_cur    *cur,   /* btree cursor or null */
 343         xfs_inode_t             *ip,            /* incore inode pointer */
 344         int                     whichfork)      /* data or attr fork */
 345 {
 346         struct xfs_mount        *mp = ip->i_mount;
 347         struct xfs_ifork        *ifp = xfs_ifork_ptr(ip, whichfork);
 348         struct xfs_btree_block  *block; /* current btree block */
 349         xfs_fsblock_t           bno;    /* block # of "block" */
 350         struct xfs_buf          *bp;    /* buffer for "block" */
 351         int                     error;  /* error return value */
 352         xfs_extnum_t            i=0, j; /* index into the extents list */
 353         int                     level;  /* btree level, for checking */
 354         __be64                  *pp;    /* pointer to block address */
 355         xfs_bmbt_rec_t          *ep;    /* pointer to current extent */
 356         xfs_bmbt_rec_t          last = {0, 0}; /* last extent in prev block */
 357         xfs_bmbt_rec_t          *nextp; /* pointer to next extent */
 358         int                     bp_release = 0;
 359
 360         if (ifp->if_format != XFS_DINODE_FMT_BTREE)
 361                 return;
 362
 363         /* skip large extent count inodes */
 364         if (ip->i_df.if_nextents > 10000)
 365                 return;
 366
 367         bno = NULLFSBLOCK;
 368         block = ifp->if_broot;
 369         /*
 370          * Root level must use BMAP_BROOT_PTR_ADDR macro to get ptr out.
 371          */
 372         level = be16_to_cpu(block->bb_level);
 373         ASSERT(level > 0);
 374         xfs_check_block(block, mp, 1, ifp->if_broot_bytes);
 375         pp = XFS_BMAP_BROOT_PTR_ADDR(mp, block, 1, ifp->if_broot_bytes);
 376         bno = be64_to_cpu(*pp);
 377
 378         ASSERT(bno != NULLFSBLOCK);
 379         ASSERT(XFS_FSB_TO_AGNO(mp, bno) < mp->m_sb.sb_agcount);
 380         ASSERT(XFS_FSB_TO_AGBNO(mp, bno) < mp->m_sb.sb_agblocks);
 381
 382         /*
 383          * Go down the tree until leaf level is reached, following the first
 384          * pointer (leftmost) at each level.
 385          */
 386         while (level-- > 0) {
 387                 /* See if buf is in cur first */
 388                 bp_release = 0;
 389                 bp = xfs_bmap_get_bp(cur, XFS_FSB_TO_DADDR(mp, bno));
 390                 if (!bp) {
 391                         bp_release = 1;
 392                         error = xfs_bmap_read_buf(mp, NULL, bno, &bp);
 393                         if (xfs_metadata_is_sick(error))
 394                                 xfs_btree_mark_sick(cur);
 395                         if (error)
 396                                 goto error_norelse;
 397                 }
 398                 block = XFS_BUF_TO_BLOCK(bp);
 399                 if (level == 0)
 400                         break;
 401
 402                 /*
 403                  * Check this block for basic sanity (increasing keys and
 404                  * no duplicate blocks).
 405                  */
 406
 407                 xfs_check_block(block, mp, 0, 0);
 408                 pp = XFS_BMBT_PTR_ADDR(mp, block, 1, mp->m_bmap_dmxr[1]);
 409                 bno = be64_to_cpu(*pp);
 410                 if (XFS_IS_CORRUPT(mp, !xfs_verify_fsbno(mp, bno))) {
 411                         xfs_btree_mark_sick(cur);
 412                         error = -EFSCORRUPTED;
 413                         goto error0;
 414                 }
 415                 if (bp_release) {
 416                         bp_release = 0;
 417                         xfs_trans_brelse(NULL, bp);
 418                 }
 419         }
 420
 421         /*
 422          * Here with bp and block set to the leftmost leaf node in the tree.
 423          */
 424         i = 0;
 425
 426         /*
 427          * Loop over all leaf nodes checking that all extents are in the right order.
 428          */
 429         for (;;) {
 430                 xfs_fsblock_t   nextbno;
 431                 xfs_extnum_t    num_recs;
 432
 433
 434                 num_recs = xfs_btree_get_numrecs(block);
 435
 436                 /*
 437                  * Read-ahead the next leaf block, if any.
 438                  */
 439
 440                 nextbno = be64_to_cpu(block->bb_u.l.bb_rightsib);
 441
 442                 /*
 443                  * Check all the extents to make sure they are OK.
 444                  * If we had a previous block, the last entry should
 445                  * conform with the first entry in this one.
 446                  */
 447
 448                 ep = XFS_BMBT_REC_ADDR(mp, block, 1);
 449                 if (i) {
 450                         ASSERT(xfs_bmbt_disk_get_startoff(&last) +
 451                                xfs_bmbt_disk_get_blockcount(&last) <=
 452                                xfs_bmbt_disk_get_startoff(ep));
 453                 }
 454                 for (j = 1; j < num_recs; j++) {
 455                         nextp = XFS_BMBT_REC_ADDR(mp, block, j + 1);
 456                         ASSERT(xfs_bmbt_disk_get_startoff(ep) +
 457                                xfs_bmbt_disk_get_blockcount(ep) <=
 458                                xfs_bmbt_disk_get_startoff(nextp));
 459                         ep = nextp;
 460                 }
 461
 462                 last = *ep;
 463                 i += num_recs;
 464                 if (bp_release) {
 465                         bp_release = 0;
 466                         xfs_trans_brelse(NULL, bp);
 467                 }
 468                 bno = nextbno;
 469                 /*
 470                  * If we've reached the end, stop.
 471                  */
 472                 if (bno == NULLFSBLOCK)
 473                         break;
 474
 475                 bp_release = 0;
 476                 bp = xfs_bmap_get_bp(cur, XFS_FSB_TO_DADDR(mp, bno));
 477                 if (!bp) {
 478                         bp_release = 1;
 479                         error = xfs_bmap_read_buf(mp, NULL, bno, &bp);
 480                         if (xfs_metadata_is_sick(error))
 481                                 xfs_btree_mark_sick(cur);
 482                         if (error)
 483                                 goto error_norelse;
 484                 }
 485                 block = XFS_BUF_TO_BLOCK(bp);
 486         }
 487
 488         return;
 489
 490 error0:
 491         xfs_warn(mp, "%s: at error0", __func__);
 492         if (bp_release)
 493                 xfs_trans_brelse(NULL, bp);
 494 error_norelse:
 495         xfs_warn(mp, "%s: BAD after btree leaves for %llu extents",
 496                 __func__, i);
 497         xfs_err(mp, "%s: CORRUPTED BTREE OR SOMETHING", __func__);
 498         xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
 499         return;
 500 }
 501
 502 /*
 503  * Validate that the bmbt_irecs being returned from bmapi are valid
 504  * given the caller's original parameters.  Specifically check the
 505  * ranges of the returned irecs to ensure that they only extend beyond
 506  * the given parameters if the XFS_BMAPI_ENTIRE flag was set.
 507  */
 508 STATIC void
 509 xfs_bmap_validate_ret(
 510         xfs_fileoff_t           bno,
 511         xfs_filblks_t           len,
 512         uint32_t                flags,
 513         xfs_bmbt_irec_t         *mval,
 514         int                     nmap,
 515         int                     ret_nmap)
 516 {
 517         int                     i;              /* index to map values */
 518
 519         ASSERT(ret_nmap <= nmap);
 520
 521         for (i = 0; i < ret_nmap; i++) {
 522                 ASSERT(mval[i].br_blockcount > 0);
 523                 if (!(flags & XFS_BMAPI_ENTIRE)) {
 524                         ASSERT(mval[i].br_startoff >= bno);
 525                         ASSERT(mval[i].br_blockcount <= len);
 526                         ASSERT(mval[i].br_startoff + mval[i].br_blockcount <=
 527                                bno + len);
 528                 } else {
 529                         ASSERT(mval[i].br_startoff < bno + len);
 530                         ASSERT(mval[i].br_startoff + mval[i].br_blockcount >
 531                                bno);
 532                 }
 533                 ASSERT(i == 0 ||
 534                        mval[i - 1].br_startoff + mval[i - 1].br_blockcount ==
 535                        mval[i].br_startoff);
 536                 ASSERT(mval[i].br_startblock != DELAYSTARTBLOCK &&
 537                        mval[i].br_startblock != HOLESTARTBLOCK);
 538                 ASSERT(mval[i].br_state == XFS_EXT_NORM ||
 539                        mval[i].br_state == XFS_EXT_UNWRITTEN);
 540         }
 541 }
 542
 543 #else
 544 #define xfs_bmap_check_leaf_extents(cur, ip, whichfork)         do { } while (0)
 545 #define xfs_bmap_validate_ret(bno,len,flags,mval,onmap,nmap)    do { } while (0)
 546 #endif /* DEBUG */
 547
 548 /*
 549  * Inode fork format manipulation functions
 550  */
 551
 552 /*
 553  * Convert the inode format to extent format if it currently is in btree format,
 554  * but the extent list is small enough that it fits into the extent format.
 555  *
 556  * Since the extents are already in-core, all we have to do is give up the space
 557  * for the btree root and pitch the leaf block.
 558  */
 559 STATIC int                              /* error */
 560 xfs_bmap_btree_to_extents(
 561         struct xfs_trans        *tp,    /* transaction pointer */
 562         struct xfs_inode        *ip,    /* incore inode pointer */
 563         struct xfs_btree_cur    *cur,   /* btree cursor */
 564         int                     *logflagsp, /* inode logging flags */
 565         int                     whichfork)  /* data or attr fork */
 566 {
 567         struct xfs_ifork        *ifp = xfs_ifork_ptr(ip, whichfork);
 568         struct xfs_mount        *mp = ip->i_mount;
 569         struct xfs_btree_block  *rblock = ifp->if_broot;
 570         struct xfs_btree_block  *cblock;/* child btree block */
 571         xfs_fsblock_t           cbno;   /* child block number */
 572         struct xfs_buf          *cbp;   /* child block's buffer */
 573         int                     error;  /* error return value */
 574         __be64                  *pp;    /* ptr to block address */
 575         struct xfs_owner_info   oinfo;
 576
 577         /* check if we actually need the extent format first: */
 578         if (!xfs_bmap_wants_extents(ip, whichfork))
 579                 return 0;
 580
 581         ASSERT(cur);
 582         ASSERT(whichfork != XFS_COW_FORK);
 583         ASSERT(ifp->if_format == XFS_DINODE_FMT_BTREE);
 584         ASSERT(be16_to_cpu(rblock->bb_level) == 1);
 585         ASSERT(be16_to_cpu(rblock->bb_numrecs) == 1);
 586         ASSERT(xfs_bmbt_maxrecs(mp, ifp->if_broot_bytes, 0) == 1);
 587
 588         pp = XFS_BMAP_BROOT_PTR_ADDR(mp, rblock, 1, ifp->if_broot_bytes);
 589         cbno = be64_to_cpu(*pp);
 590 #ifdef DEBUG
 591         if (XFS_IS_CORRUPT(cur->bc_mp, !xfs_verify_fsbno(mp, cbno))) {
 592                 xfs_btree_mark_sick(cur);
 593                 return -EFSCORRUPTED;
 594         }
 595 #endif
 596         error = xfs_bmap_read_buf(mp, tp, cbno, &cbp);
 597         if (xfs_metadata_is_sick(error))
 598                 xfs_btree_mark_sick(cur);
 599         if (error)
 600                 return error;
 601         cblock = XFS_BUF_TO_BLOCK(cbp);
 602         if ((error = xfs_btree_check_block(cur, cblock, 0, cbp)))
 603                 return error;
 604
 605         xfs_rmap_ino_bmbt_owner(&oinfo, ip->i_ino, whichfork);
 606         error = xfs_free_extent_later(cur->bc_tp, cbno, 1, &oinfo,
 607                         XFS_AG_RESV_NONE, false);
 608         if (error)
 609                 return error;
 610
 611         ip->i_nblocks--;
 612         xfs_trans_mod_dquot_byino(tp, ip, XFS_TRANS_DQ_BCOUNT, -1L);
 613         xfs_trans_binval(tp, cbp);
 614         if (cur->bc_levels[0].bp == cbp)
 615                 cur->bc_levels[0].bp = NULL;
 616         xfs_iroot_realloc(ip, -1, whichfork);
 617         ASSERT(ifp->if_broot == NULL);
 618         ifp->if_format = XFS_DINODE_FMT_EXTENTS;
 619         *logflagsp |= XFS_ILOG_CORE | xfs_ilog_fext(whichfork);
 620         return 0;
 621 }
 622
 623 /*
 624  * Convert an extents-format file into a btree-format file.
 625  * The new file will have a root block (in the inode) and a single child block.
 626  */
 627 STATIC int                                      /* error */
 628 xfs_bmap_extents_to_btree(
 629         struct xfs_trans        *tp,            /* transaction pointer */
 630         struct xfs_inode        *ip,            /* incore inode pointer */
 631         struct xfs_btree_cur    **curp,         /* cursor returned to caller */
 632         int                     wasdel,         /* converting a delayed alloc */
 633         int                     *logflagsp,     /* inode logging flags */
 634         int                     whichfork)      /* data or attr fork */
 635 {
 636         struct xfs_btree_block  *ablock;        /* allocated (child) bt block */
 637         struct xfs_buf          *abp;           /* buffer for ablock */
 638         struct xfs_alloc_arg    args;           /* allocation arguments */
 639         struct xfs_bmbt_rec     *arp;           /* child record pointer */
 640         struct xfs_btree_block  *block;         /* btree root block */
 641         struct xfs_btree_cur    *cur;           /* bmap btree cursor */
 642         int                     error;          /* error return value */
 643         struct xfs_ifork        *ifp;           /* inode fork pointer */
 644         struct xfs_bmbt_key     *kp;            /* root block key pointer */
 645         struct xfs_mount        *mp;            /* mount structure */
 646         xfs_bmbt_ptr_t          *pp;            /* root block address pointer */
 647         struct xfs_iext_cursor  icur;
 648         struct xfs_bmbt_irec    rec;
 649         xfs_extnum_t            cnt = 0;
 650
 651         mp = ip->i_mount;
 652         ASSERT(whichfork != XFS_COW_FORK);
 653         ifp = xfs_ifork_ptr(ip, whichfork);
 654         ASSERT(ifp->if_format == XFS_DINODE_FMT_EXTENTS);
 655
 656         /*
 657          * Make space in the inode incore. This needs to be undone if we fail
 658          * to expand the root.
 659          */
 660         xfs_iroot_realloc(ip, 1, whichfork);
 661
 662         /*
 663          * Fill in the root.
 664          */
 665         block = ifp->if_broot;
 666         xfs_bmbt_init_block(ip, block, NULL, 1, 1);
 667         /*
 668          * Need a cursor.  Can't allocate until bb_level is filled in.
 669          */
 670         cur = xfs_bmbt_init_cursor(mp, tp, ip, whichfork);
 671         if (wasdel)
 672                 cur->bc_flags |= XFS_BTREE_BMBT_WASDEL;
 673         /*
 674          * Convert to a btree with two levels, one record in root.
 675          */
 676         ifp->if_format = XFS_DINODE_FMT_BTREE;
 677         memset(&args, 0, sizeof(args));
 678         args.tp = tp;
 679         args.mp = mp;
 680         xfs_rmap_ino_bmbt_owner(&args.oinfo, ip->i_ino, whichfork);
 681
 682         args.minlen = args.maxlen = args.prod = 1;
 683         args.wasdel = wasdel;
 684         *logflagsp = 0;
 685         error = xfs_alloc_vextent_start_ag(&args,
 686                                 XFS_INO_TO_FSB(mp, ip->i_ino));
 687         if (error)
 688                 goto out_root_realloc;
 689
 690         /*
 691          * Allocation can't fail, the space was reserved.
 692          */
 693         if (WARN_ON_ONCE(args.fsbno == NULLFSBLOCK)) {
 694                 error = -ENOSPC;
 695                 goto out_root_realloc;
 696         }
 697
 698         cur->bc_bmap.allocated++;
 699         ip->i_nblocks++;
 700         xfs_trans_mod_dquot_byino(tp, ip, XFS_TRANS_DQ_BCOUNT, 1L);
 701         error = xfs_trans_get_buf(tp, mp->m_ddev_targp,
 702                         XFS_FSB_TO_DADDR(mp, args.fsbno),
 703                         mp->m_bsize, 0, &abp);
 704         if (error)
 705                 goto out_unreserve_dquot;
 706
 707         /*
 708          * Fill in the child block.
 709          */
 710         ablock = XFS_BUF_TO_BLOCK(abp);
 711         xfs_bmbt_init_block(ip, ablock, abp, 0, 0);
 712
 713         for_each_xfs_iext(ifp, &icur, &rec) {
 714                 if (isnullstartblock(rec.br_startblock))
 715                         continue;
 716                 arp = XFS_BMBT_REC_ADDR(mp, ablock, 1 + cnt);
 717                 xfs_bmbt_disk_set_all(arp, &rec);
 718                 cnt++;
 719         }
 720         ASSERT(cnt == ifp->if_nextents);
 721         xfs_btree_set_numrecs(ablock, cnt);
 722
 723         /*
 724          * Fill in the root key and pointer.
 725          */
 726         kp = XFS_BMBT_KEY_ADDR(mp, block, 1);
 727         arp = XFS_BMBT_REC_ADDR(mp, ablock, 1);
 728         kp->br_startoff = cpu_to_be64(xfs_bmbt_disk_get_startoff(arp));
 729         pp = XFS_BMBT_PTR_ADDR(mp, block, 1, xfs_bmbt_get_maxrecs(cur,
 730                                                 be16_to_cpu(block->bb_level)));
 731         *pp = cpu_to_be64(args.fsbno);
 732
 733         /*
 734          * Do all this logging at the end so that
 735          * the root is at the right level.
 736          */
 737         xfs_btree_log_block(cur, abp, XFS_BB_ALL_BITS);
 738         xfs_btree_log_recs(cur, abp, 1, be16_to_cpu(ablock->bb_numrecs));
 739         ASSERT(*curp == NULL);
 740         *curp = cur;
 741         *logflagsp = XFS_ILOG_CORE | xfs_ilog_fbroot(whichfork);
 742         return 0;
 743
 744 out_unreserve_dquot:
 745         xfs_trans_mod_dquot_byino(tp, ip, XFS_TRANS_DQ_BCOUNT, -1L);
 746 out_root_realloc:
 747         xfs_iroot_realloc(ip, -1, whichfork);
 748         ifp->if_format = XFS_DINODE_FMT_EXTENTS;
 749         ASSERT(ifp->if_broot == NULL);
 750         xfs_btree_del_cursor(cur, XFS_BTREE_ERROR);
 751
 752         return error;
 753 }
 754
 755 /*
 756  * Convert a local file to an extents file.
 757  * This code is out of bounds for data forks of regular files,
 758  * since the file data needs to get logged so things will stay consistent.
 759  * (The bmap-level manipulations are ok, though).
 760  */
 761 void
 762 xfs_bmap_local_to_extents_empty(
 763         struct xfs_trans        *tp,
 764         struct xfs_inode        *ip,
 765         int                     whichfork)
 766 {
 767         struct xfs_ifork        *ifp = xfs_ifork_ptr(ip, whichfork);
 768
 769         ASSERT(whichfork != XFS_COW_FORK);
 770         ASSERT(ifp->if_format == XFS_DINODE_FMT_LOCAL);
 771         ASSERT(ifp->if_bytes == 0);
 772         ASSERT(ifp->if_nextents == 0);
 773
 774         xfs_bmap_forkoff_reset(ip, whichfork);
 775         ifp->if_data = NULL;
 776         ifp->if_height = 0;
 777         ifp->if_format = XFS_DINODE_FMT_EXTENTS;
 778         xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
 779 }
 780
 781
 782 int                                     /* error */
 783 xfs_bmap_local_to_extents(
 784         xfs_trans_t     *tp,            /* transaction pointer */
 785         xfs_inode_t     *ip,            /* incore inode pointer */
 786         xfs_extlen_t    total,          /* total blocks needed by transaction */
 787         int             *logflagsp,     /* inode logging flags */
 788         int             whichfork,
 789         void            (*init_fn)(struct xfs_trans *tp,
 790                                    struct xfs_buf *bp,
 791                                    struct xfs_inode *ip,
 792                                    struct xfs_ifork *ifp, void *priv),
 793         void            *priv)
 794 {
 795         int             error = 0;
 796         int             flags;          /* logging flags returned */
 797         struct xfs_ifork *ifp;          /* inode fork pointer */
 798         xfs_alloc_arg_t args;           /* allocation arguments */
 799         struct xfs_buf  *bp;            /* buffer for extent block */
 800         struct xfs_bmbt_irec rec;
 801         struct xfs_iext_cursor icur;
 802
 803         /*
 804          * We don't want to deal with the case of keeping inode data inline yet.
 805          * So sending the data fork of a regular inode is invalid.
 806          */
 807         ASSERT(!(S_ISREG(VFS_I(ip)->i_mode) && whichfork == XFS_DATA_FORK));
 808         ifp = xfs_ifork_ptr(ip, whichfork);
 809         ASSERT(ifp->if_format == XFS_DINODE_FMT_LOCAL);
 810
 811         if (!ifp->if_bytes) {
 812                 xfs_bmap_local_to_extents_empty(tp, ip, whichfork);
 813                 flags = XFS_ILOG_CORE;
 814                 goto done;
 815         }
 816
 817         flags = 0;
 818         error = 0;
 819         memset(&args, 0, sizeof(args));
 820         args.tp = tp;
 821         args.mp = ip->i_mount;
 822         args.total = total;
 823         args.minlen = args.maxlen = args.prod = 1;
 824         xfs_rmap_ino_owner(&args.oinfo, ip->i_ino, whichfork, 0);
 825
 826         /*
 827          * Allocate a block.  We know we need only one, since the
 828          * file currently fits in an inode.
 829          */
 830         args.total = total;
 831         args.minlen = args.maxlen = args.prod = 1;
 832         error = xfs_alloc_vextent_start_ag(&args,
 833                         XFS_INO_TO_FSB(args.mp, ip->i_ino));
 834         if (error)
 835                 goto done;
 836
 837         /* Can't fail, the space was reserved. */
 838         ASSERT(args.fsbno != NULLFSBLOCK);
 839         ASSERT(args.len == 1);
 840         error = xfs_trans_get_buf(tp, args.mp->m_ddev_targp,
 841                         XFS_FSB_TO_DADDR(args.mp, args.fsbno),
 842                         args.mp->m_bsize, 0, &bp);
 843         if (error)
 844                 goto done;
 845
 846         /*
 847          * Initialize the block, copy the data and log the remote buffer.
 848          *
 849          * The callout is responsible for logging because the remote format
 850          * might differ from the local format and thus we don't know how much to
 851          * log here. Note that init_fn must also set the buffer log item type
 852          * correctly.
 853          */
 854         init_fn(tp, bp, ip, ifp, priv);
 855
 856         /* account for the change in fork size */
 857         xfs_idata_realloc(ip, -ifp->if_bytes, whichfork);
 858         xfs_bmap_local_to_extents_empty(tp, ip, whichfork);
 859         flags |= XFS_ILOG_CORE;
 860
 861         ifp->if_data = NULL;
 862         ifp->if_height = 0;
 863
 864         rec.br_startoff = 0;
 865         rec.br_startblock = args.fsbno;
 866         rec.br_blockcount = 1;
 867         rec.br_state = XFS_EXT_NORM;
 868         xfs_iext_first(ifp, &icur);
 869         xfs_iext_insert(ip, &icur, &rec, 0);
 870
 871         ifp->if_nextents = 1;
 872         ip->i_nblocks = 1;
 873         xfs_trans_mod_dquot_byino(tp, ip, XFS_TRANS_DQ_BCOUNT, 1L);
 874         flags |= xfs_ilog_fext(whichfork);
 875
 876 done:
 877         *logflagsp = flags;
 878         return error;
 879 }
 880
 881 /*
 882  * Called from xfs_bmap_add_attrfork to handle btree format files.
 883  */
 884 STATIC int                                      /* error */
 885 xfs_bmap_add_attrfork_btree(
 886         xfs_trans_t             *tp,            /* transaction pointer */
 887         xfs_inode_t             *ip,            /* incore inode pointer */
 888         int                     *flags)         /* inode logging flags */
 889 {
 890         struct xfs_btree_block  *block = ip->i_df.if_broot;
 891         struct xfs_btree_cur    *cur;           /* btree cursor */
 892         int                     error;          /* error return value */
 893         xfs_mount_t             *mp;            /* file system mount struct */
 894         int                     stat;           /* newroot status */
 895
 896         mp = ip->i_mount;
 897
 898         if (XFS_BMAP_BMDR_SPACE(block) <= xfs_inode_data_fork_size(ip))
 899                 *flags |= XFS_ILOG_DBROOT;
 900         else {
 901                 cur = xfs_bmbt_init_cursor(mp, tp, ip, XFS_DATA_FORK);
 902                 error = xfs_bmbt_lookup_first(cur, &stat);
 903                 if (error)
 904                         goto error0;
 905                 /* must be at least one entry */
 906                 if (XFS_IS_CORRUPT(mp, stat != 1)) {
 907                         xfs_btree_mark_sick(cur);
 908                         error = -EFSCORRUPTED;
 909                         goto error0;
 910                 }
 911                 if ((error = xfs_btree_new_iroot(cur, flags, &stat)))
 912                         goto error0;
 913                 if (stat == 0) {
 914                         xfs_btree_del_cursor(cur, XFS_BTREE_NOERROR);
 915                         return -ENOSPC;
 916                 }
 917                 cur->bc_bmap.allocated = 0;
 918                 xfs_btree_del_cursor(cur, XFS_BTREE_NOERROR);
 919         }
 920         return 0;
 921 error0:
 922         xfs_btree_del_cursor(cur, XFS_BTREE_ERROR);
 923         return error;
 924 }
 925
 926 /*
 927  * Called from xfs_bmap_add_attrfork to handle extents format files.
 928  */
 929 STATIC int                                      /* error */
 930 xfs_bmap_add_attrfork_extents(
 931         struct xfs_trans        *tp,            /* transaction pointer */
 932         struct xfs_inode        *ip,            /* incore inode pointer */
 933         int                     *flags)         /* inode logging flags */
 934 {
 935         struct xfs_btree_cur    *cur;           /* bmap btree cursor */
 936         int                     error;          /* error return value */
 937
 938         if (ip->i_df.if_nextents * sizeof(struct xfs_bmbt_rec) <=
 939             xfs_inode_data_fork_size(ip))
 940                 return 0;
 941         cur = NULL;
 942         error = xfs_bmap_extents_to_btree(tp, ip, &cur, 0, flags,
 943                                           XFS_DATA_FORK);
 944         if (cur) {
 945                 cur->bc_bmap.allocated = 0;
 946                 xfs_btree_del_cursor(cur, error);
 947         }
 948         return error;
 949 }
 950
 951 /*
 952  * Called from xfs_bmap_add_attrfork to handle local format files. Each
 953  * different data fork content type needs a different callout to do the
 954  * conversion. Some are basic and only require special block initialisation
 955  * callouts for the data formating, others (directories) are so specialised they
 956  * handle everything themselves.
 957  *
 958  * XXX (dgc): investigate whether directory conversion can use the generic
 959  * formatting callout. It should be possible - it's just a very complex
 960  * formatter.
 961  */
 962 STATIC int                                      /* error */
 963 xfs_bmap_add_attrfork_local(
 964         struct xfs_trans        *tp,            /* transaction pointer */
 965         struct xfs_inode        *ip,            /* incore inode pointer */
 966         int                     *flags)         /* inode logging flags */
 967 {
 968         struct xfs_da_args      dargs;          /* args for dir/attr code */
 969
 970         if (ip->i_df.if_bytes <= xfs_inode_data_fork_size(ip))
 971                 return 0;
 972
 973         if (S_ISDIR(VFS_I(ip)->i_mode)) {
 974                 memset(&dargs, 0, sizeof(dargs));
 975                 dargs.geo = ip->i_mount->m_dir_geo;
 976                 dargs.dp = ip;
 977                 dargs.total = dargs.geo->fsbcount;
 978                 dargs.whichfork = XFS_DATA_FORK;
 979                 dargs.trans = tp;
 980                 dargs.owner = ip->i_ino;
 981                 return xfs_dir2_sf_to_block(&dargs);
 982         }
 983
 984         if (S_ISLNK(VFS_I(ip)->i_mode))
 985                 return xfs_bmap_local_to_extents(tp, ip, 1, flags,
 986                                 XFS_DATA_FORK, xfs_symlink_local_to_remote,
 987                                 NULL);
 988
 989         /* should only be called for types that support local format data */
 990         ASSERT(0);
 991         xfs_bmap_mark_sick(ip, XFS_ATTR_FORK);
 992         return -EFSCORRUPTED;
 993 }
 994
 995 /*
 996  * Set an inode attr fork offset based on the format of the data fork.
 997  */
 998 static int
 999 xfs_bmap_set_attrforkoff(
1000         struct xfs_inode        *ip,
1001         int                     size,
1002         int                     *version)
1003 {
1004         int                     default_size = xfs_default_attroffset(ip) >> 3;
1005
1006         switch (ip->i_df.if_format) {
1007         case XFS_DINODE_FMT_DEV:
1008                 ip->i_forkoff = default_size;
1009                 break;
1010         case XFS_DINODE_FMT_LOCAL:
1011         case XFS_DINODE_FMT_EXTENTS:
1012         case XFS_DINODE_FMT_BTREE:
1013                 ip->i_forkoff = xfs_attr_shortform_bytesfit(ip, size);
1014                 if (!ip->i_forkoff)
1015                         ip->i_forkoff = default_size;
1016                 else if (xfs_has_attr2(ip->i_mount) && version)
1017                         *version = 2;
1018                 break;
1019         default:
1020                 ASSERT(0);
1021                 return -EINVAL;
1022         }
1023
1024         return 0;
1025 }
1026
1027 /*
1028  * Convert inode from non-attributed to attributed.  Caller must hold the
1029  * ILOCK_EXCL and the file cannot have an attr fork.
1030  */
1031 int                                             /* error code */
1032 xfs_bmap_add_attrfork(
1033         struct xfs_trans        *tp,
1034         struct xfs_inode        *ip,            /* incore inode pointer */
1035         int                     size,           /* space new attribute needs */
1036         int                     rsvd)           /* xact may use reserved blks */
1037 {
1038         struct xfs_mount        *mp = tp->t_mountp;
1039         int                     version = 1;    /* superblock attr version */
1040         int                     logflags;       /* logging flags */
1041         int                     error;          /* error return value */
1042
1043         xfs_assert_ilocked(ip, XFS_ILOCK_EXCL);
1044         ASSERT(!XFS_NOT_DQATTACHED(mp, ip));
1045         ASSERT(!xfs_inode_has_attr_fork(ip));
1046
1047         xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
1048         error = xfs_bmap_set_attrforkoff(ip, size, &version);
1049         if (error)
1050                 return error;
1051
1052         xfs_ifork_init_attr(ip, XFS_DINODE_FMT_EXTENTS, 0);
1053         logflags = 0;
1054         switch (ip->i_df.if_format) {
1055         case XFS_DINODE_FMT_LOCAL:
1056                 error = xfs_bmap_add_attrfork_local(tp, ip, &logflags);
1057                 break;
1058         case XFS_DINODE_FMT_EXTENTS:
1059                 error = xfs_bmap_add_attrfork_extents(tp, ip, &logflags);
1060                 break;
1061         case XFS_DINODE_FMT_BTREE:
1062                 error = xfs_bmap_add_attrfork_btree(tp, ip, &logflags);
1063                 break;
1064         default:
1065                 error = 0;
1066                 break;
1067         }
1068         if (logflags)
1069                 xfs_trans_log_inode(tp, ip, logflags);
1070         if (error)
1071                 return error;
1072         if (!xfs_has_attr(mp) ||
1073            (!xfs_has_attr2(mp) && version == 2)) {
1074                 bool log_sb = false;
1075
1076                 spin_lock(&mp->m_sb_lock);
1077                 if (!xfs_has_attr(mp)) {
1078                         xfs_add_attr(mp);
1079                         log_sb = true;
1080                 }
1081                 if (!xfs_has_attr2(mp) && version == 2) {
1082                         xfs_add_attr2(mp);
1083                         log_sb = true;
1084                 }
1085                 spin_unlock(&mp->m_sb_lock);
1086                 if (log_sb)
1087                         xfs_log_sb(tp);
1088         }
1089
1090         return 0;
1091 }
1092
1093 /*
1094  * Internal and external extent tree search functions.
1095  */
1096
1097 struct xfs_iread_state {
1098         struct xfs_iext_cursor  icur;
1099         xfs_extnum_t            loaded;
1100 };
1101
1102 int
1103 xfs_bmap_complain_bad_rec(
1104         struct xfs_inode                *ip,
1105         int                             whichfork,
1106         xfs_failaddr_t                  fa,
1107         const struct xfs_bmbt_irec      *irec)
1108 {
1109         struct xfs_mount                *mp = ip->i_mount;
1110         const char                      *forkname;
1111
1112         switch (whichfork) {
1113         case XFS_DATA_FORK:     forkname = "data"; break;
1114         case XFS_ATTR_FORK:     forkname = "attr"; break;
1115         case XFS_COW_FORK:      forkname = "CoW"; break;
1116         default:                forkname = "???"; break;
1117         }
1118
1119         xfs_warn(mp,
1120  "Bmap BTree record corruption in inode 0x%llx %s fork detected at %pS!",
1121                                 ip->i_ino, forkname, fa);
1122         xfs_warn(mp,
1123                 "Offset 0x%llx, start block 0x%llx, block count 0x%llx state 0x%x",
1124                 irec->br_startoff, irec->br_startblock, irec->br_blockcount,
1125                 irec->br_state);
1126
1127         return -EFSCORRUPTED;
1128 }
1129
1130 /* Stuff every bmbt record from this block into the incore extent map. */
1131 static int
1132 xfs_iread_bmbt_block(
1133         struct xfs_btree_cur    *cur,
1134         int                     level,
1135         void                    *priv)
1136 {
1137         struct xfs_iread_state  *ir = priv;
1138         struct xfs_mount        *mp = cur->bc_mp;
1139         struct xfs_inode        *ip = cur->bc_ino.ip;
1140         struct xfs_btree_block  *block;
1141         struct xfs_buf          *bp;
1142         struct xfs_bmbt_rec     *frp;
1143         xfs_extnum_t            num_recs;
1144         xfs_extnum_t            j;
1145         int                     whichfork = cur->bc_ino.whichfork;
1146         struct xfs_ifork        *ifp = xfs_ifork_ptr(ip, whichfork);
1147
1148         block = xfs_btree_get_block(cur, level, &bp);
1149
1150         /* Abort if we find more records than nextents. */
1151         num_recs = xfs_btree_get_numrecs(block);
1152         if (unlikely(ir->loaded + num_recs > ifp->if_nextents)) {
1153                 xfs_warn(ip->i_mount, "corrupt dinode %llu, (btree extents).",
1154                                 (unsigned long long)ip->i_ino);
1155                 xfs_inode_verifier_error(ip, -EFSCORRUPTED, __func__, block,
1156                                 sizeof(*block), __this_address);
1157                 xfs_bmap_mark_sick(ip, whichfork);
1158                 return -EFSCORRUPTED;
1159         }
1160
1161         /* Copy records into the incore cache. */
1162         frp = XFS_BMBT_REC_ADDR(mp, block, 1);
1163         for (j = 0; j < num_recs; j++, frp++, ir->loaded++) {
1164                 struct xfs_bmbt_irec    new;
1165                 xfs_failaddr_t          fa;
1166
1167                 xfs_bmbt_disk_get_all(frp, &new);
1168                 fa = xfs_bmap_validate_extent(ip, whichfork, &new);
1169                 if (fa) {
1170                         xfs_inode_verifier_error(ip, -EFSCORRUPTED,
1171                                         "xfs_iread_extents(2)", frp,
1172                                         sizeof(*frp), fa);
1173                         xfs_bmap_mark_sick(ip, whichfork);
1174                         return xfs_bmap_complain_bad_rec(ip, whichfork, fa,
1175                                         &new);
1176                 }
1177                 xfs_iext_insert(ip, &ir->icur, &new,
1178                                 xfs_bmap_fork_to_state(whichfork));
1179                 trace_xfs_read_extent(ip, &ir->icur,
1180                                 xfs_bmap_fork_to_state(whichfork), _THIS_IP_);
1181                 xfs_iext_next(ifp, &ir->icur);
1182         }
1183
1184         return 0;
1185 }
1186
1187 /*
1188  * Read in extents from a btree-format inode.
1189  */
1190 int
1191 xfs_iread_extents(
1192         struct xfs_trans        *tp,
1193         struct xfs_inode        *ip,
1194         int                     whichfork)
1195 {
1196         struct xfs_iread_state  ir;
1197         struct xfs_ifork        *ifp = xfs_ifork_ptr(ip, whichfork);
1198         struct xfs_mount        *mp = ip->i_mount;
1199         struct xfs_btree_cur    *cur;
1200         int                     error;
1201
1202         if (!xfs_need_iread_extents(ifp))
1203                 return 0;
1204
1205         xfs_assert_ilocked(ip, XFS_ILOCK_EXCL);
1206
1207         ir.loaded = 0;
1208         xfs_iext_first(ifp, &ir.icur);
1209         cur = xfs_bmbt_init_cursor(mp, tp, ip, whichfork);
1210         error = xfs_btree_visit_blocks(cur, xfs_iread_bmbt_block,
1211                         XFS_BTREE_VISIT_RECORDS, &ir);
1212         xfs_btree_del_cursor(cur, error);
1213         if (error)
1214                 goto out;
1215
1216         if (XFS_IS_CORRUPT(mp, ir.loaded != ifp->if_nextents)) {
1217                 xfs_bmap_mark_sick(ip, whichfork);
1218                 error = -EFSCORRUPTED;
1219                 goto out;
1220         }
1221         ASSERT(ir.loaded == xfs_iext_count(ifp));
1222         /*
1223          * Use release semantics so that we can use acquire semantics in
1224          * xfs_need_iread_extents and be guaranteed to see a valid mapping tree
1225          * after that load.
1226          */
1227         smp_store_release(&ifp->if_needextents, 0);
1228         return 0;
1229 out:
1230         if (xfs_metadata_is_sick(error))
1231                 xfs_bmap_mark_sick(ip, whichfork);
1232         xfs_iext_destroy(ifp);
1233         return error;
1234 }
1235
1236 /*
1237  * Returns the relative block number of the first unused block(s) in the given
1238  * fork with at least "len" logically contiguous blocks free.  This is the
1239  * lowest-address hole if the fork has holes, else the first block past the end
1240  * of fork.  Return 0 if the fork is currently local (in-inode).
1241  */
1242 int                                             /* error */
1243 xfs_bmap_first_unused(
1244         struct xfs_trans        *tp,            /* transaction pointer */
1245         struct xfs_inode        *ip,            /* incore inode */
1246         xfs_extlen_t            len,            /* size of hole to find */
1247         xfs_fileoff_t           *first_unused,  /* unused block */
1248         int                     whichfork)      /* data or attr fork */
1249 {
1250         struct xfs_ifork        *ifp = xfs_ifork_ptr(ip, whichfork);
1251         struct xfs_bmbt_irec    got;
1252         struct xfs_iext_cursor  icur;
1253         xfs_fileoff_t           lastaddr = 0;
1254         xfs_fileoff_t           lowest, max;
1255         int                     error;
1256
1257         if (ifp->if_format == XFS_DINODE_FMT_LOCAL) {
1258                 *first_unused = 0;
1259                 return 0;
1260         }
1261
1262         ASSERT(xfs_ifork_has_extents(ifp));
1263
1264         error = xfs_iread_extents(tp, ip, whichfork);
1265         if (error)
1266                 return error;
1267
1268         lowest = max = *first_unused;
1269         for_each_xfs_iext(ifp, &icur, &got) {
1270                 /*
1271                  * See if the hole before this extent will work.
1272                  */
1273                 if (got.br_startoff >= lowest + len &&
1274                     got.br_startoff - max >= len)
1275                         break;
1276                 lastaddr = got.br_startoff + got.br_blockcount;
1277                 max = XFS_FILEOFF_MAX(lastaddr, lowest);
1278         }
1279
1280         *first_unused = max;
1281         return 0;
1282 }
1283
1284 /*
1285  * Returns the file-relative block number of the last block - 1 before
1286  * last_block (input value) in the file.
1287  * This is not based on i_size, it is based on the extent records.
1288  * Returns 0 for local files, as they do not have extent records.
1289  */
1290 int                                             /* error */
1291 xfs_bmap_last_before(
1292         struct xfs_trans        *tp,            /* transaction pointer */
1293         struct xfs_inode        *ip,            /* incore inode */
1294         xfs_fileoff_t           *last_block,    /* last block */
1295         int                     whichfork)      /* data or attr fork */
1296 {
1297         struct xfs_ifork        *ifp = xfs_ifork_ptr(ip, whichfork);
1298         struct xfs_bmbt_irec    got;
1299         struct xfs_iext_cursor  icur;
1300         int                     error;
1301
1302         switch (ifp->if_format) {
1303         case XFS_DINODE_FMT_LOCAL:
1304                 *last_block = 0;
1305                 return 0;
1306         case XFS_DINODE_FMT_BTREE:
1307         case XFS_DINODE_FMT_EXTENTS:
1308                 break;
1309         default:
1310                 ASSERT(0);
1311                 xfs_bmap_mark_sick(ip, whichfork);
1312                 return -EFSCORRUPTED;
1313         }
1314
1315         error = xfs_iread_extents(tp, ip, whichfork);
1316         if (error)
1317                 return error;
1318
1319         if (!xfs_iext_lookup_extent_before(ip, ifp, last_block, &icur, &got))
1320                 *last_block = 0;
1321         return 0;
1322 }
1323
1324 int
1325 xfs_bmap_last_extent(
1326         struct xfs_trans        *tp,
1327         struct xfs_inode        *ip,
1328         int                     whichfork,
1329         struct xfs_bmbt_irec    *rec,
1330         int                     *is_empty)
1331 {
1332         struct xfs_ifork        *ifp = xfs_ifork_ptr(ip, whichfork);
1333         struct xfs_iext_cursor  icur;
1334         int                     error;
1335
1336         error = xfs_iread_extents(tp, ip, whichfork);
1337         if (error)
1338                 return error;
1339
1340         xfs_iext_last(ifp, &icur);
1341         if (!xfs_iext_get_extent(ifp, &icur, rec))
1342                 *is_empty = 1;
1343         else
1344                 *is_empty = 0;
1345         return 0;
1346 }
1347
1348 /*
1349  * Check the last inode extent to determine whether this allocation will result
1350  * in blocks being allocated at the end of the file. When we allocate new data
1351  * blocks at the end of the file which do not start at the previous data block,
1352  * we will try to align the new blocks at stripe unit boundaries.
1353  *
1354  * Returns 1 in bma->aeof if the file (fork) is empty as any new write will be
1355  * at, or past the EOF.
1356  */
1357 STATIC int
1358 xfs_bmap_isaeof(
1359         struct xfs_bmalloca     *bma,
1360         int                     whichfork)
1361 {
1362         struct xfs_bmbt_irec    rec;
1363         int                     is_empty;
1364         int                     error;
1365
1366         bma->aeof = false;
1367         error = xfs_bmap_last_extent(NULL, bma->ip, whichfork, &rec,
1368                                      &is_empty);
1369         if (error)
1370                 return error;
1371
1372         if (is_empty) {
1373                 bma->aeof = true;
1374                 return 0;
1375         }
1376
1377         /*
1378          * Check if we are allocation or past the last extent, or at least into
1379          * the last delayed allocated extent.
1380          */
1381         bma->aeof = bma->offset >= rec.br_startoff + rec.br_blockcount ||
1382                 (bma->offset >= rec.br_startoff &&
1383                  isnullstartblock(rec.br_startblock));
1384         return 0;
1385 }
1386
1387 /*
1388  * Returns the file-relative block number of the first block past eof in
1389  * the file.  This is not based on i_size, it is based on the extent records.
1390  * Returns 0 for local files, as they do not have extent records.
1391  */
1392 int
1393 xfs_bmap_last_offset(
1394         struct xfs_inode        *ip,
1395         xfs_fileoff_t           *last_block,
1396         int                     whichfork)
1397 {
1398         struct xfs_ifork        *ifp = xfs_ifork_ptr(ip, whichfork);
1399         struct xfs_bmbt_irec    rec;
1400         int                     is_empty;
1401         int                     error;
1402
1403         *last_block = 0;
1404
1405         if (ifp->if_format == XFS_DINODE_FMT_LOCAL)
1406                 return 0;
1407
1408         if (XFS_IS_CORRUPT(ip->i_mount, !xfs_ifork_has_extents(ifp))) {
1409                 xfs_bmap_mark_sick(ip, whichfork);
1410                 return -EFSCORRUPTED;
1411         }
1412
1413         error = xfs_bmap_last_extent(NULL, ip, whichfork, &rec, &is_empty);
1414         if (error || is_empty)
1415                 return error;
1416
1417         *last_block = rec.br_startoff + rec.br_blockcount;
1418         return 0;
1419 }
1420
1421 /*
1422  * Extent tree manipulation functions used during allocation.
1423  */
1424
1425 /*
1426  * Convert a delayed allocation to a real allocation.
1427  */
1428 STATIC int                              /* error */
1429 xfs_bmap_add_extent_delay_real(
1430         struct xfs_bmalloca     *bma,
1431         int                     whichfork)
1432 {
1433         struct xfs_mount        *mp = bma->ip->i_mount;
1434         struct xfs_ifork        *ifp = xfs_ifork_ptr(bma->ip, whichfork);
1435         struct xfs_bmbt_irec    *new = &bma->got;
1436         int                     error;  /* error return value */
1437         int                     i;      /* temp state */
1438         xfs_fileoff_t           new_endoff;     /* end offset of new entry */
1439         xfs_bmbt_irec_t         r[3];   /* neighbor extent entries */
1440                                         /* left is 0, right is 1, prev is 2 */
1441         int                     rval=0; /* return value (logging flags) */
1442         uint32_t                state = xfs_bmap_fork_to_state(whichfork);
1443         xfs_filblks_t           da_new; /* new count del alloc blocks used */
1444         xfs_filblks_t           da_old; /* old count del alloc blocks used */
1445         xfs_filblks_t           temp=0; /* value for da_new calculations */
1446         int                     tmp_rval;       /* partial logging flags */
1447         struct xfs_bmbt_irec    old;
1448
1449         ASSERT(whichfork != XFS_ATTR_FORK);
1450         ASSERT(!isnullstartblock(new->br_startblock));
1451         ASSERT(!bma->cur || (bma->cur->bc_flags & XFS_BTREE_BMBT_WASDEL));
1452
1453         XFS_STATS_INC(mp, xs_add_exlist);
1454
1455 #define LEFT            r[0]
1456 #define RIGHT           r[1]
1457 #define PREV            r[2]
1458
1459         /*
1460          * Set up a bunch of variables to make the tests simpler.
1461          */
1462         xfs_iext_get_extent(ifp, &bma->icur, &PREV);
1463         new_endoff = new->br_startoff + new->br_blockcount;
1464         ASSERT(isnullstartblock(PREV.br_startblock));
1465         ASSERT(PREV.br_startoff <= new->br_startoff);
1466         ASSERT(PREV.br_startoff + PREV.br_blockcount >= new_endoff);
1467
1468         da_old = startblockval(PREV.br_startblock);
1469         da_new = 0;
1470
1471         /*
1472          * Set flags determining what part of the previous delayed allocation
1473          * extent is being replaced by a real allocation.
1474          */
1475         if (PREV.br_startoff == new->br_startoff)
1476                 state |= BMAP_LEFT_FILLING;
1477         if (PREV.br_startoff + PREV.br_blockcount == new_endoff)
1478                 state |= BMAP_RIGHT_FILLING;
1479
1480         /*
1481          * Check and set flags if this segment has a left neighbor.
1482          * Don't set contiguous if the combined extent would be too large.
1483          */
1484         if (xfs_iext_peek_prev_extent(ifp, &bma->icur, &LEFT)) {
1485                 state |= BMAP_LEFT_VALID;
1486                 if (isnullstartblock(LEFT.br_startblock))
1487                         state |= BMAP_LEFT_DELAY;
1488         }
1489
1490         if ((state & BMAP_LEFT_VALID) && !(state & BMAP_LEFT_DELAY) &&
1491             LEFT.br_startoff + LEFT.br_blockcount == new->br_startoff &&
1492             LEFT.br_startblock + LEFT.br_blockcount == new->br_startblock &&
1493             LEFT.br_state == new->br_state &&
1494             LEFT.br_blockcount + new->br_blockcount <= XFS_MAX_BMBT_EXTLEN)
1495                 state |= BMAP_LEFT_CONTIG;
1496
1497         /*
1498          * Check and set flags if this segment has a right neighbor.
1499          * Don't set contiguous if the combined extent would be too large.
1500          * Also check for all-three-contiguous being too large.
1501          */
1502         if (xfs_iext_peek_next_extent(ifp, &bma->icur, &RIGHT)) {
1503                 state |= BMAP_RIGHT_VALID;
1504                 if (isnullstartblock(RIGHT.br_startblock))
1505                         state |= BMAP_RIGHT_DELAY;
1506         }
1507
1508         if ((state & BMAP_RIGHT_VALID) && !(state & BMAP_RIGHT_DELAY) &&
1509             new_endoff == RIGHT.br_startoff &&
1510             new->br_startblock + new->br_blockcount == RIGHT.br_startblock &&
1511             new->br_state == RIGHT.br_state &&
1512             new->br_blockcount + RIGHT.br_blockcount <= XFS_MAX_BMBT_EXTLEN &&
1513             ((state & (BMAP_LEFT_CONTIG | BMAP_LEFT_FILLING |
1514                        BMAP_RIGHT_FILLING)) !=
1515                       (BMAP_LEFT_CONTIG | BMAP_LEFT_FILLING |
1516                        BMAP_RIGHT_FILLING) ||
1517              LEFT.br_blockcount + new->br_blockcount + RIGHT.br_blockcount
1518                         <= XFS_MAX_BMBT_EXTLEN))
1519                 state |= BMAP_RIGHT_CONTIG;
1520
1521         error = 0;
1522         /*
1523          * Switch out based on the FILLING and CONTIG state bits.
1524          */
1525         switch (state & (BMAP_LEFT_FILLING | BMAP_LEFT_CONTIG |
1526                          BMAP_RIGHT_FILLING | BMAP_RIGHT_CONTIG)) {
1527         case BMAP_LEFT_FILLING | BMAP_LEFT_CONTIG |
1528              BMAP_RIGHT_FILLING | BMAP_RIGHT_CONTIG:
1529                 /*
1530                  * Filling in all of a previously delayed allocation extent.
1531                  * The left and right neighbors are both contiguous with new.
1532                  */
1533                 LEFT.br_blockcount += PREV.br_blockcount + RIGHT.br_blockcount;
1534
1535                 xfs_iext_remove(bma->ip, &bma->icur, state);
1536                 xfs_iext_remove(bma->ip, &bma->icur, state);
1537                 xfs_iext_prev(ifp, &bma->icur);
1538                 xfs_iext_update_extent(bma->ip, state, &bma->icur, &LEFT);
1539                 ifp->if_nextents--;
1540
1541                 if (bma->cur == NULL)
1542                         rval = XFS_ILOG_CORE | XFS_ILOG_DEXT;
1543                 else {
1544                         rval = XFS_ILOG_CORE;
1545                         error = xfs_bmbt_lookup_eq(bma->cur, &RIGHT, &i);
1546                         if (error)
1547                                 goto done;
1548                         if (XFS_IS_CORRUPT(mp, i != 1)) {
1549                                 xfs_btree_mark_sick(bma->cur);
1550                                 error = -EFSCORRUPTED;
1551                                 goto done;
1552                         }
1553                         error = xfs_btree_delete(bma->cur, &i);
1554                         if (error)
1555                                 goto done;
1556                         if (XFS_IS_CORRUPT(mp, i != 1)) {
1557                                 xfs_btree_mark_sick(bma->cur);
1558                                 error = -EFSCORRUPTED;
1559                                 goto done;
1560                         }
1561                         error = xfs_btree_decrement(bma->cur, 0, &i);
1562                         if (error)
1563                                 goto done;
1564                         if (XFS_IS_CORRUPT(mp, i != 1)) {
1565                                 xfs_btree_mark_sick(bma->cur);
1566                                 error = -EFSCORRUPTED;
1567                                 goto done;
1568                         }
1569                         error = xfs_bmbt_update(bma->cur, &LEFT);
1570                         if (error)
1571                                 goto done;
1572                 }
1573                 ASSERT(da_new <= da_old);
1574                 break;
1575
1576         case BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING | BMAP_LEFT_CONTIG:
1577                 /*
1578                  * Filling in all of a previously delayed allocation extent.
1579                  * The left neighbor is contiguous, the right is not.
1580                  */
1581                 old = LEFT;
1582                 LEFT.br_blockcount += PREV.br_blockcount;
1583
1584                 xfs_iext_remove(bma->ip, &bma->icur, state);
1585                 xfs_iext_prev(ifp, &bma->icur);
1586                 xfs_iext_update_extent(bma->ip, state, &bma->icur, &LEFT);
1587
1588                 if (bma->cur == NULL)
1589                         rval = XFS_ILOG_DEXT;
1590                 else {
1591                         rval = 0;
1592                         error = xfs_bmbt_lookup_eq(bma->cur, &old, &i);
1593                         if (error)
1594                                 goto done;
1595                         if (XFS_IS_CORRUPT(mp, i != 1)) {
1596                                 xfs_btree_mark_sick(bma->cur);
1597                                 error = -EFSCORRUPTED;
1598                                 goto done;
1599                         }
1600                         error = xfs_bmbt_update(bma->cur, &LEFT);
1601                         if (error)
1602                                 goto done;
1603                 }
1604                 ASSERT(da_new <= da_old);
1605                 break;
1606
1607         case BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING | BMAP_RIGHT_CONTIG:
1608                 /*
1609                  * Filling in all of a previously delayed allocation extent.
1610                  * The right neighbor is contiguous, the left is not. Take care
1611                  * with delay -> unwritten extent allocation here because the
1612                  * delalloc record we are overwriting is always written.
1613                  */
1614                 PREV.br_startblock = new->br_startblock;
1615                 PREV.br_blockcount += RIGHT.br_blockcount;
1616                 PREV.br_state = new->br_state;
1617
1618                 xfs_iext_next(ifp, &bma->icur);
1619                 xfs_iext_remove(bma->ip, &bma->icur, state);
1620                 xfs_iext_prev(ifp, &bma->icur);
1621                 xfs_iext_update_extent(bma->ip, state, &bma->icur, &PREV);
1622
1623                 if (bma->cur == NULL)
1624                         rval = XFS_ILOG_DEXT;
1625                 else {
1626                         rval = 0;
1627                         error = xfs_bmbt_lookup_eq(bma->cur, &RIGHT, &i);
1628                         if (error)
1629                                 goto done;
1630                         if (XFS_IS_CORRUPT(mp, i != 1)) {
1631                                 xfs_btree_mark_sick(bma->cur);
1632                                 error = -EFSCORRUPTED;
1633                                 goto done;
1634                         }
1635                         error = xfs_bmbt_update(bma->cur, &PREV);
1636                         if (error)
1637                                 goto done;
1638                 }
1639                 ASSERT(da_new <= da_old);
1640                 break;
1641
1642         case BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING:
1643                 /*
1644                  * Filling in all of a previously delayed allocation extent.
1645                  * Neither the left nor right neighbors are contiguous with
1646                  * the new one.
1647                  */
1648                 PREV.br_startblock = new->br_startblock;
1649                 PREV.br_state = new->br_state;
1650                 xfs_iext_update_extent(bma->ip, state, &bma->icur, &PREV);
1651                 ifp->if_nextents++;
1652
1653                 if (bma->cur == NULL)
1654                         rval = XFS_ILOG_CORE | XFS_ILOG_DEXT;
1655                 else {
1656                         rval = XFS_ILOG_CORE;
1657                         error = xfs_bmbt_lookup_eq(bma->cur, new, &i);
1658                         if (error)
1659                                 goto done;
1660                         if (XFS_IS_CORRUPT(mp, i != 0)) {
1661                                 xfs_btree_mark_sick(bma->cur);
1662                                 error = -EFSCORRUPTED;
1663                                 goto done;
1664                         }
1665                         error = xfs_btree_insert(bma->cur, &i);
1666                         if (error)
1667                                 goto done;
1668                         if (XFS_IS_CORRUPT(mp, i != 1)) {
1669                                 xfs_btree_mark_sick(bma->cur);
1670                                 error = -EFSCORRUPTED;
1671                                 goto done;
1672                         }
1673                 }
1674                 ASSERT(da_new <= da_old);
1675                 break;
1676
1677         case BMAP_LEFT_FILLING | BMAP_LEFT_CONTIG:
1678                 /*
1679                  * Filling in the first part of a previous delayed allocation.
1680                  * The left neighbor is contiguous.
1681                  */
1682                 old = LEFT;
1683                 temp = PREV.br_blockcount - new->br_blockcount;
1684                 da_new = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(bma->ip, temp),
1685                                 startblockval(PREV.br_startblock));
1686
1687                 LEFT.br_blockcount += new->br_blockcount;
1688
1689                 PREV.br_blockcount = temp;
1690                 PREV.br_startoff += new->br_blockcount;
1691                 PREV.br_startblock = nullstartblock(da_new);
1692
1693                 xfs_iext_update_extent(bma->ip, state, &bma->icur, &PREV);
1694                 xfs_iext_prev(ifp, &bma->icur);
1695                 xfs_iext_update_extent(bma->ip, state, &bma->icur, &LEFT);
1696
1697                 if (bma->cur == NULL)
1698                         rval = XFS_ILOG_DEXT;
1699                 else {
1700                         rval = 0;
1701                         error = xfs_bmbt_lookup_eq(bma->cur, &old, &i);
1702                         if (error)
1703                                 goto done;
1704                         if (XFS_IS_CORRUPT(mp, i != 1)) {
1705                                 xfs_btree_mark_sick(bma->cur);
1706                                 error = -EFSCORRUPTED;
1707                                 goto done;
1708                         }
1709                         error = xfs_bmbt_update(bma->cur, &LEFT);
1710                         if (error)
1711                                 goto done;
1712                 }
1713                 ASSERT(da_new <= da_old);
1714                 break;
1715
1716         case BMAP_LEFT_FILLING:
1717                 /*
1718                  * Filling in the first part of a previous delayed allocation.
1719                  * The left neighbor is not contiguous.
1720                  */
1721                 xfs_iext_update_extent(bma->ip, state, &bma->icur, new);
1722                 ifp->if_nextents++;
1723
1724                 if (bma->cur == NULL)
1725                         rval = XFS_ILOG_CORE | XFS_ILOG_DEXT;
1726                 else {
1727                         rval = XFS_ILOG_CORE;
1728                         error = xfs_bmbt_lookup_eq(bma->cur, new, &i);
1729                         if (error)
1730                                 goto done;
1731                         if (XFS_IS_CORRUPT(mp, i != 0)) {
1732                                 xfs_btree_mark_sick(bma->cur);
1733                                 error = -EFSCORRUPTED;
1734                                 goto done;
1735                         }
1736                         error = xfs_btree_insert(bma->cur, &i);
1737                         if (error)
1738                                 goto done;
1739                         if (XFS_IS_CORRUPT(mp, i != 1)) {
1740                                 xfs_btree_mark_sick(bma->cur);
1741                                 error = -EFSCORRUPTED;
1742                                 goto done;
1743                         }
1744                 }
1745
1746                 if (xfs_bmap_needs_btree(bma->ip, whichfork)) {
1747                         error = xfs_bmap_extents_to_btree(bma->tp, bma->ip,
1748                                         &bma->cur, 1, &tmp_rval, whichfork);
1749                         rval |= tmp_rval;
1750                         if (error)
1751                                 goto done;
1752                 }
1753
1754                 temp = PREV.br_blockcount - new->br_blockcount;
1755                 da_new = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(bma->ip, temp),
1756                         startblockval(PREV.br_startblock) -
1757                         (bma->cur ? bma->cur->bc_bmap.allocated : 0));
1758
1759                 PREV.br_startoff = new_endoff;
1760                 PREV.br_blockcount = temp;
1761                 PREV.br_startblock = nullstartblock(da_new);
1762                 xfs_iext_next(ifp, &bma->icur);
1763                 xfs_iext_insert(bma->ip, &bma->icur, &PREV, state);
1764                 xfs_iext_prev(ifp, &bma->icur);
1765                 break;
1766
1767         case BMAP_RIGHT_FILLING | BMAP_RIGHT_CONTIG:
1768                 /*
1769                  * Filling in the last part of a previous delayed allocation.
1770                  * The right neighbor is contiguous with the new allocation.
1771                  */
1772                 old = RIGHT;
1773                 RIGHT.br_startoff = new->br_startoff;
1774                 RIGHT.br_startblock = new->br_startblock;
1775                 RIGHT.br_blockcount += new->br_blockcount;
1776
1777                 if (bma->cur == NULL)
1778                         rval = XFS_ILOG_DEXT;
1779                 else {
1780                         rval = 0;
1781                         error = xfs_bmbt_lookup_eq(bma->cur, &old, &i);
1782                         if (error)
1783                                 goto done;
1784                         if (XFS_IS_CORRUPT(mp, i != 1)) {
1785                                 xfs_btree_mark_sick(bma->cur);
1786                                 error = -EFSCORRUPTED;
1787                                 goto done;
1788                         }
1789                         error = xfs_bmbt_update(bma->cur, &RIGHT);
1790                         if (error)
1791                                 goto done;
1792                 }
1793
1794                 temp = PREV.br_blockcount - new->br_blockcount;
1795                 da_new = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(bma->ip, temp),
1796                         startblockval(PREV.br_startblock));
1797
1798                 PREV.br_blockcount = temp;
1799                 PREV.br_startblock = nullstartblock(da_new);
1800
1801                 xfs_iext_update_extent(bma->ip, state, &bma->icur, &PREV);
1802                 xfs_iext_next(ifp, &bma->icur);
1803                 xfs_iext_update_extent(bma->ip, state, &bma->icur, &RIGHT);
1804                 ASSERT(da_new <= da_old);
1805                 break;
1806
1807         case BMAP_RIGHT_FILLING:
1808                 /*
1809                  * Filling in the last part of a previous delayed allocation.
1810                  * The right neighbor is not contiguous.
1811                  */
1812                 xfs_iext_update_extent(bma->ip, state, &bma->icur, new);
1813                 ifp->if_nextents++;
1814
1815                 if (bma->cur == NULL)
1816                         rval = XFS_ILOG_CORE | XFS_ILOG_DEXT;
1817                 else {
1818                         rval = XFS_ILOG_CORE;
1819                         error = xfs_bmbt_lookup_eq(bma->cur, new, &i);
1820                         if (error)
1821                                 goto done;
1822                         if (XFS_IS_CORRUPT(mp, i != 0)) {
1823                                 xfs_btree_mark_sick(bma->cur);
1824                                 error = -EFSCORRUPTED;
1825                                 goto done;
1826                         }
1827                         error = xfs_btree_insert(bma->cur, &i);
1828                         if (error)
1829                                 goto done;
1830                         if (XFS_IS_CORRUPT(mp, i != 1)) {
1831                                 xfs_btree_mark_sick(bma->cur);
1832                                 error = -EFSCORRUPTED;
1833                                 goto done;
1834                         }
1835                 }
1836
1837                 if (xfs_bmap_needs_btree(bma->ip, whichfork)) {
1838                         error = xfs_bmap_extents_to_btree(bma->tp, bma->ip,
1839                                 &bma->cur, 1, &tmp_rval, whichfork);
1840                         rval |= tmp_rval;
1841                         if (error)
1842                                 goto done;
1843                 }
1844
1845                 temp = PREV.br_blockcount - new->br_blockcount;
1846                 da_new = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(bma->ip, temp),
1847                         startblockval(PREV.br_startblock) -
1848                         (bma->cur ? bma->cur->bc_bmap.allocated : 0));
1849
1850                 PREV.br_startblock = nullstartblock(da_new);
1851                 PREV.br_blockcount = temp;
1852                 xfs_iext_insert(bma->ip, &bma->icur, &PREV, state);
1853                 xfs_iext_next(ifp, &bma->icur);
1854                 ASSERT(da_new <= da_old);
1855                 break;
1856
1857         case 0:
1858                 /*
1859                  * Filling in the middle part of a previous delayed allocation.
1860                  * Contiguity is impossible here.
1861                  * This case is avoided almost all the time.
1862                  *
1863                  * We start with a delayed allocation:
1864                  *
1865                  * +ddddddddddddddddddddddddddddddddddddddddddddddddddddddd+
1866                  *  PREV @ idx
1867                  *
1868                  * and we are allocating:
1869                  *                     +rrrrrrrrrrrrrrrrr+
1870                  *                            new
1871                  *
1872                  * and we set it up for insertion as:
1873                  * +ddddddddddddddddddd+rrrrrrrrrrrrrrrrr+ddddddddddddddddd+
1874                  *                            new
1875                  *  PREV @ idx          LEFT              RIGHT
1876                  *                      inserted at idx + 1
1877                  */
1878                 old = PREV;
1879
1880                 /* LEFT is the new middle */
1881                 LEFT = *new;
1882
1883                 /* RIGHT is the new right */
1884                 RIGHT.br_state = PREV.br_state;
1885                 RIGHT.br_startoff = new_endoff;
1886                 RIGHT.br_blockcount =
1887                         PREV.br_startoff + PREV.br_blockcount - new_endoff;
1888                 RIGHT.br_startblock =
1889                         nullstartblock(xfs_bmap_worst_indlen(bma->ip,
1890                                         RIGHT.br_blockcount));
1891
1892                 /* truncate PREV */
1893                 PREV.br_blockcount = new->br_startoff - PREV.br_startoff;
1894                 PREV.br_startblock =
1895                         nullstartblock(xfs_bmap_worst_indlen(bma->ip,
1896                                         PREV.br_blockcount));
1897                 xfs_iext_update_extent(bma->ip, state, &bma->icur, &PREV);
1898
1899                 xfs_iext_next(ifp, &bma->icur);
1900                 xfs_iext_insert(bma->ip, &bma->icur, &RIGHT, state);
1901                 xfs_iext_insert(bma->ip, &bma->icur, &LEFT, state);
1902                 ifp->if_nextents++;
1903
1904                 if (bma->cur == NULL)
1905                         rval = XFS_ILOG_CORE | XFS_ILOG_DEXT;
1906                 else {
1907                         rval = XFS_ILOG_CORE;
1908                         error = xfs_bmbt_lookup_eq(bma->cur, new, &i);
1909                         if (error)
1910                                 goto done;
1911                         if (XFS_IS_CORRUPT(mp, i != 0)) {
1912                                 xfs_btree_mark_sick(bma->cur);
1913                                 error = -EFSCORRUPTED;
1914                                 goto done;
1915                         }
1916                         error = xfs_btree_insert(bma->cur, &i);
1917                         if (error)
1918                                 goto done;
1919                         if (XFS_IS_CORRUPT(mp, i != 1)) {
1920                                 xfs_btree_mark_sick(bma->cur);
1921                                 error = -EFSCORRUPTED;
1922                                 goto done;
1923                         }
1924                 }
1925
1926                 if (xfs_bmap_needs_btree(bma->ip, whichfork)) {
1927                         error = xfs_bmap_extents_to_btree(bma->tp, bma->ip,
1928                                         &bma->cur, 1, &tmp_rval, whichfork);
1929                         rval |= tmp_rval;
1930                         if (error)
1931                                 goto done;
1932                 }
1933
1934                 da_new = startblockval(PREV.br_startblock) +
1935                          startblockval(RIGHT.br_startblock);
1936                 break;
1937
1938         case BMAP_LEFT_FILLING | BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG:
1939         case BMAP_RIGHT_FILLING | BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG:
1940         case BMAP_LEFT_FILLING | BMAP_RIGHT_CONTIG:
1941         case BMAP_RIGHT_FILLING | BMAP_LEFT_CONTIG:
1942         case BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG:
1943         case BMAP_LEFT_CONTIG:
1944         case BMAP_RIGHT_CONTIG:
1945                 /*
1946                  * These cases are all impossible.
1947                  */
1948                 ASSERT(0);
1949         }
1950
1951         /* add reverse mapping unless caller opted out */
1952         if (!(bma->flags & XFS_BMAPI_NORMAP))
1953                 xfs_rmap_map_extent(bma->tp, bma->ip, whichfork, new);
1954
1955         /* convert to a btree if necessary */
1956         if (xfs_bmap_needs_btree(bma->ip, whichfork)) {
1957                 int     tmp_logflags;   /* partial log flag return val */
1958
1959                 ASSERT(bma->cur == NULL);
1960                 error = xfs_bmap_extents_to_btree(bma->tp, bma->ip,
1961                                 &bma->cur, da_old > 0, &tmp_logflags,
1962                                 whichfork);
1963                 bma->logflags |= tmp_logflags;
1964                 if (error)
1965                         goto done;
1966         }
1967
1968         if (da_new != da_old)
1969                 xfs_mod_delalloc(bma->ip, 0, (int64_t)da_new - da_old);
1970
1971         if (bma->cur) {
1972                 da_new += bma->cur->bc_bmap.allocated;
1973                 bma->cur->bc_bmap.allocated = 0;
1974         }
1975
1976         /* adjust for changes in reserved delayed indirect blocks */
1977         if (da_new < da_old)
1978                 xfs_add_fdblocks(mp, da_old - da_new);
1979         else if (da_new > da_old)
1980                 error = xfs_dec_fdblocks(mp, da_new - da_old, true);
1981
1982         xfs_bmap_check_leaf_extents(bma->cur, bma->ip, whichfork);
1983 done:
1984         if (whichfork != XFS_COW_FORK)
1985                 bma->logflags |= rval;
1986         return error;
1987 #undef  LEFT
1988 #undef  RIGHT
1989 #undef  PREV
1990 }
1991
1992 /*
1993  * Convert an unwritten allocation to a real allocation or vice versa.
1994  */
1995 int                                     /* error */
1996 xfs_bmap_add_extent_unwritten_real(
1997         struct xfs_trans        *tp,
1998         xfs_inode_t             *ip,    /* incore inode pointer */
1999         int                     whichfork,
2000         struct xfs_iext_cursor  *icur,
2001         struct xfs_btree_cur    **curp, /* if *curp is null, not a btree */
2002         xfs_bmbt_irec_t         *new,   /* new data to add to file extents */
2003         int                     *logflagsp) /* inode logging flags */
2004 {
2005         struct xfs_btree_cur    *cur;   /* btree cursor */
2006         int                     error;  /* error return value */
2007         int                     i;      /* temp state */
2008         struct xfs_ifork        *ifp;   /* inode fork pointer */
2009         xfs_fileoff_t           new_endoff;     /* end offset of new entry */
2010         xfs_bmbt_irec_t         r[3];   /* neighbor extent entries */
2011                                         /* left is 0, right is 1, prev is 2 */
2012         int                     rval=0; /* return value (logging flags) */
2013         uint32_t                state = xfs_bmap_fork_to_state(whichfork);
2014         struct xfs_mount        *mp = ip->i_mount;
2015         struct xfs_bmbt_irec    old;
2016
2017         *logflagsp = 0;
2018
2019         cur = *curp;
2020         ifp = xfs_ifork_ptr(ip, whichfork);
2021
2022         ASSERT(!isnullstartblock(new->br_startblock));
2023
2024         XFS_STATS_INC(mp, xs_add_exlist);
2025
2026 #define LEFT            r[0]
2027 #define RIGHT           r[1]
2028 #define PREV            r[2]
2029
2030         /*
2031          * Set up a bunch of variables to make the tests simpler.
2032          */
2033         error = 0;
2034         xfs_iext_get_extent(ifp, icur, &PREV);
2035         ASSERT(new->br_state != PREV.br_state);
2036         new_endoff = new->br_startoff + new->br_blockcount;
2037         ASSERT(PREV.br_startoff <= new->br_startoff);
2038         ASSERT(PREV.br_startoff + PREV.br_blockcount >= new_endoff);
2039
2040         /*
2041          * Set flags determining what part of the previous oldext allocation
2042          * extent is being replaced by a newext allocation.
2043          */
2044         if (PREV.br_startoff == new->br_startoff)
2045                 state |= BMAP_LEFT_FILLING;
2046         if (PREV.br_startoff + PREV.br_blockcount == new_endoff)
2047                 state |= BMAP_RIGHT_FILLING;
2048
2049         /*
2050          * Check and set flags if this segment has a left neighbor.
2051          * Don't set contiguous if the combined extent would be too large.
2052          */
2053         if (xfs_iext_peek_prev_extent(ifp, icur, &LEFT)) {
2054                 state |= BMAP_LEFT_VALID;
2055                 if (isnullstartblock(LEFT.br_startblock))
2056                         state |= BMAP_LEFT_DELAY;
2057         }
2058
2059         if ((state & BMAP_LEFT_VALID) && !(state & BMAP_LEFT_DELAY) &&
2060             LEFT.br_startoff + LEFT.br_blockcount == new->br_startoff &&
2061             LEFT.br_startblock + LEFT.br_blockcount == new->br_startblock &&
2062             LEFT.br_state == new->br_state &&
2063             LEFT.br_blockcount + new->br_blockcount <= XFS_MAX_BMBT_EXTLEN)
2064                 state |= BMAP_LEFT_CONTIG;
2065
2066         /*
2067          * Check and set flags if this segment has a right neighbor.
2068          * Don't set contiguous if the combined extent would be too large.
2069          * Also check for all-three-contiguous being too large.
2070          */
2071         if (xfs_iext_peek_next_extent(ifp, icur, &RIGHT)) {
2072                 state |= BMAP_RIGHT_VALID;
2073                 if (isnullstartblock(RIGHT.br_startblock))
2074                         state |= BMAP_RIGHT_DELAY;
2075         }
2076
2077         if ((state & BMAP_RIGHT_VALID) && !(state & BMAP_RIGHT_DELAY) &&
2078             new_endoff == RIGHT.br_startoff &&
2079             new->br_startblock + new->br_blockcount == RIGHT.br_startblock &&
2080             new->br_state == RIGHT.br_state &&
2081             new->br_blockcount + RIGHT.br_blockcount <= XFS_MAX_BMBT_EXTLEN &&
2082             ((state & (BMAP_LEFT_CONTIG | BMAP_LEFT_FILLING |
2083                        BMAP_RIGHT_FILLING)) !=
2084                       (BMAP_LEFT_CONTIG | BMAP_LEFT_FILLING |
2085                        BMAP_RIGHT_FILLING) ||
2086              LEFT.br_blockcount + new->br_blockcount + RIGHT.br_blockcount
2087                         <= XFS_MAX_BMBT_EXTLEN))
2088                 state |= BMAP_RIGHT_CONTIG;
2089
2090         /*
2091          * Switch out based on the FILLING and CONTIG state bits.
2092          */
2093         switch (state & (BMAP_LEFT_FILLING | BMAP_LEFT_CONTIG |
2094                          BMAP_RIGHT_FILLING | BMAP_RIGHT_CONTIG)) {
2095         case BMAP_LEFT_FILLING | BMAP_LEFT_CONTIG |
2096              BMAP_RIGHT_FILLING | BMAP_RIGHT_CONTIG:
2097                 /*
2098                  * Setting all of a previous oldext extent to newext.
2099                  * The left and right neighbors are both contiguous with new.
2100                  */
2101                 LEFT.br_blockcount += PREV.br_blockcount + RIGHT.br_blockcount;
2102
2103                 xfs_iext_remove(ip, icur, state);
2104                 xfs_iext_remove(ip, icur, state);
2105                 xfs_iext_prev(ifp, icur);
2106                 xfs_iext_update_extent(ip, state, icur, &LEFT);
2107                 ifp->if_nextents -= 2;
2108                 if (cur == NULL)
2109                         rval = XFS_ILOG_CORE | XFS_ILOG_DEXT;
2110                 else {
2111                         rval = XFS_ILOG_CORE;
2112                         error = xfs_bmbt_lookup_eq(cur, &RIGHT, &i);
2113                         if (error)
2114                                 goto done;
2115                         if (XFS_IS_CORRUPT(mp, i != 1)) {
2116                                 xfs_btree_mark_sick(cur);
2117                                 error = -EFSCORRUPTED;
2118                                 goto done;
2119                         }
2120                         if ((error = xfs_btree_delete(cur, &i)))
2121                                 goto done;
2122                         if (XFS_IS_CORRUPT(mp, i != 1)) {
2123                                 xfs_btree_mark_sick(cur);
2124                                 error = -EFSCORRUPTED;
2125                                 goto done;
2126                         }
2127                         if ((error = xfs_btree_decrement(cur, 0, &i)))
2128                                 goto done;
2129                         if (XFS_IS_CORRUPT(mp, i != 1)) {
2130                                 xfs_btree_mark_sick(cur);
2131                                 error = -EFSCORRUPTED;
2132                                 goto done;
2133                         }
2134                         if ((error = xfs_btree_delete(cur, &i)))
2135                                 goto done;
2136                         if (XFS_IS_CORRUPT(mp, i != 1)) {
2137                                 xfs_btree_mark_sick(cur);
2138                                 error = -EFSCORRUPTED;
2139                                 goto done;
2140                         }
2141                         if ((error = xfs_btree_decrement(cur, 0, &i)))
2142                                 goto done;
2143                         if (XFS_IS_CORRUPT(mp, i != 1)) {
2144                                 xfs_btree_mark_sick(cur);
2145                                 error = -EFSCORRUPTED;
2146                                 goto done;
2147                         }
2148                         error = xfs_bmbt_update(cur, &LEFT);
2149                         if (error)
2150                                 goto done;
2151                 }
2152                 break;
2153
2154         case BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING | BMAP_LEFT_CONTIG:
2155                 /*
2156                  * Setting all of a previous oldext extent to newext.
2157                  * The left neighbor is contiguous, the right is not.
2158                  */
2159                 LEFT.br_blockcount += PREV.br_blockcount;
2160
2161                 xfs_iext_remove(ip, icur, state);
2162                 xfs_iext_prev(ifp, icur);
2163                 xfs_iext_update_extent(ip, state, icur, &LEFT);
2164                 ifp->if_nextents--;
2165                 if (cur == NULL)
2166                         rval = XFS_ILOG_CORE | XFS_ILOG_DEXT;
2167                 else {
2168                         rval = XFS_ILOG_CORE;
2169                         error = xfs_bmbt_lookup_eq(cur, &PREV, &i);
2170                         if (error)
2171                                 goto done;
2172                         if (XFS_IS_CORRUPT(mp, i != 1)) {
2173                                 xfs_btree_mark_sick(cur);
2174                                 error = -EFSCORRUPTED;
2175                                 goto done;
2176                         }
2177                         if ((error = xfs_btree_delete(cur, &i)))
2178                                 goto done;
2179                         if (XFS_IS_CORRUPT(mp, i != 1)) {
2180                                 xfs_btree_mark_sick(cur);
2181                                 error = -EFSCORRUPTED;
2182                                 goto done;
2183                         }
2184                         if ((error = xfs_btree_decrement(cur, 0, &i)))
2185                                 goto done;
2186                         if (XFS_IS_CORRUPT(mp, i != 1)) {
2187                                 xfs_btree_mark_sick(cur);
2188                                 error = -EFSCORRUPTED;
2189                                 goto done;
2190                         }
2191                         error = xfs_bmbt_update(cur, &LEFT);
2192                         if (error)
2193                                 goto done;
2194                 }
2195                 break;
2196
2197         case BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING | BMAP_RIGHT_CONTIG:
2198                 /*
2199                  * Setting all of a previous oldext extent to newext.
2200                  * The right neighbor is contiguous, the left is not.
2201                  */
2202                 PREV.br_blockcount += RIGHT.br_blockcount;
2203                 PREV.br_state = new->br_state;
2204
2205                 xfs_iext_next(ifp, icur);
2206                 xfs_iext_remove(ip, icur, state);
2207                 xfs_iext_prev(ifp, icur);
2208                 xfs_iext_update_extent(ip, state, icur, &PREV);
2209                 ifp->if_nextents--;
2210
2211                 if (cur == NULL)
2212                         rval = XFS_ILOG_CORE | XFS_ILOG_DEXT;
2213                 else {
2214                         rval = XFS_ILOG_CORE;
2215                         error = xfs_bmbt_lookup_eq(cur, &RIGHT, &i);
2216                         if (error)
2217                                 goto done;
2218                         if (XFS_IS_CORRUPT(mp, i != 1)) {
2219                                 xfs_btree_mark_sick(cur);
2220                                 error = -EFSCORRUPTED;
2221                                 goto done;
2222                         }
2223                         if ((error = xfs_btree_delete(cur, &i)))
2224                                 goto done;
2225                         if (XFS_IS_CORRUPT(mp, i != 1)) {
2226                                 xfs_btree_mark_sick(cur);
2227                                 error = -EFSCORRUPTED;
2228                                 goto done;
2229                         }
2230                         if ((error = xfs_btree_decrement(cur, 0, &i)))
2231                                 goto done;
2232                         if (XFS_IS_CORRUPT(mp, i != 1)) {
2233                                 xfs_btree_mark_sick(cur);
2234                                 error = -EFSCORRUPTED;
2235                                 goto done;
2236                         }
2237                         error = xfs_bmbt_update(cur, &PREV);
2238                         if (error)
2239                                 goto done;
2240                 }
2241                 break;
2242
2243         case BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING:
2244                 /*
2245                  * Setting all of a previous oldext extent to newext.
2246                  * Neither the left nor right neighbors are contiguous with
2247                  * the new one.
2248                  */
2249                 PREV.br_state = new->br_state;
2250                 xfs_iext_update_extent(ip, state, icur, &PREV);
2251
2252                 if (cur == NULL)
2253                         rval = XFS_ILOG_DEXT;
2254                 else {
2255                         rval = 0;
2256                         error = xfs_bmbt_lookup_eq(cur, new, &i);
2257                         if (error)
2258                                 goto done;
2259                         if (XFS_IS_CORRUPT(mp, i != 1)) {
2260                                 xfs_btree_mark_sick(cur);
2261                                 error = -EFSCORRUPTED;
2262                                 goto done;
2263                         }
2264                         error = xfs_bmbt_update(cur, &PREV);
2265                         if (error)
2266                                 goto done;
2267                 }
2268                 break;
2269
2270         case BMAP_LEFT_FILLING | BMAP_LEFT_CONTIG:
2271                 /*
2272                  * Setting the first part of a previous oldext extent to newext.
2273                  * The left neighbor is contiguous.
2274                  */
2275                 LEFT.br_blockcount += new->br_blockcount;
2276
2277                 old = PREV;
2278                 PREV.br_startoff += new->br_blockcount;
2279                 PREV.br_startblock += new->br_blockcount;
2280                 PREV.br_blockcount -= new->br_blockcount;
2281
2282                 xfs_iext_update_extent(ip, state, icur, &PREV);
2283                 xfs_iext_prev(ifp, icur);
2284                 xfs_iext_update_extent(ip, state, icur, &LEFT);
2285
2286                 if (cur == NULL)
2287                         rval = XFS_ILOG_DEXT;
2288                 else {
2289                         rval = 0;
2290                         error = xfs_bmbt_lookup_eq(cur, &old, &i);
2291                         if (error)
2292                                 goto done;
2293                         if (XFS_IS_CORRUPT(mp, i != 1)) {
2294                                 xfs_btree_mark_sick(cur);
2295                                 error = -EFSCORRUPTED;
2296                                 goto done;
2297                         }
2298                         error = xfs_bmbt_update(cur, &PREV);
2299                         if (error)
2300                                 goto done;
2301                         error = xfs_btree_decrement(cur, 0, &i);
2302                         if (error)
2303                                 goto done;
2304                         error = xfs_bmbt_update(cur, &LEFT);
2305                         if (error)
2306                                 goto done;
2307                 }
2308                 break;
2309
2310         case BMAP_LEFT_FILLING:
2311                 /*
2312                  * Setting the first part of a previous oldext extent to newext.
2313                  * The left neighbor is not contiguous.
2314                  */
2315                 old = PREV;
2316                 PREV.br_startoff += new->br_blockcount;
2317                 PREV.br_startblock += new->br_blockcount;
2318                 PREV.br_blockcount -= new->br_blockcount;
2319
2320                 xfs_iext_update_extent(ip, state, icur, &PREV);
2321                 xfs_iext_insert(ip, icur, new, state);
2322                 ifp->if_nextents++;
2323
2324                 if (cur == NULL)
2325                         rval = XFS_ILOG_CORE | XFS_ILOG_DEXT;
2326                 else {
2327                         rval = XFS_ILOG_CORE;
2328                         error = xfs_bmbt_lookup_eq(cur, &old, &i);
2329                         if (error)
2330                                 goto done;
2331                         if (XFS_IS_CORRUPT(mp, i != 1)) {
2332                                 xfs_btree_mark_sick(cur);
2333                                 error = -EFSCORRUPTED;
2334                                 goto done;
2335                         }
2336                         error = xfs_bmbt_update(cur, &PREV);
2337                         if (error)
2338                                 goto done;
2339                         cur->bc_rec.b = *new;
2340                         if ((error = xfs_btree_insert(cur, &i)))
2341                                 goto done;
2342                         if (XFS_IS_CORRUPT(mp, i != 1)) {
2343                                 xfs_btree_mark_sick(cur);
2344                                 error = -EFSCORRUPTED;
2345                                 goto done;
2346                         }
2347                 }
2348                 break;
2349
2350         case BMAP_RIGHT_FILLING | BMAP_RIGHT_CONTIG:
2351                 /*
2352                  * Setting the last part of a previous oldext extent to newext.
2353                  * The right neighbor is contiguous with the new allocation.
2354                  */
2355                 old = PREV;
2356                 PREV.br_blockcount -= new->br_blockcount;
2357
2358                 RIGHT.br_startoff = new->br_startoff;
2359                 RIGHT.br_startblock = new->br_startblock;
2360                 RIGHT.br_blockcount += new->br_blockcount;
2361
2362                 xfs_iext_update_extent(ip, state, icur, &PREV);
2363                 xfs_iext_next(ifp, icur);
2364                 xfs_iext_update_extent(ip, state, icur, &RIGHT);
2365
2366                 if (cur == NULL)
2367                         rval = XFS_ILOG_DEXT;
2368                 else {
2369                         rval = 0;
2370                         error = xfs_bmbt_lookup_eq(cur, &old, &i);
2371                         if (error)
2372                                 goto done;
2373                         if (XFS_IS_CORRUPT(mp, i != 1)) {
2374                                 xfs_btree_mark_sick(cur);
2375                                 error = -EFSCORRUPTED;
2376                                 goto done;
2377                         }
2378                         error = xfs_bmbt_update(cur, &PREV);
2379                         if (error)
2380                                 goto done;
2381                         error = xfs_btree_increment(cur, 0, &i);
2382                         if (error)
2383                                 goto done;
2384                         error = xfs_bmbt_update(cur, &RIGHT);
2385                         if (error)
2386                                 goto done;
2387                 }
2388                 break;
2389
2390         case BMAP_RIGHT_FILLING:
2391                 /*
2392                  * Setting the last part of a previous oldext extent to newext.
2393                  * The right neighbor is not contiguous.
2394                  */
2395                 old = PREV;
2396                 PREV.br_blockcount -= new->br_blockcount;
2397
2398                 xfs_iext_update_extent(ip, state, icur, &PREV);
2399                 xfs_iext_next(ifp, icur);
2400                 xfs_iext_insert(ip, icur, new, state);
2401                 ifp->if_nextents++;
2402
2403                 if (cur == NULL)
2404                         rval = XFS_ILOG_CORE | XFS_ILOG_DEXT;
2405                 else {
2406                         rval = XFS_ILOG_CORE;
2407                         error = xfs_bmbt_lookup_eq(cur, &old, &i);
2408                         if (error)
2409                                 goto done;
2410                         if (XFS_IS_CORRUPT(mp, i != 1)) {
2411                                 xfs_btree_mark_sick(cur);
2412                                 error = -EFSCORRUPTED;
2413                                 goto done;
2414                         }
2415                         error = xfs_bmbt_update(cur, &PREV);
2416                         if (error)
2417                                 goto done;
2418                         error = xfs_bmbt_lookup_eq(cur, new, &i);
2419                         if (error)
2420                                 goto done;
2421                         if (XFS_IS_CORRUPT(mp, i != 0)) {
2422                                 xfs_btree_mark_sick(cur);
2423                                 error = -EFSCORRUPTED;
2424                                 goto done;
2425                         }
2426                         if ((error = xfs_btree_insert(cur, &i)))
2427                                 goto done;
2428                         if (XFS_IS_CORRUPT(mp, i != 1)) {
2429                                 xfs_btree_mark_sick(cur);
2430                                 error = -EFSCORRUPTED;
2431                                 goto done;
2432                         }
2433                 }
2434                 break;
2435
2436         case 0:
2437                 /*
2438                  * Setting the middle part of a previous oldext extent to
2439                  * newext.  Contiguity is impossible here.
2440                  * One extent becomes three extents.
2441                  */
2442                 old = PREV;
2443                 PREV.br_blockcount = new->br_startoff - PREV.br_startoff;
2444
2445                 r[0] = *new;
2446                 r[1].br_startoff = new_endoff;
2447                 r[1].br_blockcount =
2448                         old.br_startoff + old.br_blockcount - new_endoff;
2449                 r[1].br_startblock = new->br_startblock + new->br_blockcount;
2450                 r[1].br_state = PREV.br_state;
2451
2452                 xfs_iext_update_extent(ip, state, icur, &PREV);
2453                 xfs_iext_next(ifp, icur);
2454                 xfs_iext_insert(ip, icur, &r[1], state);
2455                 xfs_iext_insert(ip, icur, &r[0], state);
2456                 ifp->if_nextents += 2;
2457
2458                 if (cur == NULL)
2459                         rval = XFS_ILOG_CORE | XFS_ILOG_DEXT;
2460                 else {
2461                         rval = XFS_ILOG_CORE;
2462                         error = xfs_bmbt_lookup_eq(cur, &old, &i);
2463                         if (error)
2464                                 goto done;
2465                         if (XFS_IS_CORRUPT(mp, i != 1)) {
2466                                 xfs_btree_mark_sick(cur);
2467                                 error = -EFSCORRUPTED;
2468                                 goto done;
2469                         }
2470                         /* new right extent - oldext */
2471                         error = xfs_bmbt_update(cur, &r[1]);
2472                         if (error)
2473                                 goto done;
2474                         /* new left extent - oldext */
2475                         cur->bc_rec.b = PREV;
2476                         if ((error = xfs_btree_insert(cur, &i)))
2477                                 goto done;
2478                         if (XFS_IS_CORRUPT(mp, i != 1)) {
2479                                 xfs_btree_mark_sick(cur);
2480                                 error = -EFSCORRUPTED;
2481                                 goto done;
2482                         }
2483                         /*
2484                          * Reset the cursor to the position of the new extent
2485                          * we are about to insert as we can't trust it after
2486                          * the previous insert.
2487                          */
2488                         error = xfs_bmbt_lookup_eq(cur, new, &i);
2489                         if (error)
2490                                 goto done;
2491                         if (XFS_IS_CORRUPT(mp, i != 0)) {
2492                                 xfs_btree_mark_sick(cur);
2493                                 error = -EFSCORRUPTED;
2494                                 goto done;
2495                         }
2496                         /* new middle extent - newext */
2497                         if ((error = xfs_btree_insert(cur, &i)))
2498                                 goto done;
2499                         if (XFS_IS_CORRUPT(mp, i != 1)) {
2500                                 xfs_btree_mark_sick(cur);
2501                                 error = -EFSCORRUPTED;
2502                                 goto done;
2503                         }
2504                 }
2505                 break;
2506
2507         case BMAP_LEFT_FILLING | BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG:
2508         case BMAP_RIGHT_FILLING | BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG:
2509         case BMAP_LEFT_FILLING | BMAP_RIGHT_CONTIG:
2510         case BMAP_RIGHT_FILLING | BMAP_LEFT_CONTIG:
2511         case BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG:
2512         case BMAP_LEFT_CONTIG:
2513         case BMAP_RIGHT_CONTIG:
2514                 /*
2515                  * These cases are all impossible.
2516                  */
2517                 ASSERT(0);
2518         }
2519
2520         /* update reverse mappings */
2521         xfs_rmap_convert_extent(mp, tp, ip, whichfork, new);
2522
2523         /* convert to a btree if necessary */
2524         if (xfs_bmap_needs_btree(ip, whichfork)) {
2525                 int     tmp_logflags;   /* partial log flag return val */
2526
2527                 ASSERT(cur == NULL);
2528                 error = xfs_bmap_extents_to_btree(tp, ip, &cur, 0,
2529                                 &tmp_logflags, whichfork);
2530                 *logflagsp |= tmp_logflags;
2531                 if (error)
2532                         goto done;
2533         }
2534
2535         /* clear out the allocated field, done with it now in any case. */
2536         if (cur) {
2537                 cur->bc_bmap.allocated = 0;
2538                 *curp = cur;
2539         }
2540
2541         xfs_bmap_check_leaf_extents(*curp, ip, whichfork);
2542 done:
2543         *logflagsp |= rval;
2544         return error;
2545 #undef  LEFT
2546 #undef  RIGHT
2547 #undef  PREV
2548 }
2549
2550 /*
2551  * Convert a hole to a delayed allocation.
2552  */
2553 STATIC void
2554 xfs_bmap_add_extent_hole_delay(
2555         xfs_inode_t             *ip,    /* incore inode pointer */
2556         int                     whichfork,
2557         struct xfs_iext_cursor  *icur,
2558         xfs_bmbt_irec_t         *new)   /* new data to add to file extents */
2559 {
2560         struct xfs_ifork        *ifp;   /* inode fork pointer */
2561         xfs_bmbt_irec_t         left;   /* left neighbor extent entry */
2562         xfs_filblks_t           newlen=0;       /* new indirect size */
2563         xfs_filblks_t           oldlen=0;       /* old indirect size */
2564         xfs_bmbt_irec_t         right;  /* right neighbor extent entry */
2565         uint32_t                state = xfs_bmap_fork_to_state(whichfork);
2566         xfs_filblks_t           temp;    /* temp for indirect calculations */
2567
2568         ifp = xfs_ifork_ptr(ip, whichfork);
2569         ASSERT(isnullstartblock(new->br_startblock));
2570
2571         /*
2572          * Check and set flags if this segment has a left neighbor
2573          */
2574         if (xfs_iext_peek_prev_extent(ifp, icur, &left)) {
2575                 state |= BMAP_LEFT_VALID;
2576                 if (isnullstartblock(left.br_startblock))
2577                         state |= BMAP_LEFT_DELAY;
2578         }
2579
2580         /*
2581          * Check and set flags if the current (right) segment exists.
2582          * If it doesn't exist, we're converting the hole at end-of-file.
2583          */
2584         if (xfs_iext_get_extent(ifp, icur, &right)) {
2585                 state |= BMAP_RIGHT_VALID;
2586                 if (isnullstartblock(right.br_startblock))
2587                         state |= BMAP_RIGHT_DELAY;
2588         }
2589
2590         /*
2591          * Set contiguity flags on the left and right neighbors.
2592          * Don't let extents get too large, even if the pieces are contiguous.
2593          */
2594         if ((state & BMAP_LEFT_VALID) && (state & BMAP_LEFT_DELAY) &&
2595             left.br_startoff + left.br_blockcount == new->br_startoff &&
2596             left.br_blockcount + new->br_blockcount <= XFS_MAX_BMBT_EXTLEN)
2597                 state |= BMAP_LEFT_CONTIG;
2598
2599         if ((state & BMAP_RIGHT_VALID) && (state & BMAP_RIGHT_DELAY) &&
2600             new->br_startoff + new->br_blockcount == right.br_startoff &&
2601             new->br_blockcount + right.br_blockcount <= XFS_MAX_BMBT_EXTLEN &&
2602             (!(state & BMAP_LEFT_CONTIG) ||
2603              (left.br_blockcount + new->br_blockcount +
2604               right.br_blockcount <= XFS_MAX_BMBT_EXTLEN)))
2605                 state |= BMAP_RIGHT_CONTIG;
2606
2607         /*
2608          * Switch out based on the contiguity flags.
2609          */
2610         switch (state & (BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG)) {
2611         case BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG:
2612                 /*
2613                  * New allocation is contiguous with delayed allocations
2614                  * on the left and on the right.
2615                  * Merge all three into a single extent record.
2616                  */
2617                 temp = left.br_blockcount + new->br_blockcount +
2618                         right.br_blockcount;
2619
2620                 oldlen = startblockval(left.br_startblock) +
2621                         startblockval(new->br_startblock) +
2622                         startblockval(right.br_startblock);
2623                 newlen = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(ip, temp),
2624                                          oldlen);
2625                 left.br_startblock = nullstartblock(newlen);
2626                 left.br_blockcount = temp;
2627
2628                 xfs_iext_remove(ip, icur, state);
2629                 xfs_iext_prev(ifp, icur);
2630                 xfs_iext_update_extent(ip, state, icur, &left);
2631                 break;
2632
2633         case BMAP_LEFT_CONTIG:
2634                 /*
2635                  * New allocation is contiguous with a delayed allocation
2636                  * on the left.
2637                  * Merge the new allocation with the left neighbor.
2638                  */
2639                 temp = left.br_blockcount + new->br_blockcount;
2640
2641                 oldlen = startblockval(left.br_startblock) +
2642                         startblockval(new->br_startblock);
2643                 newlen = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(ip, temp),
2644                                          oldlen);
2645                 left.br_blockcount = temp;
2646                 left.br_startblock = nullstartblock(newlen);
2647
2648                 xfs_iext_prev(ifp, icur);
2649                 xfs_iext_update_extent(ip, state, icur, &left);
2650                 break;
2651
2652         case BMAP_RIGHT_CONTIG:
2653                 /*
2654                  * New allocation is contiguous with a delayed allocation
2655                  * on the right.
2656                  * Merge the new allocation with the right neighbor.
2657                  */
2658                 temp = new->br_blockcount + right.br_blockcount;
2659                 oldlen = startblockval(new->br_startblock) +
2660                         startblockval(right.br_startblock);
2661                 newlen = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(ip, temp),
2662                                          oldlen);
2663                 right.br_startoff = new->br_startoff;
2664                 right.br_startblock = nullstartblock(newlen);
2665                 right.br_blockcount = temp;
2666                 xfs_iext_update_extent(ip, state, icur, &right);
2667                 break;
2668
2669         case 0:
2670                 /*
2671                  * New allocation is not contiguous with another
2672                  * delayed allocation.
2673                  * Insert a new entry.
2674                  */
2675                 oldlen = newlen = 0;
2676                 xfs_iext_insert(ip, icur, new, state);
2677                 break;
2678         }
2679         if (oldlen != newlen) {
2680                 ASSERT(oldlen > newlen);
2681                 xfs_add_fdblocks(ip->i_mount, oldlen - newlen);
2682
2683                 /*
2684                  * Nothing to do for disk quota accounting here.
2685                  */
2686                 xfs_mod_delalloc(ip, 0, (int64_t)newlen - oldlen);
2687         }
2688 }
2689
2690 /*
2691  * Convert a hole to a real allocation.
2692  */
2693 STATIC int                              /* error */
2694 xfs_bmap_add_extent_hole_real(
2695         struct xfs_trans        *tp,
2696         struct xfs_inode        *ip,
2697         int                     whichfork,
2698         struct xfs_iext_cursor  *icur,
2699         struct xfs_btree_cur    **curp,
2700         struct xfs_bmbt_irec    *new,
2701         int                     *logflagsp,
2702         uint32_t                flags)
2703 {
2704         struct xfs_ifork        *ifp = xfs_ifork_ptr(ip, whichfork);
2705         struct xfs_mount        *mp = ip->i_mount;
2706         struct xfs_btree_cur    *cur = *curp;
2707         int                     error;  /* error return value */
2708         int                     i;      /* temp state */
2709         xfs_bmbt_irec_t         left;   /* left neighbor extent entry */
2710         xfs_bmbt_irec_t         right;  /* right neighbor extent entry */
2711         int                     rval=0; /* return value (logging flags) */
2712         uint32_t                state = xfs_bmap_fork_to_state(whichfork);
2713         struct xfs_bmbt_irec    old;
2714
2715         ASSERT(!isnullstartblock(new->br_startblock));
2716         ASSERT(!cur || !(cur->bc_flags & XFS_BTREE_BMBT_WASDEL));
2717
2718         XFS_STATS_INC(mp, xs_add_exlist);
2719
2720         /*
2721          * Check and set flags if this segment has a left neighbor.
2722          */
2723         if (xfs_iext_peek_prev_extent(ifp, icur, &left)) {
2724                 state |= BMAP_LEFT_VALID;
2725                 if (isnullstartblock(left.br_startblock))
2726                         state |= BMAP_LEFT_DELAY;
2727         }
2728
2729         /*
2730          * Check and set flags if this segment has a current value.
2731          * Not true if we're inserting into the "hole" at eof.
2732          */
2733         if (xfs_iext_get_extent(ifp, icur, &right)) {
2734                 state |= BMAP_RIGHT_VALID;
2735                 if (isnullstartblock(right.br_startblock))
2736                         state |= BMAP_RIGHT_DELAY;
2737         }
2738
2739         /*
2740          * We're inserting a real allocation between "left" and "right".
2741          * Set the contiguity flags.  Don't let extents get too large.
2742          */
2743         if ((state & BMAP_LEFT_VALID) && !(state & BMAP_LEFT_DELAY) &&
2744             left.br_startoff + left.br_blockcount == new->br_startoff &&
2745             left.br_startblock + left.br_blockcount == new->br_startblock &&
2746             left.br_state == new->br_state &&
2747             left.br_blockcount + new->br_blockcount <= XFS_MAX_BMBT_EXTLEN)
2748                 state |= BMAP_LEFT_CONTIG;
2749
2750         if ((state & BMAP_RIGHT_VALID) && !(state & BMAP_RIGHT_DELAY) &&
2751             new->br_startoff + new->br_blockcount == right.br_startoff &&
2752             new->br_startblock + new->br_blockcount == right.br_startblock &&
2753             new->br_state == right.br_state &&
2754             new->br_blockcount + right.br_blockcount <= XFS_MAX_BMBT_EXTLEN &&
2755             (!(state & BMAP_LEFT_CONTIG) ||
2756              left.br_blockcount + new->br_blockcount +
2757              right.br_blockcount <= XFS_MAX_BMBT_EXTLEN))
2758                 state |= BMAP_RIGHT_CONTIG;
2759
2760         error = 0;
2761         /*
2762          * Select which case we're in here, and implement it.
2763          */
2764         switch (state & (BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG)) {
2765         case BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG:
2766                 /*
2767                  * New allocation is contiguous with real allocations on the
2768                  * left and on the right.
2769                  * Merge all three into a single extent record.
2770                  */
2771                 left.br_blockcount += new->br_blockcount + right.br_blockcount;
2772
2773                 xfs_iext_remove(ip, icur, state);
2774                 xfs_iext_prev(ifp, icur);
2775                 xfs_iext_update_extent(ip, state, icur, &left);
2776                 ifp->if_nextents--;
2777
2778                 if (cur == NULL) {
2779                         rval = XFS_ILOG_CORE | xfs_ilog_fext(whichfork);
2780                 } else {
2781                         rval = XFS_ILOG_CORE;
2782                         error = xfs_bmbt_lookup_eq(cur, &right, &i);
2783                         if (error)
2784                                 goto done;
2785                         if (XFS_IS_CORRUPT(mp, i != 1)) {
2786                                 xfs_btree_mark_sick(cur);
2787                                 error = -EFSCORRUPTED;
2788                                 goto done;
2789                         }
2790                         error = xfs_btree_delete(cur, &i);
2791                         if (error)
2792                                 goto done;
2793                         if (XFS_IS_CORRUPT(mp, i != 1)) {
2794                                 xfs_btree_mark_sick(cur);
2795                                 error = -EFSCORRUPTED;
2796                                 goto done;
2797                         }
2798                         error = xfs_btree_decrement(cur, 0, &i);
2799                         if (error)
2800                                 goto done;
2801                         if (XFS_IS_CORRUPT(mp, i != 1)) {
2802                                 xfs_btree_mark_sick(cur);
2803                                 error = -EFSCORRUPTED;
2804                                 goto done;
2805                         }
2806                         error = xfs_bmbt_update(cur, &left);
2807                         if (error)
2808                                 goto done;
2809                 }
2810                 break;
2811
2812         case BMAP_LEFT_CONTIG:
2813                 /*
2814                  * New allocation is contiguous with a real allocation
2815                  * on the left.
2816                  * Merge the new allocation with the left neighbor.
2817                  */
2818                 old = left;
2819                 left.br_blockcount += new->br_blockcount;
2820
2821                 xfs_iext_prev(ifp, icur);
2822                 xfs_iext_update_extent(ip, state, icur, &left);
2823
2824                 if (cur == NULL) {
2825                         rval = xfs_ilog_fext(whichfork);
2826                 } else {
2827                         rval = 0;
2828                         error = xfs_bmbt_lookup_eq(cur, &old, &i);
2829                         if (error)
2830                                 goto done;
2831                         if (XFS_IS_CORRUPT(mp, i != 1)) {
2832                                 xfs_btree_mark_sick(cur);
2833                                 error = -EFSCORRUPTED;
2834                                 goto done;
2835                         }
2836                         error = xfs_bmbt_update(cur, &left);
2837                         if (error)
2838                                 goto done;
2839                 }
2840                 break;
2841
2842         case BMAP_RIGHT_CONTIG:
2843                 /*
2844                  * New allocation is contiguous with a real allocation
2845                  * on the right.
2846                  * Merge the new allocation with the right neighbor.
2847                  */
2848                 old = right;
2849
2850                 right.br_startoff = new->br_startoff;
2851                 right.br_startblock = new->br_startblock;
2852                 right.br_blockcount += new->br_blockcount;
2853                 xfs_iext_update_extent(ip, state, icur, &right);
2854
2855                 if (cur == NULL) {
2856                         rval = xfs_ilog_fext(whichfork);
2857                 } else {
2858                         rval = 0;
2859                         error = xfs_bmbt_lookup_eq(cur, &old, &i);
2860                         if (error)
2861                                 goto done;
2862                         if (XFS_IS_CORRUPT(mp, i != 1)) {
2863                                 xfs_btree_mark_sick(cur);
2864                                 error = -EFSCORRUPTED;
2865                                 goto done;
2866                         }
2867                         error = xfs_bmbt_update(cur, &right);
2868                         if (error)
2869                                 goto done;
2870                 }
2871                 break;
2872
2873         case 0:
2874                 /*
2875                  * New allocation is not contiguous with another
2876                  * real allocation.
2877                  * Insert a new entry.
2878                  */
2879                 xfs_iext_insert(ip, icur, new, state);
2880                 ifp->if_nextents++;
2881
2882                 if (cur == NULL) {
2883                         rval = XFS_ILOG_CORE | xfs_ilog_fext(whichfork);
2884                 } else {
2885                         rval = XFS_ILOG_CORE;
2886                         error = xfs_bmbt_lookup_eq(cur, new, &i);
2887                         if (error)
2888                                 goto done;
2889                         if (XFS_IS_CORRUPT(mp, i != 0)) {
2890                                 xfs_btree_mark_sick(cur);
2891                                 error = -EFSCORRUPTED;
2892                                 goto done;
2893                         }
2894                         error = xfs_btree_insert(cur, &i);
2895                         if (error)
2896                                 goto done;
2897                         if (XFS_IS_CORRUPT(mp, i != 1)) {
2898                                 xfs_btree_mark_sick(cur);
2899                                 error = -EFSCORRUPTED;
2900                                 goto done;
2901                         }
2902                 }
2903                 break;
2904         }
2905
2906         /* add reverse mapping unless caller opted out */
2907         if (!(flags & XFS_BMAPI_NORMAP))
2908                 xfs_rmap_map_extent(tp, ip, whichfork, new);
2909
2910         /* convert to a btree if necessary */
2911         if (xfs_bmap_needs_btree(ip, whichfork)) {
2912                 int     tmp_logflags;   /* partial log flag return val */
2913
2914                 ASSERT(cur == NULL);
2915                 error = xfs_bmap_extents_to_btree(tp, ip, curp, 0,
2916                                 &tmp_logflags, whichfork);
2917                 *logflagsp |= tmp_logflags;
2918                 cur = *curp;
2919                 if (error)
2920                         goto done;
2921         }
2922
2923         /* clear out the allocated field, done with it now in any case. */
2924         if (cur)
2925                 cur->bc_bmap.allocated = 0;
2926
2927         xfs_bmap_check_leaf_extents(cur, ip, whichfork);
2928 done:
2929         *logflagsp |= rval;
2930         return error;
2931 }
2932
2933 /*
2934  * Functions used in the extent read, allocate and remove paths
2935  */
2936
2937 /*
2938  * Adjust the size of the new extent based on i_extsize and rt extsize.
2939  */
2940 int
2941 xfs_bmap_extsize_align(
2942         xfs_mount_t     *mp,
2943         xfs_bmbt_irec_t *gotp,          /* next extent pointer */
2944         xfs_bmbt_irec_t *prevp,         /* previous extent pointer */
2945         xfs_extlen_t    extsz,          /* align to this extent size */
2946         int             rt,             /* is this a realtime inode? */
2947         int             eof,            /* is extent at end-of-file? */
2948         int             delay,          /* creating delalloc extent? */
2949         int             convert,        /* overwriting unwritten extent? */
2950         xfs_fileoff_t   *offp,          /* in/out: aligned offset */
2951         xfs_extlen_t    *lenp)          /* in/out: aligned length */
2952 {
2953         xfs_fileoff_t   orig_off;       /* original offset */
2954         xfs_extlen_t    orig_alen;      /* original length */
2955         xfs_fileoff_t   orig_end;       /* original off+len */
2956         xfs_fileoff_t   nexto;          /* next file offset */
2957         xfs_fileoff_t   prevo;          /* previous file offset */
2958         xfs_fileoff_t   align_off;      /* temp for offset */
2959         xfs_extlen_t    align_alen;     /* temp for length */
2960         xfs_extlen_t    temp;           /* temp for calculations */
2961
2962         if (convert)
2963                 return 0;
2964
2965         orig_off = align_off = *offp;
2966         orig_alen = align_alen = *lenp;
2967         orig_end = orig_off + orig_alen;
2968
2969         /*
2970          * If this request overlaps an existing extent, then don't
2971          * attempt to perform any additional alignment.
2972          */
2973         if (!delay && !eof &&
2974             (orig_off >= gotp->br_startoff) &&
2975             (orig_end <= gotp->br_startoff + gotp->br_blockcount)) {
2976                 return 0;
2977         }
2978
2979         /*
2980          * If the file offset is unaligned vs. the extent size
2981          * we need to align it.  This will be possible unless
2982          * the file was previously written with a kernel that didn't
2983          * perform this alignment, or if a truncate shot us in the
2984          * foot.
2985          */
2986         div_u64_rem(orig_off, extsz, &temp);
2987         if (temp) {
2988                 align_alen += temp;
2989                 align_off -= temp;
2990         }
2991
2992         /* Same adjustment for the end of the requested area. */
2993         temp = (align_alen % extsz);
2994         if (temp)
2995                 align_alen += extsz - temp;
2996
2997         /*
2998          * For large extent hint sizes, the aligned extent might be larger than
2999          * XFS_BMBT_MAX_EXTLEN. In that case, reduce the size by an extsz so
3000          * that it pulls the length back under XFS_BMBT_MAX_EXTLEN. The outer
3001          * allocation loops handle short allocation just fine, so it is safe to
3002          * do this. We only want to do it when we are forced to, though, because
3003          * it means more allocation operations are required.
3004          */
3005         while (align_alen > XFS_MAX_BMBT_EXTLEN)
3006                 align_alen -= extsz;
3007         ASSERT(align_alen <= XFS_MAX_BMBT_EXTLEN);
3008
3009         /*
3010          * If the previous block overlaps with this proposed allocation
3011          * then move the start forward without adjusting the length.
3012          */
3013         if (prevp->br_startoff != NULLFILEOFF) {
3014                 if (prevp->br_startblock == HOLESTARTBLOCK)
3015                         prevo = prevp->br_startoff;
3016                 else
3017                         prevo = prevp->br_startoff + prevp->br_blockcount;
3018         } else
3019                 prevo = 0;
3020         if (align_off != orig_off && align_off < prevo)
3021                 align_off = prevo;
3022         /*
3023          * If the next block overlaps with this proposed allocation
3024          * then move the start back without adjusting the length,
3025          * but not before offset 0.
3026          * This may of course make the start overlap previous block,
3027          * and if we hit the offset 0 limit then the next block
3028          * can still overlap too.
3029          */
3030         if (!eof && gotp->br_startoff != NULLFILEOFF) {
3031                 if ((delay && gotp->br_startblock == HOLESTARTBLOCK) ||
3032                     (!delay && gotp->br_startblock == DELAYSTARTBLOCK))
3033                         nexto = gotp->br_startoff + gotp->br_blockcount;
3034                 else
3035                         nexto = gotp->br_startoff;
3036         } else
3037                 nexto = NULLFILEOFF;
3038         if (!eof &&
3039             align_off + align_alen != orig_end &&
3040             align_off + align_alen > nexto)
3041                 align_off = nexto > align_alen ? nexto - align_alen : 0;
3042         /*
3043          * If we're now overlapping the next or previous extent that
3044          * means we can't fit an extsz piece in this hole.  Just move
3045          * the start forward to the first valid spot and set
3046          * the length so we hit the end.
3047          */
3048         if (align_off != orig_off && align_off < prevo)
3049                 align_off = prevo;
3050         if (align_off + align_alen != orig_end &&
3051             align_off + align_alen > nexto &&
3052             nexto != NULLFILEOFF) {
3053                 ASSERT(nexto > prevo);
3054                 align_alen = nexto - align_off;
3055         }
3056
3057         /*
3058          * If realtime, and the result isn't a multiple of the realtime
3059          * extent size we need to remove blocks until it is.
3060          */
3061         if (rt && (temp = xfs_extlen_to_rtxmod(mp, align_alen))) {
3062                 /*
3063                  * We're not covering the original request, or
3064                  * we won't be able to once we fix the length.
3065                  */
3066                 if (orig_off < align_off ||
3067                     orig_end > align_off + align_alen ||
3068                     align_alen - temp < orig_alen)
3069                         return -EINVAL;
3070                 /*
3071                  * Try to fix it by moving the start up.
3072                  */
3073                 if (align_off + temp <= orig_off) {
3074                         align_alen -= temp;
3075                         align_off += temp;
3076                 }
3077                 /*
3078                  * Try to fix it by moving the end in.
3079                  */
3080                 else if (align_off + align_alen - temp >= orig_end)
3081                         align_alen -= temp;
3082                 /*
3083                  * Set the start to the minimum then trim the length.
3084                  */
3085                 else {
3086                         align_alen -= orig_off - align_off;
3087                         align_off = orig_off;
3088                         align_alen -= xfs_extlen_to_rtxmod(mp, align_alen);
3089                 }
3090                 /*
3091                  * Result doesn't cover the request, fail it.
3092                  */
3093                 if (orig_off < align_off || orig_end > align_off + align_alen)
3094                         return -EINVAL;
3095         } else {
3096                 ASSERT(orig_off >= align_off);
3097                 /* see XFS_BMBT_MAX_EXTLEN handling above */
3098                 ASSERT(orig_end <= align_off + align_alen ||
3099                        align_alen + extsz > XFS_MAX_BMBT_EXTLEN);
3100         }
3101
3102 #ifdef DEBUG
3103         if (!eof && gotp->br_startoff != NULLFILEOFF)
3104                 ASSERT(align_off + align_alen <= gotp->br_startoff);
3105         if (prevp->br_startoff != NULLFILEOFF)
3106                 ASSERT(align_off >= prevp->br_startoff + prevp->br_blockcount);
3107 #endif
3108
3109         *lenp = align_alen;
3110         *offp = align_off;
3111         return 0;
3112 }
3113
3114 #define XFS_ALLOC_GAP_UNITS     4
3115
3116 /* returns true if ap->blkno was modified */
3117 bool
3118 xfs_bmap_adjacent(
3119         struct xfs_bmalloca     *ap)    /* bmap alloc argument struct */
3120 {
3121         xfs_fsblock_t   adjust;         /* adjustment to block numbers */
3122         xfs_mount_t     *mp;            /* mount point structure */
3123         int             rt;             /* true if inode is realtime */
3124
3125 #define ISVALID(x,y)    \
3126         (rt ? \
3127                 (x) < mp->m_sb.sb_rblocks : \
3128                 XFS_FSB_TO_AGNO(mp, x) == XFS_FSB_TO_AGNO(mp, y) && \
3129                 XFS_FSB_TO_AGNO(mp, x) < mp->m_sb.sb_agcount && \
3130                 XFS_FSB_TO_AGBNO(mp, x) < mp->m_sb.sb_agblocks)
3131
3132         mp = ap->ip->i_mount;
3133         rt = XFS_IS_REALTIME_INODE(ap->ip) &&
3134                 (ap->datatype & XFS_ALLOC_USERDATA);
3135         /*
3136          * If allocating at eof, and there's a previous real block,
3137          * try to use its last block as our starting point.
3138          */
3139         if (ap->eof && ap->prev.br_startoff != NULLFILEOFF &&
3140             !isnullstartblock(ap->prev.br_startblock) &&
3141             ISVALID(ap->prev.br_startblock + ap->prev.br_blockcount,
3142                     ap->prev.br_startblock)) {
3143                 ap->blkno = ap->prev.br_startblock + ap->prev.br_blockcount;
3144                 /*
3145                  * Adjust for the gap between prevp and us.
3146                  */
3147                 adjust = ap->offset -
3148                         (ap->prev.br_startoff + ap->prev.br_blockcount);
3149                 if (adjust &&
3150                     ISVALID(ap->blkno + adjust, ap->prev.br_startblock))
3151                         ap->blkno += adjust;
3152                 return true;
3153         }
3154         /*
3155          * If not at eof, then compare the two neighbor blocks.
3156          * Figure out whether either one gives us a good starting point,
3157          * and pick the better one.
3158          */
3159         if (!ap->eof) {
3160                 xfs_fsblock_t   gotbno;         /* right side block number */
3161                 xfs_fsblock_t   gotdiff=0;      /* right side difference */
3162                 xfs_fsblock_t   prevbno;        /* left side block number */
3163                 xfs_fsblock_t   prevdiff=0;     /* left side difference */
3164
3165                 /*
3166                  * If there's a previous (left) block, select a requested
3167                  * start block based on it.
3168                  */
3169                 if (ap->prev.br_startoff != NULLFILEOFF &&
3170                     !isnullstartblock(ap->prev.br_startblock) &&
3171                     (prevbno = ap->prev.br_startblock +
3172                                ap->prev.br_blockcount) &&
3173                     ISVALID(prevbno, ap->prev.br_startblock)) {
3174                         /*
3175                          * Calculate gap to end of previous block.
3176                          */
3177                         adjust = prevdiff = ap->offset -
3178                                 (ap->prev.br_startoff +
3179                                  ap->prev.br_blockcount);
3180                         /*
3181                          * Figure the startblock based on the previous block's
3182                          * end and the gap size.
3183                          * Heuristic!
3184                          * If the gap is large relative to the piece we're
3185                          * allocating, or using it gives us an invalid block
3186                          * number, then just use the end of the previous block.
3187                          */
3188                         if (prevdiff <= XFS_ALLOC_GAP_UNITS * ap->length &&
3189                             ISVALID(prevbno + prevdiff,
3190                                     ap->prev.br_startblock))
3191                                 prevbno += adjust;
3192                         else
3193                                 prevdiff += adjust;
3194                 }
3195                 /*
3196                  * No previous block or can't follow it, just default.
3197                  */
3198                 else
3199                         prevbno = NULLFSBLOCK;
3200                 /*
3201                  * If there's a following (right) block, select a requested
3202                  * start block based on it.
3203                  */
3204                 if (!isnullstartblock(ap->got.br_startblock)) {
3205                         /*
3206                          * Calculate gap to start of next block.
3207                          */
3208                         adjust = gotdiff = ap->got.br_startoff - ap->offset;
3209                         /*
3210                          * Figure the startblock based on the next block's
3211                          * start and the gap size.
3212                          */
3213                         gotbno = ap->got.br_startblock;
3214                         /*
3215                          * Heuristic!
3216                          * If the gap is large relative to the piece we're
3217                          * allocating, or using it gives us an invalid block
3218                          * number, then just use the start of the next block
3219                          * offset by our length.
3220                          */
3221                         if (gotdiff <= XFS_ALLOC_GAP_UNITS * ap->length &&
3222                             ISVALID(gotbno - gotdiff, gotbno))
3223                                 gotbno -= adjust;
3224                         else if (ISVALID(gotbno - ap->length, gotbno)) {
3225                                 gotbno -= ap->length;
3226                                 gotdiff += adjust - ap->length;
3227                         } else
3228                                 gotdiff += adjust;
3229                 }
3230                 /*
3231                  * No next block, just default.
3232                  */
3233                 else
3234                         gotbno = NULLFSBLOCK;
3235                 /*
3236                  * If both valid, pick the better one, else the only good
3237                  * one, else ap->blkno is already set (to 0 or the inode block).
3238                  */
3239                 if (prevbno != NULLFSBLOCK && gotbno != NULLFSBLOCK) {
3240                         ap->blkno = prevdiff <= gotdiff ? prevbno : gotbno;
3241                         return true;
3242                 }
3243                 if (prevbno != NULLFSBLOCK) {
3244                         ap->blkno = prevbno;
3245                         return true;
3246                 }
3247                 if (gotbno != NULLFSBLOCK) {
3248                         ap->blkno = gotbno;
3249                         return true;
3250                 }
3251         }
3252 #undef ISVALID
3253         return false;
3254 }
3255
3256 int
3257 xfs_bmap_longest_free_extent(
3258         struct xfs_perag        *pag,
3259         struct xfs_trans        *tp,
3260         xfs_extlen_t            *blen)
3261 {
3262         xfs_extlen_t            longest;
3263         int                     error = 0;
3264
3265         if (!xfs_perag_initialised_agf(pag)) {
3266                 error = xfs_alloc_read_agf(pag, tp, XFS_ALLOC_FLAG_TRYLOCK,
3267                                 NULL);
3268                 if (error)
3269                         return error;
3270         }
3271
3272         longest = xfs_alloc_longest_free_extent(pag,
3273                                 xfs_alloc_min_freelist(pag->pag_mount, pag),
3274                                 xfs_ag_resv_needed(pag, XFS_AG_RESV_NONE));
3275         if (*blen < longest)
3276                 *blen = longest;
3277
3278         return 0;
3279 }
3280
3281 static xfs_extlen_t
3282 xfs_bmap_select_minlen(
3283         struct xfs_bmalloca     *ap,
3284         struct xfs_alloc_arg    *args,
3285         xfs_extlen_t            blen)
3286 {
3287
3288         /*
3289          * Since we used XFS_ALLOC_FLAG_TRYLOCK in _longest_free_extent(), it is
3290          * possible that there is enough contiguous free space for this request.
3291          */
3292         if (blen < ap->minlen)
3293                 return ap->minlen;
3294
3295         /*
3296          * If the best seen length is less than the request length,
3297          * use the best as the minimum, otherwise we've got the maxlen we
3298          * were asked for.
3299          */
3300         if (blen < args->maxlen)
3301                 return blen;
3302         return args->maxlen;
3303 }
3304
3305 static int
3306 xfs_bmap_btalloc_select_lengths(
3307         struct xfs_bmalloca     *ap,
3308         struct xfs_alloc_arg    *args,
3309         xfs_extlen_t            *blen)
3310 {
3311         struct xfs_mount        *mp = args->mp;
3312         struct xfs_perag        *pag;
3313         xfs_agnumber_t          agno, startag;
3314         int                     error = 0;
3315
3316         if (ap->tp->t_flags & XFS_TRANS_LOWMODE) {
3317                 args->total = ap->minlen;
3318                 args->minlen = ap->minlen;
3319                 return 0;
3320         }
3321
3322         args->total = ap->total;
3323         startag = XFS_FSB_TO_AGNO(mp, ap->blkno);
3324         if (startag == NULLAGNUMBER)
3325                 startag = 0;
3326
3327         *blen = 0;
3328         for_each_perag_wrap(mp, startag, agno, pag) {
3329                 error = xfs_bmap_longest_free_extent(pag, args->tp, blen);
3330                 if (error && error != -EAGAIN)
3331                         break;
3332                 error = 0;
3333                 if (*blen >= args->maxlen)
3334                         break;
3335         }
3336         if (pag)
3337                 xfs_perag_rele(pag);
3338
3339         args->minlen = xfs_bmap_select_minlen(ap, args, *blen);
3340         return error;
3341 }
3342
3343 /* Update all inode and quota accounting for the allocation we just did. */
3344 void
3345 xfs_bmap_alloc_account(
3346         struct xfs_bmalloca     *ap)
3347 {
3348         bool                    isrt = XFS_IS_REALTIME_INODE(ap->ip) &&
3349                                         !(ap->flags & XFS_BMAPI_ATTRFORK);
3350         uint                    fld;
3351
3352         if (ap->flags & XFS_BMAPI_COWFORK) {
3353                 /*
3354                  * COW fork blocks are in-core only and thus are treated as
3355                  * in-core quota reservation (like delalloc blocks) even when
3356                  * converted to real blocks. The quota reservation is not
3357                  * accounted to disk until blocks are remapped to the data
3358                  * fork. So if these blocks were previously delalloc, we
3359                  * already have quota reservation and there's nothing to do
3360                  * yet.
3361                  */
3362                 if (ap->wasdel) {
3363                         xfs_mod_delalloc(ap->ip, -(int64_t)ap->length, 0);
3364                         return;
3365                 }
3366
3367                 /*
3368                  * Otherwise, we've allocated blocks in a hole. The transaction
3369                  * has acquired in-core quota reservation for this extent.
3370                  * Rather than account these as real blocks, however, we reduce
3371                  * the transaction quota reservation based on the allocation.
3372                  * This essentially transfers the transaction quota reservation
3373                  * to that of a delalloc extent.
3374                  */
3375                 ap->ip->i_delayed_blks += ap->length;
3376                 xfs_trans_mod_dquot_byino(ap->tp, ap->ip, isrt ?
3377                                 XFS_TRANS_DQ_RES_RTBLKS : XFS_TRANS_DQ_RES_BLKS,
3378                                 -(long)ap->length);
3379                 return;
3380         }
3381
3382         /* data/attr fork only */
3383         ap->ip->i_nblocks += ap->length;
3384         xfs_trans_log_inode(ap->tp, ap->ip, XFS_ILOG_CORE);
3385         if (ap->wasdel) {
3386                 ap->ip->i_delayed_blks -= ap->length;
3387                 xfs_mod_delalloc(ap->ip, -(int64_t)ap->length, 0);
3388                 fld = isrt ? XFS_TRANS_DQ_DELRTBCOUNT : XFS_TRANS_DQ_DELBCOUNT;
3389         } else {
3390                 fld = isrt ? XFS_TRANS_DQ_RTBCOUNT : XFS_TRANS_DQ_BCOUNT;
3391         }
3392
3393         xfs_trans_mod_dquot_byino(ap->tp, ap->ip, fld, ap->length);
3394 }
3395
3396 static int
3397 xfs_bmap_compute_alignments(
3398         struct xfs_bmalloca     *ap,
3399         struct xfs_alloc_arg    *args)
3400 {
3401         struct xfs_mount        *mp = args->mp;
3402         xfs_extlen_t            align = 0; /* minimum allocation alignment */
3403         int                     stripe_align = 0;
3404
3405         /* stripe alignment for allocation is determined by mount parameters */
3406         if (mp->m_swidth && xfs_has_swalloc(mp))
3407                 stripe_align = mp->m_swidth;
3408         else if (mp->m_dalign)
3409                 stripe_align = mp->m_dalign;
3410
3411         if (ap->flags & XFS_BMAPI_COWFORK)
3412                 align = xfs_get_cowextsz_hint(ap->ip);
3413         else if (ap->datatype & XFS_ALLOC_USERDATA)
3414                 align = xfs_get_extsz_hint(ap->ip);
3415         if (align) {
3416                 if (xfs_bmap_extsize_align(mp, &ap->got, &ap->prev, align, 0,
3417                                         ap->eof, 0, ap->conv, &ap->offset,
3418                                         &ap->length))
3419                         ASSERT(0);
3420                 ASSERT(ap->length);
3421         }
3422
3423         /* apply extent size hints if obtained earlier */
3424         if (align) {
3425                 args->prod = align;
3426                 div_u64_rem(ap->offset, args->prod, &args->mod);
3427                 if (args->mod)
3428                         args->mod = args->prod - args->mod;
3429         } else if (mp->m_sb.sb_blocksize >= PAGE_SIZE) {
3430                 args->prod = 1;
3431                 args->mod = 0;
3432         } else {
3433                 args->prod = PAGE_SIZE >> mp->m_sb.sb_blocklog;
3434                 div_u64_rem(ap->offset, args->prod, &args->mod);
3435                 if (args->mod)
3436                         args->mod = args->prod - args->mod;
3437         }
3438
3439         return stripe_align;
3440 }
3441
3442 static void
3443 xfs_bmap_process_allocated_extent(
3444         struct xfs_bmalloca     *ap,
3445         struct xfs_alloc_arg    *args,
3446         xfs_fileoff_t           orig_offset,
3447         xfs_extlen_t            orig_length)
3448 {
3449         ap->blkno = args->fsbno;
3450         ap->length = args->len;
3451         /*
3452          * If the extent size hint is active, we tried to round the
3453          * caller's allocation request offset down to extsz and the
3454          * length up to another extsz boundary.  If we found a free
3455          * extent we mapped it in starting at this new offset.  If the
3456          * newly mapped space isn't long enough to cover any of the
3457          * range of offsets that was originally requested, move the
3458          * mapping up so that we can fill as much of the caller's
3459          * original request as possible.  Free space is apparently
3460          * very fragmented so we're unlikely to be able to satisfy the
3461          * hints anyway.
3462          */
3463         if (ap->length <= orig_length)
3464                 ap->offset = orig_offset;
3465         else if (ap->offset + ap->length < orig_offset + orig_length)
3466                 ap->offset = orig_offset + orig_length - ap->length;
3467         xfs_bmap_alloc_account(ap);
3468 }
3469
3470 #ifdef DEBUG
3471 static int
3472 xfs_bmap_exact_minlen_extent_alloc(
3473         struct xfs_bmalloca     *ap)
3474 {
3475         struct xfs_mount        *mp = ap->ip->i_mount;
3476         struct xfs_alloc_arg    args = { .tp = ap->tp, .mp = mp };
3477         xfs_fileoff_t           orig_offset;
3478         xfs_extlen_t            orig_length;
3479         int                     error;
3480
3481         ASSERT(ap->length);
3482
3483         if (ap->minlen != 1) {
3484                 ap->blkno = NULLFSBLOCK;
3485                 ap->length = 0;
3486                 return 0;
3487         }
3488
3489         orig_offset = ap->offset;
3490         orig_length = ap->length;
3491
3492         args.alloc_minlen_only = 1;
3493
3494         xfs_bmap_compute_alignments(ap, &args);
3495
3496         /*
3497          * Unlike the longest extent available in an AG, we don't track
3498          * the length of an AG's shortest extent.
3499          * XFS_ERRTAG_BMAP_ALLOC_MINLEN_EXTENT is a debug only knob and
3500          * hence we can afford to start traversing from the 0th AG since
3501          * we need not be concerned about a drop in performance in
3502          * "debug only" code paths.
3503          */
3504         ap->blkno = XFS_AGB_TO_FSB(mp, 0, 0);
3505
3506         args.oinfo = XFS_RMAP_OINFO_SKIP_UPDATE;
3507         args.minlen = args.maxlen = ap->minlen;
3508         args.total = ap->total;
3509
3510         args.alignment = 1;
3511         args.minalignslop = 0;
3512
3513         args.minleft = ap->minleft;
3514         args.wasdel = ap->wasdel;
3515         args.resv = XFS_AG_RESV_NONE;
3516         args.datatype = ap->datatype;
3517
3518         error = xfs_alloc_vextent_first_ag(&args, ap->blkno);
3519         if (error)
3520                 return error;
3521
3522         if (args.fsbno != NULLFSBLOCK) {
3523                 xfs_bmap_process_allocated_extent(ap, &args, orig_offset,
3524                         orig_length);
3525         } else {
3526                 ap->blkno = NULLFSBLOCK;
3527                 ap->length = 0;
3528         }
3529
3530         return 0;
3531 }
3532 #else
3533
3534 #define xfs_bmap_exact_minlen_extent_alloc(bma) (-EFSCORRUPTED)
3535
3536 #endif
3537
3538 /*
3539  * If we are not low on available data blocks and we are allocating at
3540  * EOF, optimise allocation for contiguous file extension and/or stripe
3541  * alignment of the new extent.
3542  *
3543  * NOTE: ap->aeof is only set if the allocation length is >= the
3544  * stripe unit and the allocation offset is at the end of file.
3545  */
3546 static int
3547 xfs_bmap_btalloc_at_eof(
3548         struct xfs_bmalloca     *ap,
3549         struct xfs_alloc_arg    *args,
3550         xfs_extlen_t            blen,
3551         int                     stripe_align,
3552         bool                    ag_only)
3553 {
3554         struct xfs_mount        *mp = args->mp;
3555         struct xfs_perag        *caller_pag = args->pag;
3556         int                     error;
3557
3558         /*
3559          * If there are already extents in the file, try an exact EOF block
3560          * allocation to extend the file as a contiguous extent. If that fails,
3561          * or it's the first allocation in a file, just try for a stripe aligned
3562          * allocation.
3563          */
3564         if (ap->offset) {
3565                 xfs_extlen_t    nextminlen = 0;
3566
3567                 /*
3568                  * Compute the minlen+alignment for the next case.  Set slop so
3569                  * that the value of minlen+alignment+slop doesn't go up between
3570                  * the calls.
3571                  */
3572                 args->alignment = 1;
3573                 if (blen > stripe_align && blen <= args->maxlen)
3574                         nextminlen = blen - stripe_align;
3575                 else
3576                         nextminlen = args->minlen;
3577                 if (nextminlen + stripe_align > args->minlen + 1)
3578                         args->minalignslop = nextminlen + stripe_align -
3579                                         args->minlen - 1;
3580                 else
3581                         args->minalignslop = 0;
3582
3583                 if (!caller_pag)
3584                         args->pag = xfs_perag_get(mp, XFS_FSB_TO_AGNO(mp, ap->blkno));
3585                 error = xfs_alloc_vextent_exact_bno(args, ap->blkno);
3586                 if (!caller_pag) {
3587                         xfs_perag_put(args->pag);
3588                         args->pag = NULL;
3589                 }
3590                 if (error)
3591                         return error;
3592
3593                 if (args->fsbno != NULLFSBLOCK)
3594                         return 0;
3595                 /*
3596                  * Exact allocation failed. Reset to try an aligned allocation
3597                  * according to the original allocation specification.
3598                  */
3599                 args->alignment = stripe_align;
3600                 args->minlen = nextminlen;
3601                 args->minalignslop = 0;
3602         } else {
3603                 /*
3604                  * Adjust minlen to try and preserve alignment if we
3605                  * can't guarantee an aligned maxlen extent.
3606                  */
3607                 args->alignment = stripe_align;
3608                 if (blen > args->alignment &&
3609                     blen <= args->maxlen + args->alignment)
3610                         args->minlen = blen - args->alignment;
3611                 args->minalignslop = 0;
3612         }
3613
3614         if (ag_only) {
3615                 error = xfs_alloc_vextent_near_bno(args, ap->blkno);
3616         } else {
3617                 args->pag = NULL;
3618                 error = xfs_alloc_vextent_start_ag(args, ap->blkno);
3619                 ASSERT(args->pag == NULL);
3620                 args->pag = caller_pag;
3621         }
3622         if (error)
3623                 return error;
3624
3625         if (args->fsbno != NULLFSBLOCK)
3626                 return 0;
3627
3628         /*
3629          * Allocation failed, so turn return the allocation args to their
3630          * original non-aligned state so the caller can proceed on allocation
3631          * failure as if this function was never called.
3632          */
3633         args->alignment = 1;
3634         return 0;
3635 }
3636
3637 /*
3638  * We have failed multiple allocation attempts so now are in a low space
3639  * allocation situation. Try a locality first full filesystem minimum length
3640  * allocation whilst still maintaining necessary total block reservation
3641  * requirements.
3642  *
3643  * If that fails, we are now critically low on space, so perform a last resort
3644  * allocation attempt: no reserve, no locality, blocking, minimum length, full
3645  * filesystem free space scan. We also indicate to future allocations in this
3646  * transaction that we are critically low on space so they don't waste time on
3647  * allocation modes that are unlikely to succeed.
3648  */
3649 int
3650 xfs_bmap_btalloc_low_space(
3651         struct xfs_bmalloca     *ap,
3652         struct xfs_alloc_arg    *args)
3653 {
3654         int                     error;
3655
3656         if (args->minlen > ap->minlen) {
3657                 args->minlen = ap->minlen;
3658                 error = xfs_alloc_vextent_start_ag(args, ap->blkno);
3659                 if (error || args->fsbno != NULLFSBLOCK)
3660                         return error;
3661         }
3662
3663         /* Last ditch attempt before failure is declared. */
3664         args->total = ap->minlen;
3665         error = xfs_alloc_vextent_first_ag(args, 0);
3666         if (error)
3667                 return error;
3668         ap->tp->t_flags |= XFS_TRANS_LOWMODE;
3669         return 0;
3670 }
3671
3672 static int
3673 xfs_bmap_btalloc_filestreams(
3674         struct xfs_bmalloca     *ap,
3675         struct xfs_alloc_arg    *args,
3676         int                     stripe_align)
3677 {
3678         xfs_extlen_t            blen = 0;
3679         int                     error = 0;
3680
3681
3682         error = xfs_filestream_select_ag(ap, args, &blen);
3683         if (error)
3684                 return error;
3685         ASSERT(args->pag);
3686
3687         /*
3688          * If we are in low space mode, then optimal allocation will fail so
3689          * prepare for minimal allocation and jump to the low space algorithm
3690          * immediately.
3691          */
3692         if (ap->tp->t_flags & XFS_TRANS_LOWMODE) {
3693                 args->minlen = ap->minlen;
3694                 ASSERT(args->fsbno == NULLFSBLOCK);
3695                 goto out_low_space;
3696         }
3697
3698         args->minlen = xfs_bmap_select_minlen(ap, args, blen);
3699         if (ap->aeof)
3700                 error = xfs_bmap_btalloc_at_eof(ap, args, blen, stripe_align,
3701                                 true);
3702
3703         if (!error && args->fsbno == NULLFSBLOCK)
3704                 error = xfs_alloc_vextent_near_bno(args, ap->blkno);
3705
3706 out_low_space:
3707         /*
3708          * We are now done with the perag reference for the filestreams
3709          * association provided by xfs_filestream_select_ag(). Release it now as
3710          * we've either succeeded, had a fatal error or we are out of space and
3711          * need to do a full filesystem scan for free space which will take it's
3712          * own references.
3713          */
3714         xfs_perag_rele(args->pag);
3715         args->pag = NULL;
3716         if (error || args->fsbno != NULLFSBLOCK)
3717                 return error;
3718
3719         return xfs_bmap_btalloc_low_space(ap, args);
3720 }
3721
3722 static int
3723 xfs_bmap_btalloc_best_length(
3724         struct xfs_bmalloca     *ap,
3725         struct xfs_alloc_arg    *args,
3726         int                     stripe_align)
3727 {
3728         xfs_extlen_t            blen = 0;
3729         int                     error;
3730
3731         ap->blkno = XFS_INO_TO_FSB(args->mp, ap->ip->i_ino);
3732         xfs_bmap_adjacent(ap);
3733
3734         /*
3735          * Search for an allocation group with a single extent large enough for
3736          * the request.  If one isn't found, then adjust the minimum allocation
3737          * size to the largest space found.
3738          */
3739         error = xfs_bmap_btalloc_select_lengths(ap, args, &blen);
3740         if (error)
3741                 return error;
3742
3743         /*
3744          * Don't attempt optimal EOF allocation if previous allocations barely
3745          * succeeded due to being near ENOSPC. It is highly unlikely we'll get
3746          * optimal or even aligned allocations in this case, so don't waste time
3747          * trying.
3748          */
3749         if (ap->aeof && !(ap->tp->t_flags & XFS_TRANS_LOWMODE)) {
3750                 error = xfs_bmap_btalloc_at_eof(ap, args, blen, stripe_align,
3751                                 false);
3752                 if (error || args->fsbno != NULLFSBLOCK)
3753                         return error;
3754         }
3755
3756         error = xfs_alloc_vextent_start_ag(args, ap->blkno);
3757         if (error || args->fsbno != NULLFSBLOCK)
3758                 return error;
3759
3760         return xfs_bmap_btalloc_low_space(ap, args);
3761 }
3762
3763 static int
3764 xfs_bmap_btalloc(
3765         struct xfs_bmalloca     *ap)
3766 {
3767         struct xfs_mount        *mp = ap->ip->i_mount;
3768         struct xfs_alloc_arg    args = {
3769                 .tp             = ap->tp,
3770                 .mp             = mp,
3771                 .fsbno          = NULLFSBLOCK,
3772                 .oinfo          = XFS_RMAP_OINFO_SKIP_UPDATE,
3773                 .minleft        = ap->minleft,
3774                 .wasdel         = ap->wasdel,
3775                 .resv           = XFS_AG_RESV_NONE,
3776                 .datatype       = ap->datatype,
3777                 .alignment      = 1,
3778                 .minalignslop   = 0,
3779         };
3780         xfs_fileoff_t           orig_offset;
3781         xfs_extlen_t            orig_length;
3782         int                     error;
3783         int                     stripe_align;
3784
3785         ASSERT(ap->length);
3786         orig_offset = ap->offset;
3787         orig_length = ap->length;
3788
3789         stripe_align = xfs_bmap_compute_alignments(ap, &args);
3790
3791         /* Trim the allocation back to the maximum an AG can fit. */
3792         args.maxlen = min(ap->length, mp->m_ag_max_usable);
3793
3794         if ((ap->datatype & XFS_ALLOC_USERDATA) &&
3795             xfs_inode_is_filestream(ap->ip))
3796                 error = xfs_bmap_btalloc_filestreams(ap, &args, stripe_align);
3797         else
3798                 error = xfs_bmap_btalloc_best_length(ap, &args, stripe_align);
3799         if (error)
3800                 return error;
3801
3802         if (args.fsbno != NULLFSBLOCK) {
3803                 xfs_bmap_process_allocated_extent(ap, &args, orig_offset,
3804                         orig_length);
3805         } else {
3806                 ap->blkno = NULLFSBLOCK;
3807                 ap->length = 0;
3808         }
3809         return 0;
3810 }
3811
3812 /* Trim extent to fit a logical block range. */
3813 void
3814 xfs_trim_extent(
3815         struct xfs_bmbt_irec    *irec,
3816         xfs_fileoff_t           bno,
3817         xfs_filblks_t           len)
3818 {
3819         xfs_fileoff_t           distance;
3820         xfs_fileoff_t           end = bno + len;
3821
3822         if (irec->br_startoff + irec->br_blockcount <= bno ||
3823             irec->br_startoff >= end) {
3824                 irec->br_blockcount = 0;
3825                 return;
3826         }
3827
3828         if (irec->br_startoff < bno) {
3829                 distance = bno - irec->br_startoff;
3830                 if (isnullstartblock(irec->br_startblock))
3831                         irec->br_startblock = DELAYSTARTBLOCK;
3832                 if (irec->br_startblock != DELAYSTARTBLOCK &&
3833                     irec->br_startblock != HOLESTARTBLOCK)
3834                         irec->br_startblock += distance;
3835                 irec->br_startoff += distance;
3836                 irec->br_blockcount -= distance;
3837         }
3838
3839         if (end < irec->br_startoff + irec->br_blockcount) {
3840                 distance = irec->br_startoff + irec->br_blockcount - end;
3841                 irec->br_blockcount -= distance;
3842         }
3843 }
3844
3845 /*
3846  * Trim the returned map to the required bounds
3847  */
3848 STATIC void
3849 xfs_bmapi_trim_map(
3850         struct xfs_bmbt_irec    *mval,
3851         struct xfs_bmbt_irec    *got,
3852         xfs_fileoff_t           *bno,
3853         xfs_filblks_t           len,
3854         xfs_fileoff_t           obno,
3855         xfs_fileoff_t           end,
3856         int                     n,
3857         uint32_t                flags)
3858 {
3859         if ((flags & XFS_BMAPI_ENTIRE) ||
3860             got->br_startoff + got->br_blockcount <= obno) {
3861                 *mval = *got;
3862                 if (isnullstartblock(got->br_startblock))
3863                         mval->br_startblock = DELAYSTARTBLOCK;
3864                 return;
3865         }
3866
3867         if (obno > *bno)
3868                 *bno = obno;
3869         ASSERT((*bno >= obno) || (n == 0));
3870         ASSERT(*bno < end);
3871         mval->br_startoff = *bno;
3872         if (isnullstartblock(got->br_startblock))
3873                 mval->br_startblock = DELAYSTARTBLOCK;
3874         else
3875                 mval->br_startblock = got->br_startblock +
3876                                         (*bno - got->br_startoff);
3877         /*
3878          * Return the minimum of what we got and what we asked for for
3879          * the length.  We can use the len variable here because it is
3880          * modified below and we could have been there before coming
3881          * here if the first part of the allocation didn't overlap what
3882          * was asked for.
3883          */
3884         mval->br_blockcount = XFS_FILBLKS_MIN(end - *bno,
3885                         got->br_blockcount - (*bno - got->br_startoff));
3886         mval->br_state = got->br_state;
3887         ASSERT(mval->br_blockcount <= len);
3888         return;
3889 }
3890
3891 /*
3892  * Update and validate the extent map to return
3893  */
3894 STATIC void
3895 xfs_bmapi_update_map(
3896         struct xfs_bmbt_irec    **map,
3897         xfs_fileoff_t           *bno,
3898         xfs_filblks_t           *len,
3899         xfs_fileoff_t           obno,
3900         xfs_fileoff_t           end,
3901         int                     *n,
3902         uint32_t                flags)
3903 {
3904         xfs_bmbt_irec_t *mval = *map;
3905
3906         ASSERT((flags & XFS_BMAPI_ENTIRE) ||
3907                ((mval->br_startoff + mval->br_blockcount) <= end));
3908         ASSERT((flags & XFS_BMAPI_ENTIRE) || (mval->br_blockcount <= *len) ||
3909                (mval->br_startoff < obno));
3910
3911         *bno = mval->br_startoff + mval->br_blockcount;
3912         *len = end - *bno;
3913         if (*n > 0 && mval->br_startoff == mval[-1].br_startoff) {
3914                 /* update previous map with new information */
3915                 ASSERT(mval->br_startblock == mval[-1].br_startblock);
3916                 ASSERT(mval->br_blockcount > mval[-1].br_blockcount);
3917                 ASSERT(mval->br_state == mval[-1].br_state);
3918                 mval[-1].br_blockcount = mval->br_blockcount;
3919                 mval[-1].br_state = mval->br_state;
3920         } else if (*n > 0 && mval->br_startblock != DELAYSTARTBLOCK &&
3921                    mval[-1].br_startblock != DELAYSTARTBLOCK &&
3922                    mval[-1].br_startblock != HOLESTARTBLOCK &&
3923                    mval->br_startblock == mval[-1].br_startblock +
3924                                           mval[-1].br_blockcount &&
3925                    mval[-1].br_state == mval->br_state) {
3926                 ASSERT(mval->br_startoff ==
3927                        mval[-1].br_startoff + mval[-1].br_blockcount);
3928                 mval[-1].br_blockcount += mval->br_blockcount;
3929         } else if (*n > 0 &&
3930                    mval->br_startblock == DELAYSTARTBLOCK &&
3931                    mval[-1].br_startblock == DELAYSTARTBLOCK &&
3932                    mval->br_startoff ==
3933                    mval[-1].br_startoff + mval[-1].br_blockcount) {
3934                 mval[-1].br_blockcount += mval->br_blockcount;
3935                 mval[-1].br_state = mval->br_state;
3936         } else if (!((*n == 0) &&
3937                      ((mval->br_startoff + mval->br_blockcount) <=
3938                       obno))) {
3939                 mval++;
3940                 (*n)++;
3941         }
3942         *map = mval;
3943 }
3944
3945 /*
3946  * Map file blocks to filesystem blocks without allocation.
3947  */
3948 int
3949 xfs_bmapi_read(
3950         struct xfs_inode        *ip,
3951         xfs_fileoff_t           bno,
3952         xfs_filblks_t           len,
3953         struct xfs_bmbt_irec    *mval,
3954         int                     *nmap,
3955         uint32_t                flags)
3956 {
3957         struct xfs_mount        *mp = ip->i_mount;
3958         int                     whichfork = xfs_bmapi_whichfork(flags);
3959         struct xfs_ifork        *ifp = xfs_ifork_ptr(ip, whichfork);
3960         struct xfs_bmbt_irec    got;
3961         xfs_fileoff_t           obno;
3962         xfs_fileoff_t           end;
3963         struct xfs_iext_cursor  icur;
3964         int                     error;
3965         bool                    eof = false;
3966         int                     n = 0;
3967
3968         ASSERT(*nmap >= 1);
3969         ASSERT(!(flags & ~(XFS_BMAPI_ATTRFORK | XFS_BMAPI_ENTIRE)));
3970         xfs_assert_ilocked(ip, XFS_ILOCK_SHARED | XFS_ILOCK_EXCL);
3971
3972         if (WARN_ON_ONCE(!ifp)) {
3973                 xfs_bmap_mark_sick(ip, whichfork);
3974                 return -EFSCORRUPTED;
3975         }
3976
3977         if (XFS_IS_CORRUPT(mp, !xfs_ifork_has_extents(ifp)) ||
3978             XFS_TEST_ERROR(false, mp, XFS_ERRTAG_BMAPIFORMAT)) {
3979                 xfs_bmap_mark_sick(ip, whichfork);
3980                 return -EFSCORRUPTED;
3981         }
3982
3983         if (xfs_is_shutdown(mp))
3984                 return -EIO;
3985
3986         XFS_STATS_INC(mp, xs_blk_mapr);
3987
3988         error = xfs_iread_extents(NULL, ip, whichfork);
3989         if (error)
3990                 return error;
3991
3992         if (!xfs_iext_lookup_extent(ip, ifp, bno, &icur, &got))
3993                 eof = true;
3994         end = bno + len;
3995         obno = bno;
3996
3997         while (bno < end && n < *nmap) {
3998                 /* Reading past eof, act as though there's a hole up to end. */
3999                 if (eof)
4000                         got.br_startoff = end;
4001                 if (got.br_startoff > bno) {
4002                         /* Reading in a hole.  */
4003                         mval->br_startoff = bno;
4004                         mval->br_startblock = HOLESTARTBLOCK;
4005                         mval->br_blockcount =
4006                                 XFS_FILBLKS_MIN(len, got.br_startoff - bno);
4007                         mval->br_state = XFS_EXT_NORM;
4008                         bno += mval->br_blockcount;
4009                         len -= mval->br_blockcount;
4010                         mval++;
4011                         n++;
4012                         continue;
4013                 }
4014
4015                 /* set up the extent map to return. */
4016                 xfs_bmapi_trim_map(mval, &got, &bno, len, obno, end, n, flags);
4017                 xfs_bmapi_update_map(&mval, &bno, &len, obno, end, &n, flags);
4018
4019                 /* If we're done, stop now. */
4020                 if (bno >= end || n >= *nmap)
4021                         break;
4022
4023                 /* Else go on to the next record. */
4024                 if (!xfs_iext_next_extent(ifp, &icur, &got))
4025                         eof = true;
4026         }
4027         *nmap = n;
4028         return 0;
4029 }
4030
4031 /*
4032  * Add a delayed allocation extent to an inode. Blocks are reserved from the
4033  * global pool and the extent inserted into the inode in-core extent tree.
4034  *
4035  * On entry, got refers to the first extent beyond the offset of the extent to
4036  * allocate or eof is specified if no such extent exists. On return, got refers
4037  * to the extent record that was inserted to the inode fork.
4038  *
4039  * Note that the allocated extent may have been merged with contiguous extents
4040  * during insertion into the inode fork. Thus, got does not reflect the current
4041  * state of the inode fork on return. If necessary, the caller can use lastx to
4042  * look up the updated record in the inode fork.
4043  */
4044 int
4045 xfs_bmapi_reserve_delalloc(
4046         struct xfs_inode        *ip,
4047         int                     whichfork,
4048         xfs_fileoff_t           off,
4049         xfs_filblks_t           len,
4050         xfs_filblks_t           prealloc,
4051         struct xfs_bmbt_irec    *got,
4052         struct xfs_iext_cursor  *icur,
4053         int                     eof)
4054 {
4055         struct xfs_mount        *mp = ip->i_mount;
4056         struct xfs_ifork        *ifp = xfs_ifork_ptr(ip, whichfork);
4057         xfs_extlen_t            alen;
4058         xfs_extlen_t            indlen;
4059         uint64_t                fdblocks;
4060         int                     error;
4061         xfs_fileoff_t           aoff = off;
4062
4063         /*
4064          * Cap the alloc length. Keep track of prealloc so we know whether to
4065          * tag the inode before we return.
4066          */
4067         alen = XFS_FILBLKS_MIN(len + prealloc, XFS_MAX_BMBT_EXTLEN);
4068         if (!eof)
4069                 alen = XFS_FILBLKS_MIN(alen, got->br_startoff - aoff);
4070         if (prealloc && alen >= len)
4071                 prealloc = alen - len;
4072
4073         /* Figure out the extent size, adjust alen */
4074         if (whichfork == XFS_COW_FORK) {
4075                 struct xfs_bmbt_irec    prev;
4076                 xfs_extlen_t            extsz = xfs_get_cowextsz_hint(ip);
4077
4078                 if (!xfs_iext_peek_prev_extent(ifp, icur, &prev))
4079                         prev.br_startoff = NULLFILEOFF;
4080
4081                 error = xfs_bmap_extsize_align(mp, got, &prev, extsz, 0, eof,
4082                                                1, 0, &aoff, &alen);
4083                 ASSERT(!error);
4084         }
4085
4086         /*
4087          * Make a transaction-less quota reservation for delayed allocation
4088          * blocks.  This number gets adjusted later.  We return if we haven't
4089          * allocated blocks already inside this loop.
4090          */
4091         error = xfs_quota_reserve_blkres(ip, alen);
4092         if (error)
4093                 return error;
4094
4095         /*
4096          * Split changing sb for alen and indlen since they could be coming
4097          * from different places.
4098          */
4099         indlen = (xfs_extlen_t)xfs_bmap_worst_indlen(ip, alen);
4100         ASSERT(indlen > 0);
4101
4102         fdblocks = indlen;
4103         if (XFS_IS_REALTIME_INODE(ip)) {
4104                 error = xfs_dec_frextents(mp, xfs_rtb_to_rtx(mp, alen));
4105                 if (error)
4106                         goto out_unreserve_quota;
4107         } else {
4108                 fdblocks += alen;
4109         }
4110
4111         error = xfs_dec_fdblocks(mp, fdblocks, false);
4112         if (error)
4113                 goto out_unreserve_frextents;
4114
4115         ip->i_delayed_blks += alen;
4116         xfs_mod_delalloc(ip, alen, indlen);
4117
4118         got->br_startoff = aoff;
4119         got->br_startblock = nullstartblock(indlen);
4120         got->br_blockcount = alen;
4121         got->br_state = XFS_EXT_NORM;
4122
4123         xfs_bmap_add_extent_hole_delay(ip, whichfork, icur, got);
4124
4125         /*
4126          * Tag the inode if blocks were preallocated. Note that COW fork
4127          * preallocation can occur at the start or end of the extent, even when
4128          * prealloc == 0, so we must also check the aligned offset and length.
4129          */
4130         if (whichfork == XFS_DATA_FORK && prealloc)
4131                 xfs_inode_set_eofblocks_tag(ip);
4132         if (whichfork == XFS_COW_FORK && (prealloc || aoff < off || alen > len))
4133                 xfs_inode_set_cowblocks_tag(ip);
4134
4135         return 0;
4136
4137 out_unreserve_frextents:
4138         if (XFS_IS_REALTIME_INODE(ip))
4139                 xfs_add_frextents(mp, xfs_rtb_to_rtx(mp, alen));
4140 out_unreserve_quota:
4141         if (XFS_IS_QUOTA_ON(mp))
4142                 xfs_quota_unreserve_blkres(ip, alen);
4143         return error;
4144 }
4145
4146 static int
4147 xfs_bmap_alloc_userdata(
4148         struct xfs_bmalloca     *bma)
4149 {
4150         struct xfs_mount        *mp = bma->ip->i_mount;
4151         int                     whichfork = xfs_bmapi_whichfork(bma->flags);
4152         int                     error;
4153
4154         /*
4155          * Set the data type being allocated. For the data fork, the first data
4156          * in the file is treated differently to all other allocations. For the
4157          * attribute fork, we only need to ensure the allocated range is not on
4158          * the busy list.
4159          */
4160         bma->datatype = XFS_ALLOC_NOBUSY;
4161         if (whichfork == XFS_DATA_FORK || whichfork == XFS_COW_FORK) {
4162                 bma->datatype |= XFS_ALLOC_USERDATA;
4163                 if (bma->offset == 0)
4164                         bma->datatype |= XFS_ALLOC_INITIAL_USER_DATA;
4165
4166                 if (mp->m_dalign && bma->length >= mp->m_dalign) {
4167                         error = xfs_bmap_isaeof(bma, whichfork);
4168                         if (error)
4169                                 return error;
4170                 }
4171
4172                 if (XFS_IS_REALTIME_INODE(bma->ip))
4173                         return xfs_bmap_rtalloc(bma);
4174         }
4175
4176         if (unlikely(XFS_TEST_ERROR(false, mp,
4177                         XFS_ERRTAG_BMAP_ALLOC_MINLEN_EXTENT)))
4178                 return xfs_bmap_exact_minlen_extent_alloc(bma);
4179
4180         return xfs_bmap_btalloc(bma);
4181 }
4182
4183 static int
4184 xfs_bmapi_allocate(
4185         struct xfs_bmalloca     *bma)
4186 {
4187         struct xfs_mount        *mp = bma->ip->i_mount;
4188         int                     whichfork = xfs_bmapi_whichfork(bma->flags);
4189         struct xfs_ifork        *ifp = xfs_ifork_ptr(bma->ip, whichfork);
4190         int                     error;
4191
4192         ASSERT(bma->length > 0);
4193         ASSERT(bma->length <= XFS_MAX_BMBT_EXTLEN);
4194
4195         if (bma->flags & XFS_BMAPI_CONTIG)
4196                 bma->minlen = bma->length;
4197         else
4198                 bma->minlen = 1;
4199
4200         if (bma->flags & XFS_BMAPI_METADATA) {
4201                 if (unlikely(XFS_TEST_ERROR(false, mp,
4202                                 XFS_ERRTAG_BMAP_ALLOC_MINLEN_EXTENT)))
4203                         error = xfs_bmap_exact_minlen_extent_alloc(bma);
4204                 else
4205                         error = xfs_bmap_btalloc(bma);
4206         } else {
4207                 error = xfs_bmap_alloc_userdata(bma);
4208         }
4209         if (error)
4210                 return error;
4211         if (bma->blkno == NULLFSBLOCK)
4212                 return -ENOSPC;
4213
4214         if (WARN_ON_ONCE(!xfs_valid_startblock(bma->ip, bma->blkno))) {
4215                 xfs_bmap_mark_sick(bma->ip, whichfork);
4216                 return -EFSCORRUPTED;
4217         }
4218
4219         if (bma->flags & XFS_BMAPI_ZERO) {
4220                 error = xfs_zero_extent(bma->ip, bma->blkno, bma->length);
4221                 if (error)
4222                         return error;
4223         }
4224
4225         if (ifp->if_format == XFS_DINODE_FMT_BTREE && !bma->cur)
4226                 bma->cur = xfs_bmbt_init_cursor(mp, bma->tp, bma->ip, whichfork);
4227         /*
4228          * Bump the number of extents we've allocated
4229          * in this call.
4230          */
4231         bma->nallocs++;
4232
4233         if (bma->cur && bma->wasdel)
4234                 bma->cur->bc_flags |= XFS_BTREE_BMBT_WASDEL;
4235
4236         bma->got.br_startoff = bma->offset;
4237         bma->got.br_startblock = bma->blkno;
4238         bma->got.br_blockcount = bma->length;
4239         bma->got.br_state = XFS_EXT_NORM;
4240
4241         if (bma->flags & XFS_BMAPI_PREALLOC)
4242                 bma->got.br_state = XFS_EXT_UNWRITTEN;
4243
4244         if (bma->wasdel)
4245                 error = xfs_bmap_add_extent_delay_real(bma, whichfork);
4246         else
4247                 error = xfs_bmap_add_extent_hole_real(bma->tp, bma->ip,
4248                                 whichfork, &bma->icur, &bma->cur, &bma->got,
4249                                 &bma->logflags, bma->flags);
4250         if (error)
4251                 return error;
4252
4253         /*
4254          * Update our extent pointer, given that xfs_bmap_add_extent_delay_real
4255          * or xfs_bmap_add_extent_hole_real might have merged it into one of
4256          * the neighbouring ones.
4257          */
4258         xfs_iext_get_extent(ifp, &bma->icur, &bma->got);
4259
4260         ASSERT(bma->got.br_startoff <= bma->offset);
4261         ASSERT(bma->got.br_startoff + bma->got.br_blockcount >=
4262                bma->offset + bma->length);
4263         ASSERT(bma->got.br_state == XFS_EXT_NORM ||
4264                bma->got.br_state == XFS_EXT_UNWRITTEN);
4265         return 0;
4266 }
4267
4268 STATIC int
4269 xfs_bmapi_convert_unwritten(
4270         struct xfs_bmalloca     *bma,
4271         struct xfs_bmbt_irec    *mval,
4272         xfs_filblks_t           len,
4273         uint32_t                flags)
4274 {
4275         int                     whichfork = xfs_bmapi_whichfork(flags);
4276         struct xfs_ifork        *ifp = xfs_ifork_ptr(bma->ip, whichfork);
4277         int                     tmp_logflags = 0;
4278         int                     error;
4279
4280         /* check if we need to do unwritten->real conversion */
4281         if (mval->br_state == XFS_EXT_UNWRITTEN &&
4282             (flags & XFS_BMAPI_PREALLOC))
4283                 return 0;
4284
4285         /* check if we need to do real->unwritten conversion */
4286         if (mval->br_state == XFS_EXT_NORM &&
4287             (flags & (XFS_BMAPI_PREALLOC | XFS_BMAPI_CONVERT)) !=
4288                         (XFS_BMAPI_PREALLOC | XFS_BMAPI_CONVERT))
4289                 return 0;
4290
4291         /*
4292          * Modify (by adding) the state flag, if writing.
4293          */
4294         ASSERT(mval->br_blockcount <= len);
4295         if (ifp->if_format == XFS_DINODE_FMT_BTREE && !bma->cur) {
4296                 bma->cur = xfs_bmbt_init_cursor(bma->ip->i_mount, bma->tp,
4297                                         bma->ip, whichfork);
4298         }
4299         mval->br_state = (mval->br_state == XFS_EXT_UNWRITTEN)
4300                                 ? XFS_EXT_NORM : XFS_EXT_UNWRITTEN;
4301
4302         /*
4303          * Before insertion into the bmbt, zero the range being converted
4304          * if required.
4305          */
4306         if (flags & XFS_BMAPI_ZERO) {
4307                 error = xfs_zero_extent(bma->ip, mval->br_startblock,
4308                                         mval->br_blockcount);
4309                 if (error)
4310                         return error;
4311         }
4312
4313         error = xfs_bmap_add_extent_unwritten_real(bma->tp, bma->ip, whichfork,
4314                         &bma->icur, &bma->cur, mval, &tmp_logflags);
4315         /*
4316          * Log the inode core unconditionally in the unwritten extent conversion
4317          * path because the conversion might not have done so (e.g., if the
4318          * extent count hasn't changed). We need to make sure the inode is dirty
4319          * in the transaction for the sake of fsync(), even if nothing has
4320          * changed, because fsync() will not force the log for this transaction
4321          * unless it sees the inode pinned.
4322          *
4323          * Note: If we're only converting cow fork extents, there aren't
4324          * any on-disk updates to make, so we don't need to log anything.
4325          */
4326         if (whichfork != XFS_COW_FORK)
4327                 bma->logflags |= tmp_logflags | XFS_ILOG_CORE;
4328         if (error)
4329                 return error;
4330
4331         /*
4332          * Update our extent pointer, given that
4333          * xfs_bmap_add_extent_unwritten_real might have merged it into one
4334          * of the neighbouring ones.
4335          */
4336         xfs_iext_get_extent(ifp, &bma->icur, &bma->got);
4337
4338         /*
4339          * We may have combined previously unwritten space with written space,
4340          * so generate another request.
4341          */
4342         if (mval->br_blockcount < len)
4343                 return -EAGAIN;
4344         return 0;
4345 }
4346
4347 xfs_extlen_t
4348 xfs_bmapi_minleft(
4349         struct xfs_trans        *tp,
4350         struct xfs_inode        *ip,
4351         int                     fork)
4352 {
4353         struct xfs_ifork        *ifp = xfs_ifork_ptr(ip, fork);
4354
4355         if (tp && tp->t_highest_agno != NULLAGNUMBER)
4356                 return 0;
4357         if (ifp->if_format != XFS_DINODE_FMT_BTREE)
4358                 return 1;
4359         return be16_to_cpu(ifp->if_broot->bb_level) + 1;
4360 }
4361
4362 /*
4363  * Log whatever the flags say, even if error.  Otherwise we might miss detecting
4364  * a case where the data is changed, there's an error, and it's not logged so we
4365  * don't shutdown when we should.  Don't bother logging extents/btree changes if
4366  * we converted to the other format.
4367  */
4368 static void
4369 xfs_bmapi_finish(
4370         struct xfs_bmalloca     *bma,
4371         int                     whichfork,
4372         int                     error)
4373 {
4374         struct xfs_ifork        *ifp = xfs_ifork_ptr(bma->ip, whichfork);
4375
4376         if ((bma->logflags & xfs_ilog_fext(whichfork)) &&
4377             ifp->if_format != XFS_DINODE_FMT_EXTENTS)
4378                 bma->logflags &= ~xfs_ilog_fext(whichfork);
4379         else if ((bma->logflags & xfs_ilog_fbroot(whichfork)) &&
4380                  ifp->if_format != XFS_DINODE_FMT_BTREE)
4381                 bma->logflags &= ~xfs_ilog_fbroot(whichfork);
4382
4383         if (bma->logflags)
4384                 xfs_trans_log_inode(bma->tp, bma->ip, bma->logflags);
4385         if (bma->cur)
4386                 xfs_btree_del_cursor(bma->cur, error);
4387 }
4388
4389 /*
4390  * Map file blocks to filesystem blocks, and allocate blocks or convert the
4391  * extent state if necessary.  Details behaviour is controlled by the flags
4392  * parameter.  Only allocates blocks from a single allocation group, to avoid
4393  * locking problems.
4394  *
4395  * Returns 0 on success and places the extent mappings in mval.  nmaps is used
4396  * as an input/output parameter where the caller specifies the maximum number
4397  * of mappings that may be returned and xfs_bmapi_write passes back the number
4398  * of mappings (including existing mappings) it found.
4399  *
4400  * Returns a negative error code on failure, including -ENOSPC when it could not
4401  * allocate any blocks and -ENOSR when it did allocate blocks to convert a
4402  * delalloc range, but those blocks were before the passed in range.
4403  */
4404 int
4405 xfs_bmapi_write(
4406         struct xfs_trans        *tp,            /* transaction pointer */
4407         struct xfs_inode        *ip,            /* incore inode */
4408         xfs_fileoff_t           bno,            /* starting file offs. mapped */
4409         xfs_filblks_t           len,            /* length to map in file */
4410         uint32_t                flags,          /* XFS_BMAPI_... */
4411         xfs_extlen_t            total,          /* total blocks needed */
4412         struct xfs_bmbt_irec    *mval,          /* output: map values */
4413         int                     *nmap)          /* i/o: mval size/count */
4414 {
4415         struct xfs_bmalloca     bma = {
4416                 .tp             = tp,
4417                 .ip             = ip,
4418                 .total          = total,
4419         };
4420         struct xfs_mount        *mp = ip->i_mount;
4421         int                     whichfork = xfs_bmapi_whichfork(flags);
4422         struct xfs_ifork        *ifp = xfs_ifork_ptr(ip, whichfork);
4423         xfs_fileoff_t           end;            /* end of mapped file region */
4424         bool                    eof = false;    /* after the end of extents */
4425         int                     error;          /* error return */
4426         int                     n;              /* current extent index */
4427         xfs_fileoff_t           obno;           /* old block number (offset) */
4428
4429 #ifdef DEBUG
4430         xfs_fileoff_t           orig_bno;       /* original block number value */
4431         int                     orig_flags;     /* original flags arg value */
4432         xfs_filblks_t           orig_len;       /* original value of len arg */
4433         struct xfs_bmbt_irec    *orig_mval;     /* original value of mval */
4434         int                     orig_nmap;      /* original value of *nmap */
4435
4436         orig_bno = bno;
4437         orig_len = len;
4438         orig_flags = flags;
4439         orig_mval = mval;
4440         orig_nmap = *nmap;
4441 #endif
4442
4443         ASSERT(*nmap >= 1);
4444         ASSERT(*nmap <= XFS_BMAP_MAX_NMAP);
4445         ASSERT(tp != NULL);
4446         ASSERT(len > 0);
4447         ASSERT(ifp->if_format != XFS_DINODE_FMT_LOCAL);
4448         xfs_assert_ilocked(ip, XFS_ILOCK_EXCL);
4449         ASSERT(!(flags & XFS_BMAPI_REMAP));
4450
4451         /* zeroing is for currently only for data extents, not metadata */
4452         ASSERT((flags & (XFS_BMAPI_METADATA | XFS_BMAPI_ZERO)) !=
4453                         (XFS_BMAPI_METADATA | XFS_BMAPI_ZERO));
4454         /*
4455          * we can allocate unwritten extents or pre-zero allocated blocks,
4456          * but it makes no sense to do both at once. This would result in
4457          * zeroing the unwritten extent twice, but it still being an
4458          * unwritten extent....
4459          */
4460         ASSERT((flags & (XFS_BMAPI_PREALLOC | XFS_BMAPI_ZERO)) !=
4461                         (XFS_BMAPI_PREALLOC | XFS_BMAPI_ZERO));
4462
4463         if (XFS_IS_CORRUPT(mp, !xfs_ifork_has_extents(ifp)) ||
4464             XFS_TEST_ERROR(false, mp, XFS_ERRTAG_BMAPIFORMAT)) {
4465                 xfs_bmap_mark_sick(ip, whichfork);
4466                 return -EFSCORRUPTED;
4467         }
4468
4469         if (xfs_is_shutdown(mp))
4470                 return -EIO;
4471
4472         XFS_STATS_INC(mp, xs_blk_mapw);
4473
4474         error = xfs_iread_extents(tp, ip, whichfork);
4475         if (error)
4476                 goto error0;
4477
4478         if (!xfs_iext_lookup_extent(ip, ifp, bno, &bma.icur, &bma.got))
4479                 eof = true;
4480         if (!xfs_iext_peek_prev_extent(ifp, &bma.icur, &bma.prev))
4481                 bma.prev.br_startoff = NULLFILEOFF;
4482         bma.minleft = xfs_bmapi_minleft(tp, ip, whichfork);
4483
4484         n = 0;
4485         end = bno + len;
4486         obno = bno;
4487         while (bno < end && n < *nmap) {
4488                 bool                    need_alloc = false, wasdelay = false;
4489
4490                 /* in hole or beyond EOF? */
4491                 if (eof || bma.got.br_startoff > bno) {
4492                         /*
4493                          * CoW fork conversions should /never/ hit EOF or
4494                          * holes.  There should always be something for us
4495                          * to work on.
4496                          */
4497                         ASSERT(!((flags & XFS_BMAPI_CONVERT) &&
4498                                  (flags & XFS_BMAPI_COWFORK)));
4499
4500                         need_alloc = true;
4501                 } else if (isnullstartblock(bma.got.br_startblock)) {
4502                         wasdelay = true;
4503                 }
4504
4505                 /*
4506                  * First, deal with the hole before the allocated space
4507                  * that we found, if any.
4508                  */
4509                 if (need_alloc || wasdelay) {
4510                         bma.eof = eof;
4511                         bma.conv = !!(flags & XFS_BMAPI_CONVERT);
4512                         bma.wasdel = wasdelay;
4513                         bma.offset = bno;
4514                         bma.flags = flags;
4515
4516                         /*
4517                          * There's a 32/64 bit type mismatch between the
4518                          * allocation length request (which can be 64 bits in
4519                          * length) and the bma length request, which is
4520                          * xfs_extlen_t and therefore 32 bits. Hence we have to
4521                          * be careful and do the min() using the larger type to
4522                          * avoid overflows.
4523                          */
4524                         bma.length = XFS_FILBLKS_MIN(len, XFS_MAX_BMBT_EXTLEN);
4525
4526                         if (wasdelay) {
4527                                 bma.length = XFS_FILBLKS_MIN(bma.length,
4528                                         bma.got.br_blockcount -
4529                                         (bno - bma.got.br_startoff));
4530                         } else {
4531                                 if (!eof)
4532                                         bma.length = XFS_FILBLKS_MIN(bma.length,
4533                                                 bma.got.br_startoff - bno);
4534                         }
4535
4536                         ASSERT(bma.length > 0);
4537                         error = xfs_bmapi_allocate(&bma);
4538                         if (error) {
4539                                 /*
4540                                  * If we already allocated space in a previous
4541                                  * iteration return what we go so far when
4542                                  * running out of space.
4543                                  */
4544                                 if (error == -ENOSPC && bma.nallocs)
4545                                         break;
4546                                 goto error0;
4547                         }
4548
4549                         /*
4550                          * If this is a CoW allocation, record the data in
4551                          * the refcount btree for orphan recovery.
4552                          */
4553                         if (whichfork == XFS_COW_FORK)
4554                                 xfs_refcount_alloc_cow_extent(tp, bma.blkno,
4555                                                 bma.length);
4556                 }
4557
4558                 /* Deal with the allocated space we found.  */
4559                 xfs_bmapi_trim_map(mval, &bma.got, &bno, len, obno,
4560                                                         end, n, flags);
4561
4562                 /* Execute unwritten extent conversion if necessary */
4563                 error = xfs_bmapi_convert_unwritten(&bma, mval, len, flags);
4564                 if (error == -EAGAIN)
4565                         continue;
4566                 if (error)
4567                         goto error0;
4568
4569                 /* update the extent map to return */
4570                 xfs_bmapi_update_map(&mval, &bno, &len, obno, end, &n, flags);
4571
4572                 /*
4573                  * If we're done, stop now.  Stop when we've allocated
4574                  * XFS_BMAP_MAX_NMAP extents no matter what.  Otherwise
4575                  * the transaction may get too big.
4576                  */
4577                 if (bno >= end || n >= *nmap || bma.nallocs >= *nmap)
4578                         break;
4579
4580                 /* Else go on to the next record. */
4581                 bma.prev = bma.got;
4582                 if (!xfs_iext_next_extent(ifp, &bma.icur, &bma.got))
4583                         eof = true;
4584         }
4585
4586         error = xfs_bmap_btree_to_extents(tp, ip, bma.cur, &bma.logflags,
4587                         whichfork);
4588         if (error)
4589                 goto error0;
4590
4591         ASSERT(ifp->if_format != XFS_DINODE_FMT_BTREE ||
4592                ifp->if_nextents > XFS_IFORK_MAXEXT(ip, whichfork));
4593         xfs_bmapi_finish(&bma, whichfork, 0);
4594         xfs_bmap_validate_ret(orig_bno, orig_len, orig_flags, orig_mval,
4595                 orig_nmap, n);
4596
4597         /*
4598          * When converting delayed allocations, xfs_bmapi_allocate ignores
4599          * the passed in bno and always converts from the start of the found
4600          * delalloc extent.
4601          *
4602          * To avoid a successful return with *nmap set to 0, return the magic
4603          * -ENOSR error code for this particular case so that the caller can
4604          * handle it.
4605          */
4606         if (!n) {
4607                 ASSERT(bma.nallocs >= *nmap);
4608                 return -ENOSR;
4609         }
4610         *nmap = n;
4611         return 0;
4612 error0:
4613         xfs_bmapi_finish(&bma, whichfork, error);
4614         return error;
4615 }
4616
4617 /*
4618  * Convert an existing delalloc extent to real blocks based on file offset. This
4619  * attempts to allocate the entire delalloc extent and may require multiple
4620  * invocations to allocate the target offset if a large enough physical extent
4621  * is not available.
4622  */
4623 static int
4624 xfs_bmapi_convert_one_delalloc(
4625         struct xfs_inode        *ip,
4626         int                     whichfork,
4627         xfs_off_t               offset,
4628         struct iomap            *iomap,
4629         unsigned int            *seq)
4630 {
4631         struct xfs_ifork        *ifp = xfs_ifork_ptr(ip, whichfork);
4632         struct xfs_mount        *mp = ip->i_mount;
4633         xfs_fileoff_t           offset_fsb = XFS_B_TO_FSBT(mp, offset);
4634         struct xfs_bmalloca     bma = { NULL };
4635         uint16_t                flags = 0;
4636         struct xfs_trans        *tp;
4637         int                     error;
4638
4639         if (whichfork == XFS_COW_FORK)
4640                 flags |= IOMAP_F_SHARED;
4641
4642         /*
4643          * Space for the extent and indirect blocks was reserved when the
4644          * delalloc extent was created so there's no need to do so here.
4645          */
4646         error = xfs_trans_alloc(mp, &M_RES(mp)->tr_write, 0, 0,
4647                                 XFS_TRANS_RESERVE, &tp);
4648         if (error)
4649                 return error;
4650
4651         xfs_ilock(ip, XFS_ILOCK_EXCL);
4652         xfs_trans_ijoin(tp, ip, 0);
4653
4654         error = xfs_iext_count_extend(tp, ip, whichfork,
4655                         XFS_IEXT_ADD_NOSPLIT_CNT);
4656         if (error)
4657                 goto out_trans_cancel;
4658
4659         if (!xfs_iext_lookup_extent(ip, ifp, offset_fsb, &bma.icur, &bma.got) ||
4660             bma.got.br_startoff > offset_fsb) {
4661                 /*
4662                  * No extent found in the range we are trying to convert.  This
4663                  * should only happen for the COW fork, where another thread
4664                  * might have moved the extent to the data fork in the meantime.
4665                  */
4666                 WARN_ON_ONCE(whichfork != XFS_COW_FORK);
4667                 error = -EAGAIN;
4668                 goto out_trans_cancel;
4669         }
4670
4671         /*
4672          * If we find a real extent here we raced with another thread converting
4673          * the extent.  Just return the real extent at this offset.
4674          */
4675         if (!isnullstartblock(bma.got.br_startblock)) {
4676                 xfs_bmbt_to_iomap(ip, iomap, &bma.got, 0, flags,
4677                                 xfs_iomap_inode_sequence(ip, flags));
4678                 if (seq)
4679                         *seq = READ_ONCE(ifp->if_seq);
4680                 goto out_trans_cancel;
4681         }
4682
4683         bma.tp = tp;
4684         bma.ip = ip;
4685         bma.wasdel = true;
4686         bma.minleft = xfs_bmapi_minleft(tp, ip, whichfork);
4687
4688         /*
4689          * Always allocate convert from the start of the delalloc extent even if
4690          * that is outside the passed in range to create large contiguous
4691          * extents on disk.
4692          */
4693         bma.offset = bma.got.br_startoff;
4694         bma.length = bma.got.br_blockcount;
4695
4696         /*
4697          * When we're converting the delalloc reservations backing dirty pages
4698          * in the page cache, we must be careful about how we create the new
4699          * extents:
4700          *
4701          * New CoW fork extents are created unwritten, turned into real extents
4702          * when we're about to write the data to disk, and mapped into the data
4703          * fork after the write finishes.  End of story.
4704          *
4705          * New data fork extents must be mapped in as unwritten and converted
4706          * to real extents after the write succeeds to avoid exposing stale
4707          * disk contents if we crash.
4708          */
4709         bma.flags = XFS_BMAPI_PREALLOC;
4710         if (whichfork == XFS_COW_FORK)
4711                 bma.flags |= XFS_BMAPI_COWFORK;
4712
4713         if (!xfs_iext_peek_prev_extent(ifp, &bma.icur, &bma.prev))
4714                 bma.prev.br_startoff = NULLFILEOFF;
4715
4716         error = xfs_bmapi_allocate(&bma);
4717         if (error)
4718                 goto out_finish;
4719
4720         XFS_STATS_ADD(mp, xs_xstrat_bytes, XFS_FSB_TO_B(mp, bma.length));
4721         XFS_STATS_INC(mp, xs_xstrat_quick);
4722
4723         ASSERT(!isnullstartblock(bma.got.br_startblock));
4724         xfs_bmbt_to_iomap(ip, iomap, &bma.got, 0, flags,
4725                                 xfs_iomap_inode_sequence(ip, flags));
4726         if (seq)
4727                 *seq = READ_ONCE(ifp->if_seq);
4728
4729         if (whichfork == XFS_COW_FORK)
4730                 xfs_refcount_alloc_cow_extent(tp, bma.blkno, bma.length);
4731
4732         error = xfs_bmap_btree_to_extents(tp, ip, bma.cur, &bma.logflags,
4733                         whichfork);
4734         if (error)
4735                 goto out_finish;
4736
4737         xfs_bmapi_finish(&bma, whichfork, 0);
4738         error = xfs_trans_commit(tp);
4739         xfs_iunlock(ip, XFS_ILOCK_EXCL);
4740         return error;
4741
4742 out_finish:
4743         xfs_bmapi_finish(&bma, whichfork, error);
4744 out_trans_cancel:
4745         xfs_trans_cancel(tp);
4746         xfs_iunlock(ip, XFS_ILOCK_EXCL);
4747         return error;
4748 }
4749
4750 /*
4751  * Pass in a dellalloc extent and convert it to real extents, return the real
4752  * extent that maps offset_fsb in iomap.
4753  */
4754 int
4755 xfs_bmapi_convert_delalloc(
4756         struct xfs_inode        *ip,
4757         int                     whichfork,
4758         loff_t                  offset,
4759         struct iomap            *iomap,
4760         unsigned int            *seq)
4761 {
4762         int                     error;
4763
4764         /*
4765          * Attempt to allocate whatever delalloc extent currently backs offset
4766          * and put the result into iomap.  Allocate in a loop because it may
4767          * take several attempts to allocate real blocks for a contiguous
4768          * delalloc extent if free space is sufficiently fragmented.
4769          */
4770         do {
4771                 error = xfs_bmapi_convert_one_delalloc(ip, whichfork, offset,
4772                                         iomap, seq);
4773                 if (error)
4774                         return error;
4775         } while (iomap->offset + iomap->length <= offset);
4776
4777         return 0;
4778 }
4779
4780 int
4781 xfs_bmapi_remap(
4782         struct xfs_trans        *tp,
4783         struct xfs_inode        *ip,
4784         xfs_fileoff_t           bno,
4785         xfs_filblks_t           len,
4786         xfs_fsblock_t           startblock,
4787         uint32_t                flags)
4788 {
4789         struct xfs_mount        *mp = ip->i_mount;
4790         struct xfs_ifork        *ifp;
4791         struct xfs_btree_cur    *cur = NULL;
4792         struct xfs_bmbt_irec    got;
4793         struct xfs_iext_cursor  icur;
4794         int                     whichfork = xfs_bmapi_whichfork(flags);
4795         int                     logflags = 0, error;
4796
4797         ifp = xfs_ifork_ptr(ip, whichfork);
4798         ASSERT(len > 0);
4799         ASSERT(len <= (xfs_filblks_t)XFS_MAX_BMBT_EXTLEN);
4800         xfs_assert_ilocked(ip, XFS_ILOCK_EXCL);
4801         ASSERT(!(flags & ~(XFS_BMAPI_ATTRFORK | XFS_BMAPI_PREALLOC |
4802                            XFS_BMAPI_NORMAP)));
4803         ASSERT((flags & (XFS_BMAPI_ATTRFORK | XFS_BMAPI_PREALLOC)) !=
4804                         (XFS_BMAPI_ATTRFORK | XFS_BMAPI_PREALLOC));
4805
4806         if (XFS_IS_CORRUPT(mp, !xfs_ifork_has_extents(ifp)) ||
4807             XFS_TEST_ERROR(false, mp, XFS_ERRTAG_BMAPIFORMAT)) {
4808                 xfs_bmap_mark_sick(ip, whichfork);
4809                 return -EFSCORRUPTED;
4810         }
4811
4812         if (xfs_is_shutdown(mp))
4813                 return -EIO;
4814
4815         error = xfs_iread_extents(tp, ip, whichfork);
4816         if (error)
4817                 return error;
4818
4819         if (xfs_iext_lookup_extent(ip, ifp, bno, &icur, &got)) {
4820                 /* make sure we only reflink into a hole. */
4821                 ASSERT(got.br_startoff > bno);
4822                 ASSERT(got.br_startoff - bno >= len);
4823         }
4824
4825         ip->i_nblocks += len;
4826         xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
4827
4828         if (ifp->if_format == XFS_DINODE_FMT_BTREE)
4829                 cur = xfs_bmbt_init_cursor(mp, tp, ip, whichfork);
4830
4831         got.br_startoff = bno;
4832         got.br_startblock = startblock;
4833         got.br_blockcount = len;
4834         if (flags & XFS_BMAPI_PREALLOC)
4835                 got.br_state = XFS_EXT_UNWRITTEN;
4836         else
4837                 got.br_state = XFS_EXT_NORM;
4838
4839         error = xfs_bmap_add_extent_hole_real(tp, ip, whichfork, &icur,
4840                         &cur, &got, &logflags, flags);
4841         if (error)
4842                 goto error0;
4843
4844         error = xfs_bmap_btree_to_extents(tp, ip, cur, &logflags, whichfork);
4845
4846 error0:
4847         if (ip->i_df.if_format != XFS_DINODE_FMT_EXTENTS)
4848                 logflags &= ~XFS_ILOG_DEXT;
4849         else if (ip->i_df.if_format != XFS_DINODE_FMT_BTREE)
4850                 logflags &= ~XFS_ILOG_DBROOT;
4851
4852         if (logflags)
4853                 xfs_trans_log_inode(tp, ip, logflags);
4854         if (cur)
4855                 xfs_btree_del_cursor(cur, error);
4856         return error;
4857 }
4858
4859 /*
4860  * When a delalloc extent is split (e.g., due to a hole punch), the original
4861  * indlen reservation must be shared across the two new extents that are left
4862  * behind.
4863  *
4864  * Given the original reservation and the worst case indlen for the two new
4865  * extents (as calculated by xfs_bmap_worst_indlen()), split the original
4866  * reservation fairly across the two new extents. If necessary, steal available
4867  * blocks from a deleted extent to make up a reservation deficiency (e.g., if
4868  * ores == 1). The number of stolen blocks is returned. The availability and
4869  * subsequent accounting of stolen blocks is the responsibility of the caller.
4870  */
4871 static void
4872 xfs_bmap_split_indlen(
4873         xfs_filblks_t                   ores,           /* original res. */
4874         xfs_filblks_t                   *indlen1,       /* ext1 worst indlen */
4875         xfs_filblks_t                   *indlen2)       /* ext2 worst indlen */
4876 {
4877         xfs_filblks_t                   len1 = *indlen1;
4878         xfs_filblks_t                   len2 = *indlen2;
4879         xfs_filblks_t                   nres = len1 + len2; /* new total res. */
4880         xfs_filblks_t                   resfactor;
4881
4882         /*
4883          * We can't meet the total required reservation for the two extents.
4884          * Calculate the percent of the overall shortage between both extents
4885          * and apply this percentage to each of the requested indlen values.
4886          * This distributes the shortage fairly and reduces the chances that one
4887          * of the two extents is left with nothing when extents are repeatedly
4888          * split.
4889          */
4890         resfactor = (ores * 100);
4891         do_div(resfactor, nres);
4892         len1 *= resfactor;
4893         do_div(len1, 100);
4894         len2 *= resfactor;
4895         do_div(len2, 100);
4896         ASSERT(len1 + len2 <= ores);
4897         ASSERT(len1 < *indlen1 && len2 < *indlen2);
4898
4899         /*
4900          * Hand out the remainder to each extent. If one of the two reservations
4901          * is zero, we want to make sure that one gets a block first. The loop
4902          * below starts with len1, so hand len2 a block right off the bat if it
4903          * is zero.
4904          */
4905         ores -= (len1 + len2);
4906         ASSERT((*indlen1 - len1) + (*indlen2 - len2) >= ores);
4907         if (ores && !len2 && *indlen2) {
4908                 len2++;
4909                 ores--;
4910         }
4911         while (ores) {
4912                 if (len1 < *indlen1) {
4913                         len1++;
4914                         ores--;
4915                 }
4916                 if (!ores)
4917                         break;
4918                 if (len2 < *indlen2) {
4919                         len2++;
4920                         ores--;
4921                 }
4922         }
4923
4924         *indlen1 = len1;
4925         *indlen2 = len2;
4926 }
4927
4928 void
4929 xfs_bmap_del_extent_delay(
4930         struct xfs_inode        *ip,
4931         int                     whichfork,
4932         struct xfs_iext_cursor  *icur,
4933         struct xfs_bmbt_irec    *got,
4934         struct xfs_bmbt_irec    *del)
4935 {
4936         struct xfs_mount        *mp = ip->i_mount;
4937         struct xfs_ifork        *ifp = xfs_ifork_ptr(ip, whichfork);
4938         struct xfs_bmbt_irec    new;
4939         int64_t                 da_old, da_new, da_diff = 0;
4940         xfs_fileoff_t           del_endoff, got_endoff;
4941         xfs_filblks_t           got_indlen, new_indlen, stolen = 0;
4942         uint32_t                state = xfs_bmap_fork_to_state(whichfork);
4943         uint64_t                fdblocks;
4944         bool                    isrt;
4945
4946         XFS_STATS_INC(mp, xs_del_exlist);
4947
4948         isrt = xfs_ifork_is_realtime(ip, whichfork);
4949         del_endoff = del->br_startoff + del->br_blockcount;
4950         got_endoff = got->br_startoff + got->br_blockcount;
4951         da_old = startblockval(got->br_startblock);
4952         da_new = 0;
4953
4954         ASSERT(del->br_blockcount > 0);
4955         ASSERT(got->br_startoff <= del->br_startoff);
4956         ASSERT(got_endoff >= del_endoff);
4957
4958         /*
4959          * Update the inode delalloc counter now and wait to update the
4960          * sb counters as we might have to borrow some blocks for the
4961          * indirect block accounting.
4962          */
4963         xfs_quota_unreserve_blkres(ip, del->br_blockcount);
4964         ip->i_delayed_blks -= del->br_blockcount;
4965
4966         if (got->br_startoff == del->br_startoff)
4967                 state |= BMAP_LEFT_FILLING;
4968         if (got_endoff == del_endoff)
4969                 state |= BMAP_RIGHT_FILLING;
4970
4971         switch (state & (BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING)) {
4972         case BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING:
4973                 /*
4974                  * Matches the whole extent.  Delete the entry.
4975                  */
4976                 xfs_iext_remove(ip, icur, state);
4977                 xfs_iext_prev(ifp, icur);
4978                 break;
4979         case BMAP_LEFT_FILLING:
4980                 /*
4981                  * Deleting the first part of the extent.
4982                  */
4983                 got->br_startoff = del_endoff;
4984                 got->br_blockcount -= del->br_blockcount;
4985                 da_new = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(ip,
4986                                 got->br_blockcount), da_old);
4987                 got->br_startblock = nullstartblock((int)da_new);
4988                 xfs_iext_update_extent(ip, state, icur, got);
4989                 break;
4990         case BMAP_RIGHT_FILLING:
4991                 /*
4992                  * Deleting the last part of the extent.
4993                  */
4994                 got->br_blockcount = got->br_blockcount - del->br_blockcount;
4995                 da_new = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(ip,
4996                                 got->br_blockcount), da_old);
4997                 got->br_startblock = nullstartblock((int)da_new);
4998                 xfs_iext_update_extent(ip, state, icur, got);
4999                 break;
5000         case 0:
5001                 /*
5002                  * Deleting the middle of the extent.
5003                  *
5004                  * Distribute the original indlen reservation across the two new
5005                  * extents.  Steal blocks from the deleted extent if necessary.
5006                  * Stealing blocks simply fudges the fdblocks accounting below.
5007                  * Warn if either of the new indlen reservations is zero as this
5008                  * can lead to delalloc problems.
5009                  */
5010                 got->br_blockcount = del->br_startoff - got->br_startoff;
5011                 got_indlen = xfs_bmap_worst_indlen(ip, got->br_blockcount);
5012
5013                 new.br_blockcount = got_endoff - del_endoff;
5014                 new_indlen = xfs_bmap_worst_indlen(ip, new.br_blockcount);
5015
5016                 WARN_ON_ONCE(!got_indlen || !new_indlen);
5017                 /*
5018                  * Steal as many blocks as we can to try and satisfy the worst
5019                  * case indlen for both new extents.
5020                  *
5021                  * However, we can't just steal reservations from the data
5022                  * blocks if this is an RT inodes as the data and metadata
5023                  * blocks come from different pools.  We'll have to live with
5024                  * under-filled indirect reservation in this case.
5025                  */
5026                 da_new = got_indlen + new_indlen;
5027                 if (da_new > da_old && !isrt) {
5028                         stolen = XFS_FILBLKS_MIN(da_new - da_old,
5029                                                  del->br_blockcount);
5030                         da_old += stolen;
5031                 }
5032                 if (da_new > da_old)
5033                         xfs_bmap_split_indlen(da_old, &got_indlen, &new_indlen);
5034                 da_new = got_indlen + new_indlen;
5035
5036                 got->br_startblock = nullstartblock((int)got_indlen);
5037
5038                 new.br_startoff = del_endoff;
5039                 new.br_state = got->br_state;
5040                 new.br_startblock = nullstartblock((int)new_indlen);
5041
5042                 xfs_iext_update_extent(ip, state, icur, got);
5043                 xfs_iext_next(ifp, icur);
5044                 xfs_iext_insert(ip, icur, &new, state);
5045
5046                 del->br_blockcount -= stolen;
5047                 break;
5048         }
5049
5050         ASSERT(da_old >= da_new);
5051         da_diff = da_old - da_new;
5052         fdblocks = da_diff;
5053
5054         if (isrt)
5055                 xfs_add_frextents(mp, xfs_rtb_to_rtx(mp, del->br_blockcount));
5056         else
5057                 fdblocks += del->br_blockcount;
5058
5059         xfs_add_fdblocks(mp, fdblocks);
5060         xfs_mod_delalloc(ip, -(int64_t)del->br_blockcount, -da_diff);
5061 }
5062
5063 void
5064 xfs_bmap_del_extent_cow(
5065         struct xfs_inode        *ip,
5066         struct xfs_iext_cursor  *icur,
5067         struct xfs_bmbt_irec    *got,
5068         struct xfs_bmbt_irec    *del)
5069 {
5070         struct xfs_mount        *mp = ip->i_mount;
5071         struct xfs_ifork        *ifp = xfs_ifork_ptr(ip, XFS_COW_FORK);
5072         struct xfs_bmbt_irec    new;
5073         xfs_fileoff_t           del_endoff, got_endoff;
5074         uint32_t                state = BMAP_COWFORK;
5075
5076         XFS_STATS_INC(mp, xs_del_exlist);
5077
5078         del_endoff = del->br_startoff + del->br_blockcount;
5079         got_endoff = got->br_startoff + got->br_blockcount;
5080
5081         ASSERT(del->br_blockcount > 0);
5082         ASSERT(got->br_startoff <= del->br_startoff);
5083         ASSERT(got_endoff >= del_endoff);
5084         ASSERT(!isnullstartblock(got->br_startblock));
5085
5086         if (got->br_startoff == del->br_startoff)
5087                 state |= BMAP_LEFT_FILLING;
5088         if (got_endoff == del_endoff)
5089                 state |= BMAP_RIGHT_FILLING;
5090
5091         switch (state & (BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING)) {
5092         case BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING:
5093                 /*
5094                  * Matches the whole extent.  Delete the entry.
5095                  */
5096                 xfs_iext_remove(ip, icur, state);
5097                 xfs_iext_prev(ifp, icur);
5098                 break;
5099         case BMAP_LEFT_FILLING:
5100                 /*
5101                  * Deleting the first part of the extent.
5102                  */
5103                 got->br_startoff = del_endoff;
5104                 got->br_blockcount -= del->br_blockcount;
5105                 got->br_startblock = del->br_startblock + del->br_blockcount;
5106                 xfs_iext_update_extent(ip, state, icur, got);
5107                 break;
5108         case BMAP_RIGHT_FILLING:
5109                 /*
5110                  * Deleting the last part of the extent.
5111                  */
5112                 got->br_blockcount -= del->br_blockcount;
5113                 xfs_iext_update_extent(ip, state, icur, got);
5114                 break;
5115         case 0:
5116                 /*
5117                  * Deleting the middle of the extent.
5118                  */
5119                 got->br_blockcount = del->br_startoff - got->br_startoff;
5120
5121                 new.br_startoff = del_endoff;
5122                 new.br_blockcount = got_endoff - del_endoff;
5123                 new.br_state = got->br_state;
5124                 new.br_startblock = del->br_startblock + del->br_blockcount;
5125
5126                 xfs_iext_update_extent(ip, state, icur, got);
5127                 xfs_iext_next(ifp, icur);
5128                 xfs_iext_insert(ip, icur, &new, state);
5129                 break;
5130         }
5131         ip->i_delayed_blks -= del->br_blockcount;
5132 }
5133
5134 /*
5135  * Called by xfs_bmapi to update file extent records and the btree
5136  * after removing space.
5137  */
5138 STATIC int                              /* error */
5139 xfs_bmap_del_extent_real(
5140         xfs_inode_t             *ip,    /* incore inode pointer */
5141         xfs_trans_t             *tp,    /* current transaction pointer */
5142         struct xfs_iext_cursor  *icur,
5143         struct xfs_btree_cur    *cur,   /* if null, not a btree */
5144         xfs_bmbt_irec_t         *del,   /* data to remove from extents */
5145         int                     *logflagsp, /* inode logging flags */
5146         int                     whichfork, /* data or attr fork */
5147         uint32_t                bflags) /* bmapi flags */
5148 {
5149         xfs_fsblock_t           del_endblock=0; /* first block past del */
5150         xfs_fileoff_t           del_endoff;     /* first offset past del */
5151         int                     error = 0;      /* error return value */
5152         struct xfs_bmbt_irec    got;    /* current extent entry */
5153         xfs_fileoff_t           got_endoff;     /* first offset past got */
5154         int                     i;      /* temp state */
5155         struct xfs_ifork        *ifp;   /* inode fork pointer */
5156         xfs_mount_t             *mp;    /* mount structure */
5157         xfs_filblks_t           nblks;  /* quota/sb block count */
5158         xfs_bmbt_irec_t         new;    /* new record to be inserted */
5159         /* REFERENCED */
5160         uint                    qfield; /* quota field to update */
5161         uint32_t                state = xfs_bmap_fork_to_state(whichfork);
5162         struct xfs_bmbt_irec    old;
5163
5164         *logflagsp = 0;
5165
5166         mp = ip->i_mount;
5167         XFS_STATS_INC(mp, xs_del_exlist);
5168
5169         ifp = xfs_ifork_ptr(ip, whichfork);
5170         ASSERT(del->br_blockcount > 0);
5171         xfs_iext_get_extent(ifp, icur, &got);
5172         ASSERT(got.br_startoff <= del->br_startoff);
5173         del_endoff = del->br_startoff + del->br_blockcount;
5174         got_endoff = got.br_startoff + got.br_blockcount;
5175         ASSERT(got_endoff >= del_endoff);
5176         ASSERT(!isnullstartblock(got.br_startblock));
5177         qfield = 0;
5178
5179         /*
5180          * If it's the case where the directory code is running with no block
5181          * reservation, and the deleted block is in the middle of its extent,
5182          * and the resulting insert of an extent would cause transformation to
5183          * btree format, then reject it.  The calling code will then swap blocks
5184          * around instead.  We have to do this now, rather than waiting for the
5185          * conversion to btree format, since the transaction will be dirty then.
5186          */
5187         if (tp->t_blk_res == 0 &&
5188             ifp->if_format == XFS_DINODE_FMT_EXTENTS &&
5189             ifp->if_nextents >= XFS_IFORK_MAXEXT(ip, whichfork) &&
5190             del->br_startoff > got.br_startoff && del_endoff < got_endoff)
5191                 return -ENOSPC;
5192
5193         *logflagsp = XFS_ILOG_CORE;
5194         if (xfs_ifork_is_realtime(ip, whichfork))
5195                 qfield = XFS_TRANS_DQ_RTBCOUNT;
5196         else
5197                 qfield = XFS_TRANS_DQ_BCOUNT;
5198         nblks = del->br_blockcount;
5199
5200         del_endblock = del->br_startblock + del->br_blockcount;
5201         if (cur) {
5202                 error = xfs_bmbt_lookup_eq(cur, &got, &i);
5203                 if (error)
5204                         return error;
5205                 if (XFS_IS_CORRUPT(mp, i != 1)) {
5206                         xfs_btree_mark_sick(cur);
5207                         return -EFSCORRUPTED;
5208                 }
5209         }
5210
5211         if (got.br_startoff == del->br_startoff)
5212                 state |= BMAP_LEFT_FILLING;
5213         if (got_endoff == del_endoff)
5214                 state |= BMAP_RIGHT_FILLING;
5215
5216         switch (state & (BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING)) {
5217         case BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING:
5218                 /*
5219                  * Matches the whole extent.  Delete the entry.
5220                  */
5221                 xfs_iext_remove(ip, icur, state);
5222                 xfs_iext_prev(ifp, icur);
5223                 ifp->if_nextents--;
5224
5225                 *logflagsp |= XFS_ILOG_CORE;
5226                 if (!cur) {
5227                         *logflagsp |= xfs_ilog_fext(whichfork);
5228                         break;
5229                 }
5230                 if ((error = xfs_btree_delete(cur, &i)))
5231                         return error;
5232                 if (XFS_IS_CORRUPT(mp, i != 1)) {
5233                         xfs_btree_mark_sick(cur);
5234                         return -EFSCORRUPTED;
5235                 }
5236                 break;
5237         case BMAP_LEFT_FILLING:
5238                 /*
5239                  * Deleting the first part of the extent.
5240                  */
5241                 got.br_startoff = del_endoff;
5242                 got.br_startblock = del_endblock;
5243                 got.br_blockcount -= del->br_blockcount;
5244                 xfs_iext_update_extent(ip, state, icur, &got);
5245                 if (!cur) {
5246                         *logflagsp |= xfs_ilog_fext(whichfork);
5247                         break;
5248                 }
5249                 error = xfs_bmbt_update(cur, &got);
5250                 if (error)
5251                         return error;
5252                 break;
5253         case BMAP_RIGHT_FILLING:
5254                 /*
5255                  * Deleting the last part of the extent.
5256                  */
5257                 got.br_blockcount -= del->br_blockcount;
5258                 xfs_iext_update_extent(ip, state, icur, &got);
5259                 if (!cur) {
5260                         *logflagsp |= xfs_ilog_fext(whichfork);
5261                         break;
5262                 }
5263                 error = xfs_bmbt_update(cur, &got);
5264                 if (error)
5265                         return error;
5266                 break;
5267         case 0:
5268                 /*
5269                  * Deleting the middle of the extent.
5270                  */
5271
5272                 old = got;
5273
5274                 got.br_blockcount = del->br_startoff - got.br_startoff;
5275                 xfs_iext_update_extent(ip, state, icur, &got);
5276
5277                 new.br_startoff = del_endoff;
5278                 new.br_blockcount = got_endoff - del_endoff;
5279                 new.br_state = got.br_state;
5280                 new.br_startblock = del_endblock;
5281
5282                 *logflagsp |= XFS_ILOG_CORE;
5283                 if (cur) {
5284                         error = xfs_bmbt_update(cur, &got);
5285                         if (error)
5286                                 return error;
5287                         error = xfs_btree_increment(cur, 0, &i);
5288                         if (error)
5289                                 return error;
5290                         cur->bc_rec.b = new;
5291                         error = xfs_btree_insert(cur, &i);
5292                         if (error && error != -ENOSPC)
5293                                 return error;
5294                         /*
5295                          * If get no-space back from btree insert, it tried a
5296                          * split, and we have a zero block reservation.  Fix up
5297                          * our state and return the error.
5298                          */
5299                         if (error == -ENOSPC) {
5300                                 /*
5301                                  * Reset the cursor, don't trust it after any
5302                                  * insert operation.
5303                                  */
5304                                 error = xfs_bmbt_lookup_eq(cur, &got, &i);
5305                                 if (error)
5306                                         return error;
5307                                 if (XFS_IS_CORRUPT(mp, i != 1)) {
5308                                         xfs_btree_mark_sick(cur);
5309                                         return -EFSCORRUPTED;
5310                                 }
5311                                 /*
5312                                  * Update the btree record back
5313                                  * to the original value.
5314                                  */
5315                                 error = xfs_bmbt_update(cur, &old);
5316                                 if (error)
5317                                         return error;
5318                                 /*
5319                                  * Reset the extent record back
5320                                  * to the original value.
5321                                  */
5322                                 xfs_iext_update_extent(ip, state, icur, &old);
5323                                 *logflagsp = 0;
5324                                 return -ENOSPC;
5325                         }
5326                         if (XFS_IS_CORRUPT(mp, i != 1)) {
5327                                 xfs_btree_mark_sick(cur);
5328                                 return -EFSCORRUPTED;
5329                         }
5330                 } else
5331                         *logflagsp |= xfs_ilog_fext(whichfork);
5332
5333                 ifp->if_nextents++;
5334                 xfs_iext_next(ifp, icur);
5335                 xfs_iext_insert(ip, icur, &new, state);
5336                 break;
5337         }
5338
5339         /* remove reverse mapping */
5340         xfs_rmap_unmap_extent(tp, ip, whichfork, del);
5341
5342         /*
5343          * If we need to, add to list of extents to delete.
5344          */
5345         if (!(bflags & XFS_BMAPI_REMAP)) {
5346                 if (xfs_is_reflink_inode(ip) && whichfork == XFS_DATA_FORK) {
5347                         xfs_refcount_decrease_extent(tp, del);
5348                 } else if (xfs_ifork_is_realtime(ip, whichfork)) {
5349                         /*
5350                          * Ensure the bitmap and summary inodes are locked
5351                          * and joined to the transaction before modifying them.
5352                          */
5353                         if (!(tp->t_flags & XFS_TRANS_RTBITMAP_LOCKED)) {
5354                                 tp->t_flags |= XFS_TRANS_RTBITMAP_LOCKED;
5355                                 xfs_rtbitmap_lock(tp, mp);
5356                         }
5357                         error = xfs_rtfree_blocks(tp, del->br_startblock,
5358                                         del->br_blockcount);
5359                 } else {
5360                         error = xfs_free_extent_later(tp, del->br_startblock,
5361                                         del->br_blockcount, NULL,
5362                                         XFS_AG_RESV_NONE,
5363                                         ((bflags & XFS_BMAPI_NODISCARD) ||
5364                                         del->br_state == XFS_EXT_UNWRITTEN));
5365                 }
5366                 if (error)
5367                         return error;
5368         }
5369
5370         /*
5371          * Adjust inode # blocks in the file.
5372          */
5373         if (nblks)
5374                 ip->i_nblocks -= nblks;
5375         /*
5376          * Adjust quota data.
5377          */
5378         if (qfield && !(bflags & XFS_BMAPI_REMAP))
5379                 xfs_trans_mod_dquot_byino(tp, ip, qfield, (long)-nblks);
5380
5381         return 0;
5382 }
5383
5384 /*
5385  * Unmap (remove) blocks from a file.
5386  * If nexts is nonzero then the number of extents to remove is limited to
5387  * that value.  If not all extents in the block range can be removed then
5388  * *done is set.
5389  */
5390 static int
5391 __xfs_bunmapi(
5392         struct xfs_trans        *tp,            /* transaction pointer */
5393         struct xfs_inode        *ip,            /* incore inode */
5394         xfs_fileoff_t           start,          /* first file offset deleted */
5395         xfs_filblks_t           *rlen,          /* i/o: amount remaining */
5396         uint32_t                flags,          /* misc flags */
5397         xfs_extnum_t            nexts)          /* number of extents max */
5398 {
5399         struct xfs_btree_cur    *cur;           /* bmap btree cursor */
5400         struct xfs_bmbt_irec    del;            /* extent being deleted */
5401         int                     error;          /* error return value */
5402         xfs_extnum_t            extno;          /* extent number in list */
5403         struct xfs_bmbt_irec    got;            /* current extent record */
5404         struct xfs_ifork        *ifp;           /* inode fork pointer */
5405         int                     isrt;           /* freeing in rt area */
5406         int                     logflags;       /* transaction logging flags */
5407         xfs_extlen_t            mod;            /* rt extent offset */
5408         struct xfs_mount        *mp = ip->i_mount;
5409         int                     tmp_logflags;   /* partial logging flags */
5410         int                     wasdel;         /* was a delayed alloc extent */
5411         int                     whichfork;      /* data or attribute fork */
5412         xfs_filblks_t           len = *rlen;    /* length to unmap in file */
5413         xfs_fileoff_t           end;
5414         struct xfs_iext_cursor  icur;
5415         bool                    done = false;
5416
5417         trace_xfs_bunmap(ip, start, len, flags, _RET_IP_);
5418
5419         whichfork = xfs_bmapi_whichfork(flags);
5420         ASSERT(whichfork != XFS_COW_FORK);
5421         ifp = xfs_ifork_ptr(ip, whichfork);
5422         if (XFS_IS_CORRUPT(mp, !xfs_ifork_has_extents(ifp))) {
5423                 xfs_bmap_mark_sick(ip, whichfork);
5424                 return -EFSCORRUPTED;
5425         }
5426         if (xfs_is_shutdown(mp))
5427                 return -EIO;
5428
5429         xfs_assert_ilocked(ip, XFS_ILOCK_EXCL);
5430         ASSERT(len > 0);
5431         ASSERT(nexts >= 0);
5432
5433         error = xfs_iread_extents(tp, ip, whichfork);
5434         if (error)
5435                 return error;
5436
5437         if (xfs_iext_count(ifp) == 0) {
5438                 *rlen = 0;
5439                 return 0;
5440         }
5441         XFS_STATS_INC(mp, xs_blk_unmap);
5442         isrt = xfs_ifork_is_realtime(ip, whichfork);
5443         end = start + len;
5444
5445         if (!xfs_iext_lookup_extent_before(ip, ifp, &end, &icur, &got)) {
5446                 *rlen = 0;
5447                 return 0;
5448         }
5449         end--;
5450
5451         logflags = 0;
5452         if (ifp->if_format == XFS_DINODE_FMT_BTREE) {
5453                 ASSERT(ifp->if_format == XFS_DINODE_FMT_BTREE);
5454                 cur = xfs_bmbt_init_cursor(mp, tp, ip, whichfork);
5455         } else
5456                 cur = NULL;
5457
5458         extno = 0;
5459         while (end != (xfs_fileoff_t)-1 && end >= start &&
5460                (nexts == 0 || extno < nexts)) {
5461                 /*
5462                  * Is the found extent after a hole in which end lives?
5463                  * Just back up to the previous extent, if so.
5464                  */
5465                 if (got.br_startoff > end &&
5466                     !xfs_iext_prev_extent(ifp, &icur, &got)) {
5467                         done = true;
5468                         break;
5469                 }
5470                 /*
5471                  * Is the last block of this extent before the range
5472                  * we're supposed to delete?  If so, we're done.
5473                  */
5474                 end = XFS_FILEOFF_MIN(end,
5475                         got.br_startoff + got.br_blockcount - 1);
5476                 if (end < start)
5477                         break;
5478                 /*
5479                  * Then deal with the (possibly delayed) allocated space
5480                  * we found.
5481                  */
5482                 del = got;
5483                 wasdel = isnullstartblock(del.br_startblock);
5484
5485                 if (got.br_startoff < start) {
5486                         del.br_startoff = start;
5487                         del.br_blockcount -= start - got.br_startoff;
5488                         if (!wasdel)
5489                                 del.br_startblock += start - got.br_startoff;
5490                 }
5491                 if (del.br_startoff + del.br_blockcount > end + 1)
5492                         del.br_blockcount = end + 1 - del.br_startoff;
5493
5494                 if (!isrt || (flags & XFS_BMAPI_REMAP))
5495                         goto delete;
5496
5497                 mod = xfs_rtb_to_rtxoff(mp,
5498                                 del.br_startblock + del.br_blockcount);
5499                 if (mod) {
5500                         /*
5501                          * Realtime extent not lined up at the end.
5502                          * The extent could have been split into written
5503                          * and unwritten pieces, or we could just be
5504                          * unmapping part of it.  But we can't really
5505                          * get rid of part of a realtime extent.
5506                          */
5507                         if (del.br_state == XFS_EXT_UNWRITTEN) {
5508                                 /*
5509                                  * This piece is unwritten, or we're not
5510                                  * using unwritten extents.  Skip over it.
5511                                  */
5512                                 ASSERT((flags & XFS_BMAPI_REMAP) || end >= mod);
5513                                 end -= mod > del.br_blockcount ?
5514                                         del.br_blockcount : mod;
5515                                 if (end < got.br_startoff &&
5516                                     !xfs_iext_prev_extent(ifp, &icur, &got)) {
5517                                         done = true;
5518                                         break;
5519                                 }
5520                                 continue;
5521                         }
5522                         /*
5523                          * It's written, turn it unwritten.
5524                          * This is better than zeroing it.
5525                          */
5526                         ASSERT(del.br_state == XFS_EXT_NORM);
5527                         ASSERT(tp->t_blk_res > 0);
5528                         /*
5529                          * If this spans a realtime extent boundary,
5530                          * chop it back to the start of the one we end at.
5531                          */
5532                         if (del.br_blockcount > mod) {
5533                                 del.br_startoff += del.br_blockcount - mod;
5534                                 del.br_startblock += del.br_blockcount - mod;
5535                                 del.br_blockcount = mod;
5536                         }
5537                         del.br_state = XFS_EXT_UNWRITTEN;
5538                         error = xfs_bmap_add_extent_unwritten_real(tp, ip,
5539                                         whichfork, &icur, &cur, &del,
5540                                         &logflags);
5541                         if (error)
5542                                 goto error0;
5543                         goto nodelete;
5544                 }
5545
5546                 mod = xfs_rtb_to_rtxoff(mp, del.br_startblock);
5547                 if (mod) {
5548                         xfs_extlen_t off = mp->m_sb.sb_rextsize - mod;
5549
5550                         /*
5551                          * Realtime extent is lined up at the end but not
5552                          * at the front.  We'll get rid of full extents if
5553                          * we can.
5554                          */
5555                         if (del.br_blockcount > off) {
5556                                 del.br_blockcount -= off;
5557                                 del.br_startoff += off;
5558                                 del.br_startblock += off;
5559                         } else if (del.br_startoff == start &&
5560                                    (del.br_state == XFS_EXT_UNWRITTEN ||
5561                                     tp->t_blk_res == 0)) {
5562                                 /*
5563                                  * Can't make it unwritten.  There isn't
5564                                  * a full extent here so just skip it.
5565                                  */
5566                                 ASSERT(end >= del.br_blockcount);
5567                                 end -= del.br_blockcount;
5568                                 if (got.br_startoff > end &&
5569                                     !xfs_iext_prev_extent(ifp, &icur, &got)) {
5570                                         done = true;
5571                                         break;
5572                                 }
5573                                 continue;
5574                         } else if (del.br_state == XFS_EXT_UNWRITTEN) {
5575                                 struct xfs_bmbt_irec    prev;
5576                                 xfs_fileoff_t           unwrite_start;
5577
5578                                 /*
5579                                  * This one is already unwritten.
5580                                  * It must have a written left neighbor.
5581                                  * Unwrite the killed part of that one and
5582                                  * try again.
5583                                  */
5584                                 if (!xfs_iext_prev_extent(ifp, &icur, &prev))
5585                                         ASSERT(0);
5586                                 ASSERT(prev.br_state == XFS_EXT_NORM);
5587                                 ASSERT(!isnullstartblock(prev.br_startblock));
5588                                 ASSERT(del.br_startblock ==
5589                                        prev.br_startblock + prev.br_blockcount);
5590                                 unwrite_start = max3(start,
5591                                                      del.br_startoff - mod,
5592                                                      prev.br_startoff);
5593                                 mod = unwrite_start - prev.br_startoff;
5594                                 prev.br_startoff = unwrite_start;
5595                                 prev.br_startblock += mod;
5596                                 prev.br_blockcount -= mod;
5597                                 prev.br_state = XFS_EXT_UNWRITTEN;
5598                                 error = xfs_bmap_add_extent_unwritten_real(tp,
5599                                                 ip, whichfork, &icur, &cur,
5600                                                 &prev, &logflags);
5601                                 if (error)
5602                                         goto error0;
5603                                 goto nodelete;
5604                         } else {
5605                                 ASSERT(del.br_state == XFS_EXT_NORM);
5606                                 del.br_state = XFS_EXT_UNWRITTEN;
5607                                 error = xfs_bmap_add_extent_unwritten_real(tp,
5608                                                 ip, whichfork, &icur, &cur,
5609                                                 &del, &logflags);
5610                                 if (error)
5611                                         goto error0;
5612                                 goto nodelete;
5613                         }
5614                 }
5615
5616 delete:
5617                 if (wasdel) {
5618                         xfs_bmap_del_extent_delay(ip, whichfork, &icur, &got, &del);
5619                 } else {
5620                         error = xfs_bmap_del_extent_real(ip, tp, &icur, cur,
5621                                         &del, &tmp_logflags, whichfork,
5622                                         flags);
5623                         logflags |= tmp_logflags;
5624                         if (error)
5625                                 goto error0;
5626                 }
5627
5628                 end = del.br_startoff - 1;
5629 nodelete:
5630                 /*
5631                  * If not done go on to the next (previous) record.
5632                  */
5633                 if (end != (xfs_fileoff_t)-1 && end >= start) {
5634                         if (!xfs_iext_get_extent(ifp, &icur, &got) ||
5635                             (got.br_startoff > end &&
5636                              !xfs_iext_prev_extent(ifp, &icur, &got))) {
5637                                 done = true;
5638                                 break;
5639                         }
5640                         extno++;
5641                 }
5642         }
5643         if (done || end == (xfs_fileoff_t)-1 || end < start)
5644                 *rlen = 0;
5645         else
5646                 *rlen = end - start + 1;
5647
5648         /*
5649          * Convert to a btree if necessary.
5650          */
5651         if (xfs_bmap_needs_btree(ip, whichfork)) {
5652                 ASSERT(cur == NULL);
5653                 error = xfs_bmap_extents_to_btree(tp, ip, &cur, 0,
5654                                 &tmp_logflags, whichfork);
5655                 logflags |= tmp_logflags;
5656         } else {
5657                 error = xfs_bmap_btree_to_extents(tp, ip, cur, &logflags,
5658                         whichfork);
5659         }
5660
5661 error0:
5662         /*
5663          * Log everything.  Do this after conversion, there's no point in
5664          * logging the extent records if we've converted to btree format.
5665          */
5666         if ((logflags & xfs_ilog_fext(whichfork)) &&
5667             ifp->if_format != XFS_DINODE_FMT_EXTENTS)
5668                 logflags &= ~xfs_ilog_fext(whichfork);
5669         else if ((logflags & xfs_ilog_fbroot(whichfork)) &&
5670                  ifp->if_format != XFS_DINODE_FMT_BTREE)
5671                 logflags &= ~xfs_ilog_fbroot(whichfork);
5672         /*
5673          * Log inode even in the error case, if the transaction
5674          * is dirty we'll need to shut down the filesystem.
5675          */
5676         if (logflags)
5677                 xfs_trans_log_inode(tp, ip, logflags);
5678         if (cur) {
5679                 if (!error)
5680                         cur->bc_bmap.allocated = 0;
5681                 xfs_btree_del_cursor(cur, error);
5682         }
5683         return error;
5684 }
5685
5686 /* Unmap a range of a file. */
5687 int
5688 xfs_bunmapi(
5689         xfs_trans_t             *tp,
5690         struct xfs_inode        *ip,
5691         xfs_fileoff_t           bno,
5692         xfs_filblks_t           len,
5693         uint32_t                flags,
5694         xfs_extnum_t            nexts,
5695         int                     *done)
5696 {
5697         int                     error;
5698
5699         error = __xfs_bunmapi(tp, ip, bno, &len, flags, nexts);
5700         *done = (len == 0);
5701         return error;
5702 }
5703
5704 /*
5705  * Determine whether an extent shift can be accomplished by a merge with the
5706  * extent that precedes the target hole of the shift.
5707  */
5708 STATIC bool
5709 xfs_bmse_can_merge(
5710         struct xfs_bmbt_irec    *left,  /* preceding extent */
5711         struct xfs_bmbt_irec    *got,   /* current extent to shift */
5712         xfs_fileoff_t           shift)  /* shift fsb */
5713 {
5714         xfs_fileoff_t           startoff;
5715
5716         startoff = got->br_startoff - shift;
5717
5718         /*
5719          * The extent, once shifted, must be adjacent in-file and on-disk with
5720          * the preceding extent.
5721          */
5722         if ((left->br_startoff + left->br_blockcount != startoff) ||
5723             (left->br_startblock + left->br_blockcount != got->br_startblock) ||
5724             (left->br_state != got->br_state) ||
5725             (left->br_blockcount + got->br_blockcount > XFS_MAX_BMBT_EXTLEN))
5726                 return false;
5727
5728         return true;
5729 }
5730
5731 /*
5732  * A bmap extent shift adjusts the file offset of an extent to fill a preceding
5733  * hole in the file. If an extent shift would result in the extent being fully
5734  * adjacent to the extent that currently precedes the hole, we can merge with
5735  * the preceding extent rather than do the shift.
5736  *
5737  * This function assumes the caller has verified a shift-by-merge is possible
5738  * with the provided extents via xfs_bmse_can_merge().
5739  */
5740 STATIC int
5741 xfs_bmse_merge(
5742         struct xfs_trans                *tp,
5743         struct xfs_inode                *ip,
5744         int                             whichfork,
5745         xfs_fileoff_t                   shift,          /* shift fsb */
5746         struct xfs_iext_cursor          *icur,
5747         struct xfs_bmbt_irec            *got,           /* extent to shift */
5748         struct xfs_bmbt_irec            *left,          /* preceding extent */
5749         struct xfs_btree_cur            *cur,
5750         int                             *logflags)      /* output */
5751 {
5752         struct xfs_ifork                *ifp = xfs_ifork_ptr(ip, whichfork);
5753         struct xfs_bmbt_irec            new;
5754         xfs_filblks_t                   blockcount;
5755         int                             error, i;
5756         struct xfs_mount                *mp = ip->i_mount;
5757
5758         blockcount = left->br_blockcount + got->br_blockcount;
5759
5760         xfs_assert_ilocked(ip, XFS_IOLOCK_EXCL | XFS_ILOCK_EXCL);
5761         ASSERT(xfs_bmse_can_merge(left, got, shift));
5762
5763         new = *left;
5764         new.br_blockcount = blockcount;
5765
5766         /*
5767          * Update the on-disk extent count, the btree if necessary and log the
5768          * inode.
5769          */
5770         ifp->if_nextents--;
5771         *logflags |= XFS_ILOG_CORE;
5772         if (!cur) {
5773                 *logflags |= XFS_ILOG_DEXT;
5774                 goto done;
5775         }
5776
5777         /* lookup and remove the extent to merge */
5778         error = xfs_bmbt_lookup_eq(cur, got, &i);
5779         if (error)
5780                 return error;
5781         if (XFS_IS_CORRUPT(mp, i != 1)) {
5782                 xfs_btree_mark_sick(cur);
5783                 return -EFSCORRUPTED;
5784         }
5785
5786         error = xfs_btree_delete(cur, &i);
5787         if (error)
5788                 return error;
5789         if (XFS_IS_CORRUPT(mp, i != 1)) {
5790                 xfs_btree_mark_sick(cur);
5791                 return -EFSCORRUPTED;
5792         }
5793
5794         /* lookup and update size of the previous extent */
5795         error = xfs_bmbt_lookup_eq(cur, left, &i);
5796         if (error)
5797                 return error;
5798         if (XFS_IS_CORRUPT(mp, i != 1)) {
5799                 xfs_btree_mark_sick(cur);
5800                 return -EFSCORRUPTED;
5801         }
5802
5803         error = xfs_bmbt_update(cur, &new);
5804         if (error)
5805                 return error;
5806
5807         /* change to extent format if required after extent removal */
5808         error = xfs_bmap_btree_to_extents(tp, ip, cur, logflags, whichfork);
5809         if (error)
5810                 return error;
5811
5812 done:
5813         xfs_iext_remove(ip, icur, 0);
5814         xfs_iext_prev(ifp, icur);
5815         xfs_iext_update_extent(ip, xfs_bmap_fork_to_state(whichfork), icur,
5816                         &new);
5817
5818         /* update reverse mapping. rmap functions merge the rmaps for us */
5819         xfs_rmap_unmap_extent(tp, ip, whichfork, got);
5820         memcpy(&new, got, sizeof(new));
5821         new.br_startoff = left->br_startoff + left->br_blockcount;
5822         xfs_rmap_map_extent(tp, ip, whichfork, &new);
5823         return 0;
5824 }
5825
5826 static int
5827 xfs_bmap_shift_update_extent(
5828         struct xfs_trans        *tp,
5829         struct xfs_inode        *ip,
5830         int                     whichfork,
5831         struct xfs_iext_cursor  *icur,
5832         struct xfs_bmbt_irec    *got,
5833         struct xfs_btree_cur    *cur,
5834         int                     *logflags,
5835         xfs_fileoff_t           startoff)
5836 {
5837         struct xfs_mount        *mp = ip->i_mount;
5838         struct xfs_bmbt_irec    prev = *got;
5839         int                     error, i;
5840
5841         *logflags |= XFS_ILOG_CORE;
5842
5843         got->br_startoff = startoff;
5844
5845         if (cur) {
5846                 error = xfs_bmbt_lookup_eq(cur, &prev, &i);
5847                 if (error)
5848                         return error;
5849                 if (XFS_IS_CORRUPT(mp, i != 1)) {
5850                         xfs_btree_mark_sick(cur);
5851                         return -EFSCORRUPTED;
5852                 }
5853
5854                 error = xfs_bmbt_update(cur, got);
5855                 if (error)
5856                         return error;
5857         } else {
5858                 *logflags |= XFS_ILOG_DEXT;
5859         }
5860
5861         xfs_iext_update_extent(ip, xfs_bmap_fork_to_state(whichfork), icur,
5862                         got);
5863
5864         /* update reverse mapping */
5865         xfs_rmap_unmap_extent(tp, ip, whichfork, &prev);
5866         xfs_rmap_map_extent(tp, ip, whichfork, got);
5867         return 0;
5868 }
5869
5870 int
5871 xfs_bmap_collapse_extents(
5872         struct xfs_trans        *tp,
5873         struct xfs_inode        *ip,
5874         xfs_fileoff_t           *next_fsb,
5875         xfs_fileoff_t           offset_shift_fsb,
5876         bool                    *done)
5877 {
5878         int                     whichfork = XFS_DATA_FORK;
5879         struct xfs_mount        *mp = ip->i_mount;
5880         struct xfs_ifork        *ifp = xfs_ifork_ptr(ip, whichfork);
5881         struct xfs_btree_cur    *cur = NULL;
5882         struct xfs_bmbt_irec    got, prev;
5883         struct xfs_iext_cursor  icur;
5884         xfs_fileoff_t           new_startoff;
5885         int                     error = 0;
5886         int                     logflags = 0;
5887
5888         if (XFS_IS_CORRUPT(mp, !xfs_ifork_has_extents(ifp)) ||
5889             XFS_TEST_ERROR(false, mp, XFS_ERRTAG_BMAPIFORMAT)) {
5890                 xfs_bmap_mark_sick(ip, whichfork);
5891                 return -EFSCORRUPTED;
5892         }
5893
5894         if (xfs_is_shutdown(mp))
5895                 return -EIO;
5896
5897         xfs_assert_ilocked(ip, XFS_IOLOCK_EXCL | XFS_ILOCK_EXCL);
5898
5899         error = xfs_iread_extents(tp, ip, whichfork);
5900         if (error)
5901                 return error;
5902
5903         if (ifp->if_format == XFS_DINODE_FMT_BTREE)
5904                 cur = xfs_bmbt_init_cursor(mp, tp, ip, whichfork);
5905
5906         if (!xfs_iext_lookup_extent(ip, ifp, *next_fsb, &icur, &got)) {
5907                 *done = true;
5908                 goto del_cursor;
5909         }
5910         if (XFS_IS_CORRUPT(mp, isnullstartblock(got.br_startblock))) {
5911                 xfs_bmap_mark_sick(ip, whichfork);
5912                 error = -EFSCORRUPTED;
5913                 goto del_cursor;
5914         }
5915
5916         new_startoff = got.br_startoff - offset_shift_fsb;
5917         if (xfs_iext_peek_prev_extent(ifp, &icur, &prev)) {
5918                 if (new_startoff < prev.br_startoff + prev.br_blockcount) {
5919                         error = -EINVAL;
5920                         goto del_cursor;
5921                 }
5922
5923                 if (xfs_bmse_can_merge(&prev, &got, offset_shift_fsb)) {
5924                         error = xfs_bmse_merge(tp, ip, whichfork,
5925                                         offset_shift_fsb, &icur, &got, &prev,
5926                                         cur, &logflags);
5927                         if (error)
5928                                 goto del_cursor;
5929                         goto done;
5930                 }
5931         } else {
5932                 if (got.br_startoff < offset_shift_fsb) {
5933                         error = -EINVAL;
5934                         goto del_cursor;
5935                 }
5936         }
5937
5938         error = xfs_bmap_shift_update_extent(tp, ip, whichfork, &icur, &got,
5939                         cur, &logflags, new_startoff);
5940         if (error)
5941                 goto del_cursor;
5942
5943 done:
5944         if (!xfs_iext_next_extent(ifp, &icur, &got)) {
5945                 *done = true;
5946                 goto del_cursor;
5947         }
5948
5949         *next_fsb = got.br_startoff;
5950 del_cursor:
5951         if (cur)
5952                 xfs_btree_del_cursor(cur, error);
5953         if (logflags)
5954                 xfs_trans_log_inode(tp, ip, logflags);
5955         return error;
5956 }
5957
5958 /* Make sure we won't be right-shifting an extent past the maximum bound. */
5959 int
5960 xfs_bmap_can_insert_extents(
5961         struct xfs_inode        *ip,
5962         xfs_fileoff_t           off,
5963         xfs_fileoff_t           shift)
5964 {
5965         struct xfs_bmbt_irec    got;
5966         int                     is_empty;
5967         int                     error = 0;
5968
5969         xfs_assert_ilocked(ip, XFS_IOLOCK_EXCL);
5970
5971         if (xfs_is_shutdown(ip->i_mount))
5972                 return -EIO;
5973
5974         xfs_ilock(ip, XFS_ILOCK_EXCL);
5975         error = xfs_bmap_last_extent(NULL, ip, XFS_DATA_FORK, &got, &is_empty);
5976         if (!error && !is_empty && got.br_startoff >= off &&
5977             ((got.br_startoff + shift) & BMBT_STARTOFF_MASK) < got.br_startoff)
5978                 error = -EINVAL;
5979         xfs_iunlock(ip, XFS_ILOCK_EXCL);
5980
5981         return error;
5982 }
5983
5984 int
5985 xfs_bmap_insert_extents(
5986         struct xfs_trans        *tp,
5987         struct xfs_inode        *ip,
5988         xfs_fileoff_t           *next_fsb,
5989         xfs_fileoff_t           offset_shift_fsb,
5990         bool                    *done,
5991         xfs_fileoff_t           stop_fsb)
5992 {
5993         int                     whichfork = XFS_DATA_FORK;
5994         struct xfs_mount        *mp = ip->i_mount;
5995         struct xfs_ifork        *ifp = xfs_ifork_ptr(ip, whichfork);
5996         struct xfs_btree_cur    *cur = NULL;
5997         struct xfs_bmbt_irec    got, next;
5998         struct xfs_iext_cursor  icur;
5999         xfs_fileoff_t           new_startoff;
6000         int                     error = 0;
6001         int                     logflags = 0;
6002
6003         if (XFS_IS_CORRUPT(mp, !xfs_ifork_has_extents(ifp)) ||
6004             XFS_TEST_ERROR(false, mp, XFS_ERRTAG_BMAPIFORMAT)) {
6005                 xfs_bmap_mark_sick(ip, whichfork);
6006                 return -EFSCORRUPTED;
6007         }
6008
6009         if (xfs_is_shutdown(mp))
6010                 return -EIO;
6011
6012         xfs_assert_ilocked(ip, XFS_IOLOCK_EXCL | XFS_ILOCK_EXCL);
6013
6014         error = xfs_iread_extents(tp, ip, whichfork);
6015         if (error)
6016                 return error;
6017
6018         if (ifp->if_format == XFS_DINODE_FMT_BTREE)
6019                 cur = xfs_bmbt_init_cursor(mp, tp, ip, whichfork);
6020
6021         if (*next_fsb == NULLFSBLOCK) {
6022                 xfs_iext_last(ifp, &icur);
6023                 if (!xfs_iext_get_extent(ifp, &icur, &got) ||
6024                     stop_fsb > got.br_startoff) {
6025                         *done = true;
6026                         goto del_cursor;
6027                 }
6028         } else {
6029                 if (!xfs_iext_lookup_extent(ip, ifp, *next_fsb, &icur, &got)) {
6030                         *done = true;
6031                         goto del_cursor;
6032                 }
6033         }
6034         if (XFS_IS_CORRUPT(mp, isnullstartblock(got.br_startblock))) {
6035                 xfs_bmap_mark_sick(ip, whichfork);
6036                 error = -EFSCORRUPTED;
6037                 goto del_cursor;
6038         }
6039
6040         if (XFS_IS_CORRUPT(mp, stop_fsb > got.br_startoff)) {
6041                 xfs_bmap_mark_sick(ip, whichfork);
6042                 error = -EFSCORRUPTED;
6043                 goto del_cursor;
6044         }
6045
6046         new_startoff = got.br_startoff + offset_shift_fsb;
6047         if (xfs_iext_peek_next_extent(ifp, &icur, &next)) {
6048                 if (new_startoff + got.br_blockcount > next.br_startoff) {
6049                         error = -EINVAL;
6050                         goto del_cursor;
6051                 }
6052
6053                 /*
6054                  * Unlike a left shift (which involves a hole punch), a right
6055                  * shift does not modify extent neighbors in any way.  We should
6056                  * never find mergeable extents in this scenario.  Check anyways
6057                  * and warn if we encounter two extents that could be one.
6058                  */
6059                 if (xfs_bmse_can_merge(&got, &next, offset_shift_fsb))
6060                         WARN_ON_ONCE(1);
6061         }
6062
6063         error = xfs_bmap_shift_update_extent(tp, ip, whichfork, &icur, &got,
6064                         cur, &logflags, new_startoff);
6065         if (error)
6066                 goto del_cursor;
6067
6068         if (!xfs_iext_prev_extent(ifp, &icur, &got) ||
6069             stop_fsb >= got.br_startoff + got.br_blockcount) {
6070                 *done = true;
6071                 goto del_cursor;
6072         }
6073
6074         *next_fsb = got.br_startoff;
6075 del_cursor:
6076         if (cur)
6077                 xfs_btree_del_cursor(cur, error);
6078         if (logflags)
6079                 xfs_trans_log_inode(tp, ip, logflags);
6080         return error;
6081 }
6082
6083 /*
6084  * Splits an extent into two extents at split_fsb block such that it is the
6085  * first block of the current_ext. @ext is a target extent to be split.
6086  * @split_fsb is a block where the extents is split.  If split_fsb lies in a
6087  * hole or the first block of extents, just return 0.
6088  */
6089 int
6090 xfs_bmap_split_extent(
6091         struct xfs_trans        *tp,
6092         struct xfs_inode        *ip,
6093         xfs_fileoff_t           split_fsb)
6094 {
6095         int                             whichfork = XFS_DATA_FORK;
6096         struct xfs_ifork                *ifp = xfs_ifork_ptr(ip, whichfork);
6097         struct xfs_btree_cur            *cur = NULL;
6098         struct xfs_bmbt_irec            got;
6099         struct xfs_bmbt_irec            new; /* split extent */
6100         struct xfs_mount                *mp = ip->i_mount;
6101         xfs_fsblock_t                   gotblkcnt; /* new block count for got */
6102         struct xfs_iext_cursor          icur;
6103         int                             error = 0;
6104         int                             logflags = 0;
6105         int                             i = 0;
6106
6107         if (XFS_IS_CORRUPT(mp, !xfs_ifork_has_extents(ifp)) ||
6108             XFS_TEST_ERROR(false, mp, XFS_ERRTAG_BMAPIFORMAT)) {
6109                 xfs_bmap_mark_sick(ip, whichfork);
6110                 return -EFSCORRUPTED;
6111         }
6112
6113         if (xfs_is_shutdown(mp))
6114                 return -EIO;
6115
6116         /* Read in all the extents */
6117         error = xfs_iread_extents(tp, ip, whichfork);
6118         if (error)
6119                 return error;
6120
6121         /*
6122          * If there are not extents, or split_fsb lies in a hole we are done.
6123          */
6124         if (!xfs_iext_lookup_extent(ip, ifp, split_fsb, &icur, &got) ||
6125             got.br_startoff >= split_fsb)
6126                 return 0;
6127
6128         gotblkcnt = split_fsb - got.br_startoff;
6129         new.br_startoff = split_fsb;
6130         new.br_startblock = got.br_startblock + gotblkcnt;
6131         new.br_blockcount = got.br_blockcount - gotblkcnt;
6132         new.br_state = got.br_state;
6133
6134         if (ifp->if_format == XFS_DINODE_FMT_BTREE) {
6135                 cur = xfs_bmbt_init_cursor(mp, tp, ip, whichfork);
6136                 error = xfs_bmbt_lookup_eq(cur, &got, &i);
6137                 if (error)
6138                         goto del_cursor;
6139                 if (XFS_IS_CORRUPT(mp, i != 1)) {
6140                         xfs_btree_mark_sick(cur);
6141                         error = -EFSCORRUPTED;
6142                         goto del_cursor;
6143                 }
6144         }
6145
6146         got.br_blockcount = gotblkcnt;
6147         xfs_iext_update_extent(ip, xfs_bmap_fork_to_state(whichfork), &icur,
6148                         &got);
6149
6150         logflags = XFS_ILOG_CORE;
6151         if (cur) {
6152                 error = xfs_bmbt_update(cur, &got);
6153                 if (error)
6154                         goto del_cursor;
6155         } else
6156                 logflags |= XFS_ILOG_DEXT;
6157
6158         /* Add new extent */
6159         xfs_iext_next(ifp, &icur);
6160         xfs_iext_insert(ip, &icur, &new, 0);
6161         ifp->if_nextents++;
6162
6163         if (cur) {
6164                 error = xfs_bmbt_lookup_eq(cur, &new, &i);
6165                 if (error)
6166                         goto del_cursor;
6167                 if (XFS_IS_CORRUPT(mp, i != 0)) {
6168                         xfs_btree_mark_sick(cur);
6169                         error = -EFSCORRUPTED;
6170                         goto del_cursor;
6171                 }
6172                 error = xfs_btree_insert(cur, &i);
6173                 if (error)
6174                         goto del_cursor;
6175                 if (XFS_IS_CORRUPT(mp, i != 1)) {
6176                         xfs_btree_mark_sick(cur);
6177                         error = -EFSCORRUPTED;
6178                         goto del_cursor;
6179                 }
6180         }
6181
6182         /*
6183          * Convert to a btree if necessary.
6184          */
6185         if (xfs_bmap_needs_btree(ip, whichfork)) {
6186                 int tmp_logflags; /* partial log flag return val */
6187
6188                 ASSERT(cur == NULL);
6189                 error = xfs_bmap_extents_to_btree(tp, ip, &cur, 0,
6190                                 &tmp_logflags, whichfork);
6191                 logflags |= tmp_logflags;
6192         }
6193
6194 del_cursor:
6195         if (cur) {
6196                 cur->bc_bmap.allocated = 0;
6197                 xfs_btree_del_cursor(cur, error);
6198         }
6199
6200         if (logflags)
6201                 xfs_trans_log_inode(tp, ip, logflags);
6202         return error;
6203 }
6204
6205 /* Record a bmap intent. */
6206 static inline void
6207 __xfs_bmap_add(
6208         struct xfs_trans                *tp,
6209         enum xfs_bmap_intent_type       type,
6210         struct xfs_inode                *ip,
6211         int                             whichfork,
6212         struct xfs_bmbt_irec            *bmap)
6213 {
6214         struct xfs_bmap_intent          *bi;
6215
6216         if ((whichfork != XFS_DATA_FORK && whichfork != XFS_ATTR_FORK) ||
6217             bmap->br_startblock == HOLESTARTBLOCK ||
6218             bmap->br_startblock == DELAYSTARTBLOCK)
6219                 return;
6220
6221         bi = kmem_cache_alloc(xfs_bmap_intent_cache, GFP_KERNEL | __GFP_NOFAIL);
6222         INIT_LIST_HEAD(&bi->bi_list);
6223         bi->bi_type = type;
6224         bi->bi_owner = ip;
6225         bi->bi_whichfork = whichfork;
6226         bi->bi_bmap = *bmap;
6227
6228         xfs_bmap_defer_add(tp, bi);
6229 }
6230
6231 /* Map an extent into a file. */
6232 void
6233 xfs_bmap_map_extent(
6234         struct xfs_trans        *tp,
6235         struct xfs_inode        *ip,
6236         int                     whichfork,
6237         struct xfs_bmbt_irec    *PREV)
6238 {
6239         __xfs_bmap_add(tp, XFS_BMAP_MAP, ip, whichfork, PREV);
6240 }
6241
6242 /* Unmap an extent out of a file. */
6243 void
6244 xfs_bmap_unmap_extent(
6245         struct xfs_trans        *tp,
6246         struct xfs_inode        *ip,
6247         int                     whichfork,
6248         struct xfs_bmbt_irec    *PREV)
6249 {
6250         __xfs_bmap_add(tp, XFS_BMAP_UNMAP, ip, whichfork, PREV);
6251 }
6252
6253 /*
6254  * Process one of the deferred bmap operations.  We pass back the
6255  * btree cursor to maintain our lock on the bmapbt between calls.
6256  */
6257 int
6258 xfs_bmap_finish_one(
6259         struct xfs_trans                *tp,
6260         struct xfs_bmap_intent          *bi)
6261 {
6262         struct xfs_bmbt_irec            *bmap = &bi->bi_bmap;
6263         int                             error = 0;
6264         int                             flags = 0;
6265
6266         if (bi->bi_whichfork == XFS_ATTR_FORK)
6267                 flags |= XFS_BMAPI_ATTRFORK;
6268
6269         ASSERT(tp->t_highest_agno == NULLAGNUMBER);
6270
6271         trace_xfs_bmap_deferred(bi);
6272
6273         if (XFS_TEST_ERROR(false, tp->t_mountp, XFS_ERRTAG_BMAP_FINISH_ONE))
6274                 return -EIO;
6275
6276         switch (bi->bi_type) {
6277         case XFS_BMAP_MAP:
6278                 if (bi->bi_bmap.br_state == XFS_EXT_UNWRITTEN)
6279                         flags |= XFS_BMAPI_PREALLOC;
6280                 error = xfs_bmapi_remap(tp, bi->bi_owner, bmap->br_startoff,
6281                                 bmap->br_blockcount, bmap->br_startblock,
6282                                 flags);
6283                 bmap->br_blockcount = 0;
6284                 break;
6285         case XFS_BMAP_UNMAP:
6286                 error = __xfs_bunmapi(tp, bi->bi_owner, bmap->br_startoff,
6287                                 &bmap->br_blockcount, flags | XFS_BMAPI_REMAP,
6288                                 1);
6289                 break;
6290         default:
6291                 ASSERT(0);
6292                 xfs_bmap_mark_sick(bi->bi_owner, bi->bi_whichfork);
6293                 error = -EFSCORRUPTED;
6294         }
6295
6296         return error;
6297 }
6298
6299 /* Check that an extent does not have invalid flags or bad ranges. */
6300 xfs_failaddr_t
6301 xfs_bmap_validate_extent_raw(
6302         struct xfs_mount        *mp,
6303         bool                    rtfile,
6304         int                     whichfork,
6305         struct xfs_bmbt_irec    *irec)
6306 {
6307         if (!xfs_verify_fileext(mp, irec->br_startoff, irec->br_blockcount))
6308                 return __this_address;
6309
6310         if (rtfile && whichfork == XFS_DATA_FORK) {
6311                 if (!xfs_verify_rtbext(mp, irec->br_startblock,
6312                                            irec->br_blockcount))
6313                         return __this_address;
6314         } else {
6315                 if (!xfs_verify_fsbext(mp, irec->br_startblock,
6316                                            irec->br_blockcount))
6317                         return __this_address;
6318         }
6319         if (irec->br_state != XFS_EXT_NORM && whichfork != XFS_DATA_FORK)
6320                 return __this_address;
6321         return NULL;
6322 }
6323
6324 int __init
6325 xfs_bmap_intent_init_cache(void)
6326 {
6327         xfs_bmap_intent_cache = kmem_cache_create("xfs_bmap_intent",
6328                         sizeof(struct xfs_bmap_intent),
6329                         0, 0, NULL);
6330
6331         return xfs_bmap_intent_cache != NULL ? 0 : -ENOMEM;
6332 }
6333
6334 void
6335 xfs_bmap_intent_destroy_cache(void)
6336 {
6337         kmem_cache_destroy(xfs_bmap_intent_cache);
6338         xfs_bmap_intent_cache = NULL;
6339 }
6340
6341 /* Check that an inode's extent does not have invalid flags or bad ranges. */
6342 xfs_failaddr_t
6343 xfs_bmap_validate_extent(
6344         struct xfs_inode        *ip,
6345         int                     whichfork,
6346         struct xfs_bmbt_irec    *irec)
6347 {
6348         return xfs_bmap_validate_extent_raw(ip->i_mount,
6349                         XFS_IS_REALTIME_INODE(ip), whichfork, irec);
6350 }
6351
6352 /*
6353  * Used in xfs_itruncate_extents().  This is the maximum number of extents
6354  * freed from a file in a single transaction.
6355  */
6356 #define XFS_ITRUNC_MAX_EXTENTS  2
6357
6358 /*
6359  * Unmap every extent in part of an inode's fork.  We don't do any higher level
6360  * invalidation work at all.
6361  */
6362 int
6363 xfs_bunmapi_range(
6364         struct xfs_trans        **tpp,
6365         struct xfs_inode        *ip,
6366         uint32_t                flags,
6367         xfs_fileoff_t           startoff,
6368         xfs_fileoff_t           endoff)
6369 {
6370         xfs_filblks_t           unmap_len = endoff - startoff + 1;
6371         int                     error = 0;
6372
6373         xfs_assert_ilocked(ip, XFS_ILOCK_EXCL);
6374
6375         while (unmap_len > 0) {
6376                 ASSERT((*tpp)->t_highest_agno == NULLAGNUMBER);
6377                 error = __xfs_bunmapi(*tpp, ip, startoff, &unmap_len, flags,
6378                                 XFS_ITRUNC_MAX_EXTENTS);
6379                 if (error)
6380                         goto out;
6381
6382                 /* free the just unmapped extents */
6383                 error = xfs_defer_finish(tpp);
6384                 if (error)
6385                         goto out;
6386         }
6387 out:
6388         return error;
6389 }
6390
6391 struct xfs_bmap_query_range {
6392         xfs_bmap_query_range_fn fn;
6393         void                    *priv;
6394 };
6395
6396 /* Format btree record and pass to our callback. */
6397 STATIC int
6398 xfs_bmap_query_range_helper(
6399         struct xfs_btree_cur            *cur,
6400         const union xfs_btree_rec       *rec,
6401         void                            *priv)
6402 {
6403         struct xfs_bmap_query_range     *query = priv;
6404         struct xfs_bmbt_irec            irec;
6405         xfs_failaddr_t                  fa;
6406
6407         xfs_bmbt_disk_get_all(&rec->bmbt, &irec);
6408         fa = xfs_bmap_validate_extent(cur->bc_ino.ip, cur->bc_ino.whichfork,
6409                         &irec);
6410         if (fa) {
6411                 xfs_btree_mark_sick(cur);
6412                 return xfs_bmap_complain_bad_rec(cur->bc_ino.ip,
6413                                 cur->bc_ino.whichfork, fa, &irec);
6414         }
6415
6416         return query->fn(cur, &irec, query->priv);
6417 }
6418
6419 /* Find all bmaps. */
6420 int
6421 xfs_bmap_query_all(
6422         struct xfs_btree_cur            *cur,
6423         xfs_bmap_query_range_fn         fn,
6424         void                            *priv)
6425 {
6426         struct xfs_bmap_query_range     query = {
6427                 .priv                   = priv,
6428                 .fn                     = fn,
6429         };
6430
6431         return xfs_btree_query_all(cur, xfs_bmap_query_range_helper, &query);
6432 }