fs/xfs/libxfs/xfs_bmap.c

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