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