fs/xfs/xfs_bmap_util.c

   1 /*
   2  * Copyright (c) 2000-2006 Silicon Graphics, Inc.
   3  * Copyright (c) 2012 Red Hat, Inc.
   4  * All Rights Reserved.
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License as
   8  * published by the Free Software Foundation.
   9  *
  10  * This program is distributed in the hope that it would be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write the Free Software Foundation,
  17  * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  18  */
  19 #include "xfs.h"
  20 #include "xfs_fs.h"
  21 #include "xfs_shared.h"
  22 #include "xfs_format.h"
  23 #include "xfs_log_format.h"
  24 #include "xfs_trans_resv.h"
  25 #include "xfs_bit.h"
  26 #include "xfs_mount.h"
  27 #include "xfs_da_format.h"
  28 #include "xfs_inode.h"
  29 #include "xfs_btree.h"
  30 #include "xfs_trans.h"
  31 #include "xfs_extfree_item.h"
  32 #include "xfs_alloc.h"
  33 #include "xfs_bmap.h"
  34 #include "xfs_bmap_util.h"
  35 #include "xfs_bmap_btree.h"
  36 #include "xfs_rtalloc.h"
  37 #include "xfs_error.h"
  38 #include "xfs_quota.h"
  39 #include "xfs_trans_space.h"
  40 #include "xfs_trace.h"
  41 #include "xfs_icache.h"
  42 #include "xfs_log.h"
  43
  44 /* Kernel only BMAP related definitions and functions */
  45
  46 /*
  47  * Convert the given file system block to a disk block.  We have to treat it
  48  * differently based on whether the file is a real time file or not, because the
  49  * bmap code does.
  50  */
  51 xfs_daddr_t
  52 xfs_fsb_to_db(struct xfs_inode *ip, xfs_fsblock_t fsb)
  53 {
  54         return (XFS_IS_REALTIME_INODE(ip) ? \
  55                  (xfs_daddr_t)XFS_FSB_TO_BB((ip)->i_mount, (fsb)) : \
  56                  XFS_FSB_TO_DADDR((ip)->i_mount, (fsb)));
  57 }
  58
  59 /*
  60  * Routine to be called at transaction's end by xfs_bmapi, xfs_bunmapi
  61  * caller.  Frees all the extents that need freeing, which must be done
  62  * last due to locking considerations.  We never free any extents in
  63  * the first transaction.
  64  *
  65  * Return 1 if the given transaction was committed and a new one
  66  * started, and 0 otherwise in the committed parameter.
  67  */
  68 int                                             /* error */
  69 xfs_bmap_finish(
  70         struct xfs_trans                **tp,   /* transaction pointer addr */
  71         struct xfs_bmap_free            *flist, /* i/o: list extents to free */
  72         int                             *committed)/* xact committed or not */
  73 {
  74         struct xfs_efd_log_item         *efd;   /* extent free data */
  75         struct xfs_efi_log_item         *efi;   /* extent free intention */
  76         int                             error;  /* error return value */
  77         struct xfs_bmap_free_item       *free;  /* free extent item */
  78         struct xfs_bmap_free_item       *next;  /* next item on free list */
  79
  80         ASSERT((*tp)->t_flags & XFS_TRANS_PERM_LOG_RES);
  81         if (flist->xbf_count == 0) {
  82                 *committed = 0;
  83                 return 0;
  84         }
  85         efi = xfs_trans_get_efi(*tp, flist->xbf_count);
  86         for (free = flist->xbf_first; free; free = free->xbfi_next)
  87                 xfs_trans_log_efi_extent(*tp, efi, free->xbfi_startblock,
  88                         free->xbfi_blockcount);
  89
  90         error = __xfs_trans_roll(tp, NULL, committed);
  91         if (error) {
  92                 /*
  93                  * If the transaction was committed, drop the EFD reference
  94                  * since we're bailing out of here. The other reference is
  95                  * dropped when the EFI hits the AIL.
  96                  *
  97                  * If the transaction was not committed, the EFI is freed by the
  98                  * EFI item unlock handler on abort. Also, we have a new
  99                  * transaction so we should return committed=1 even though we're
 100                  * returning an error.
 101                  */
 102                 if (*committed) {
 103                         xfs_efi_release(efi);
 104                         xfs_force_shutdown((*tp)->t_mountp,
 105                                 (error == -EFSCORRUPTED) ?
 106                                         SHUTDOWN_CORRUPT_INCORE :
 107                                         SHUTDOWN_META_IO_ERROR);
 108                 } else {
 109                         *committed = 1;
 110                 }
 111
 112                 return error;
 113         }
 114
 115         efd = xfs_trans_get_efd(*tp, efi, flist->xbf_count);
 116         for (free = flist->xbf_first; free != NULL; free = next) {
 117                 next = free->xbfi_next;
 118
 119                 /*
 120                  * Free the extent and log the EFD to dirty the transaction
 121                  * before handling errors. This ensures that the transaction is
 122                  * aborted, which:
 123                  *
 124                  * 1.) releases the EFI and frees the EFD
 125                  * 2.) shuts down the filesystem
 126                  *
 127                  * The bmap free list is cleaned up at a higher level.
 128                  */
 129                 error = xfs_free_extent(*tp, free->xbfi_startblock,
 130                                         free->xbfi_blockcount);
 131                 xfs_trans_log_efd_extent(*tp, efd, free->xbfi_startblock,
 132                                          free->xbfi_blockcount);
 133                 if (error)
 134                         return error;
 135
 136                 xfs_bmap_del_free(flist, NULL, free);
 137         }
 138
 139         return 0;
 140 }
 141
 142 int
 143 xfs_bmap_rtalloc(
 144         struct xfs_bmalloca     *ap)    /* bmap alloc argument struct */
 145 {
 146         xfs_alloctype_t atype = 0;      /* type for allocation routines */
 147         int             error;          /* error return value */
 148         xfs_mount_t     *mp;            /* mount point structure */
 149         xfs_extlen_t    prod = 0;       /* product factor for allocators */
 150         xfs_extlen_t    ralen = 0;      /* realtime allocation length */
 151         xfs_extlen_t    align;          /* minimum allocation alignment */
 152         xfs_rtblock_t   rtb;
 153
 154         mp = ap->ip->i_mount;
 155         align = xfs_get_extsz_hint(ap->ip);
 156         prod = align / mp->m_sb.sb_rextsize;
 157         error = xfs_bmap_extsize_align(mp, &ap->got, &ap->prev,
 158                                         align, 1, ap->eof, 0,
 159                                         ap->conv, &ap->offset, &ap->length);
 160         if (error)
 161                 return error;
 162         ASSERT(ap->length);
 163         ASSERT(ap->length % mp->m_sb.sb_rextsize == 0);
 164
 165         /*
 166          * If the offset & length are not perfectly aligned
 167          * then kill prod, it will just get us in trouble.
 168          */
 169         if (do_mod(ap->offset, align) || ap->length % align)
 170                 prod = 1;
 171         /*
 172          * Set ralen to be the actual requested length in rtextents.
 173          */
 174         ralen = ap->length / mp->m_sb.sb_rextsize;
 175         /*
 176          * If the old value was close enough to MAXEXTLEN that
 177          * we rounded up to it, cut it back so it's valid again.
 178          * Note that if it's a really large request (bigger than
 179          * MAXEXTLEN), we don't hear about that number, and can't
 180          * adjust the starting point to match it.
 181          */
 182         if (ralen * mp->m_sb.sb_rextsize >= MAXEXTLEN)
 183                 ralen = MAXEXTLEN / mp->m_sb.sb_rextsize;
 184
 185         /*
 186          * Lock out other modifications to the RT bitmap inode.
 187          */
 188         xfs_ilock(mp->m_rbmip, XFS_ILOCK_EXCL);
 189         xfs_trans_ijoin(ap->tp, mp->m_rbmip, XFS_ILOCK_EXCL);
 190
 191         /*
 192          * If it's an allocation to an empty file at offset 0,
 193          * pick an extent that will space things out in the rt area.
 194          */
 195         if (ap->eof && ap->offset == 0) {
 196                 xfs_rtblock_t uninitialized_var(rtx); /* realtime extent no */
 197
 198                 error = xfs_rtpick_extent(mp, ap->tp, ralen, &rtx);
 199                 if (error)
 200                         return error;
 201                 ap->blkno = rtx * mp->m_sb.sb_rextsize;
 202         } else {
 203                 ap->blkno = 0;
 204         }
 205
 206         xfs_bmap_adjacent(ap);
 207
 208         /*
 209          * Realtime allocation, done through xfs_rtallocate_extent.
 210          */
 211         atype = ap->blkno == 0 ?  XFS_ALLOCTYPE_ANY_AG : XFS_ALLOCTYPE_NEAR_BNO;
 212         do_div(ap->blkno, mp->m_sb.sb_rextsize);
 213         rtb = ap->blkno;
 214         ap->length = ralen;
 215         if ((error = xfs_rtallocate_extent(ap->tp, ap->blkno, 1, ap->length,
 216                                 &ralen, atype, ap->wasdel, prod, &rtb)))
 217                 return error;
 218         if (rtb == NULLFSBLOCK && prod > 1 &&
 219             (error = xfs_rtallocate_extent(ap->tp, ap->blkno, 1,
 220                                            ap->length, &ralen, atype,
 221                                            ap->wasdel, 1, &rtb)))
 222                 return error;
 223         ap->blkno = rtb;
 224         if (ap->blkno != NULLFSBLOCK) {
 225                 ap->blkno *= mp->m_sb.sb_rextsize;
 226                 ralen *= mp->m_sb.sb_rextsize;
 227                 ap->length = ralen;
 228                 ap->ip->i_d.di_nblocks += ralen;
 229                 xfs_trans_log_inode(ap->tp, ap->ip, XFS_ILOG_CORE);
 230                 if (ap->wasdel)
 231                         ap->ip->i_delayed_blks -= ralen;
 232                 /*
 233                  * Adjust the disk quota also. This was reserved
 234                  * earlier.
 235                  */
 236                 xfs_trans_mod_dquot_byino(ap->tp, ap->ip,
 237                         ap->wasdel ? XFS_TRANS_DQ_DELRTBCOUNT :
 238                                         XFS_TRANS_DQ_RTBCOUNT, (long) ralen);
 239         } else {
 240                 ap->length = 0;
 241         }
 242         return 0;
 243 }
 244
 245 /*
 246  * Check if the endoff is outside the last extent. If so the caller will grow
 247  * the allocation to a stripe unit boundary.  All offsets are considered outside
 248  * the end of file for an empty fork, so 1 is returned in *eof in that case.
 249  */
 250 int
 251 xfs_bmap_eof(
 252         struct xfs_inode        *ip,
 253         xfs_fileoff_t           endoff,
 254         int                     whichfork,
 255         int                     *eof)
 256 {
 257         struct xfs_bmbt_irec    rec;
 258         int                     error;
 259
 260         error = xfs_bmap_last_extent(NULL, ip, whichfork, &rec, eof);
 261         if (error || *eof)
 262                 return error;
 263
 264         *eof = endoff >= rec.br_startoff + rec.br_blockcount;
 265         return 0;
 266 }
 267
 268 /*
 269  * Extent tree block counting routines.
 270  */
 271
 272 /*
 273  * Count leaf blocks given a range of extent records.
 274  */
 275 STATIC void
 276 xfs_bmap_count_leaves(
 277         xfs_ifork_t             *ifp,
 278         xfs_extnum_t            idx,
 279         int                     numrecs,
 280         int                     *count)
 281 {
 282         int             b;
 283
 284         for (b = 0; b < numrecs; b++) {
 285                 xfs_bmbt_rec_host_t *frp = xfs_iext_get_ext(ifp, idx + b);
 286                 *count += xfs_bmbt_get_blockcount(frp);
 287         }
 288 }
 289
 290 /*
 291  * Count leaf blocks given a range of extent records originally
 292  * in btree format.
 293  */
 294 STATIC void
 295 xfs_bmap_disk_count_leaves(
 296         struct xfs_mount        *mp,
 297         struct xfs_btree_block  *block,
 298         int                     numrecs,
 299         int                     *count)
 300 {
 301         int             b;
 302         xfs_bmbt_rec_t  *frp;
 303
 304         for (b = 1; b <= numrecs; b++) {
 305                 frp = XFS_BMBT_REC_ADDR(mp, block, b);
 306                 *count += xfs_bmbt_disk_get_blockcount(frp);
 307         }
 308 }
 309
 310 /*
 311  * Recursively walks each level of a btree
 312  * to count total fsblocks in use.
 313  */
 314 STATIC int                                     /* error */
 315 xfs_bmap_count_tree(
 316         xfs_mount_t     *mp,            /* file system mount point */
 317         xfs_trans_t     *tp,            /* transaction pointer */
 318         xfs_ifork_t     *ifp,           /* inode fork pointer */
 319         xfs_fsblock_t   blockno,        /* file system block number */
 320         int             levelin,        /* level in btree */
 321         int             *count)         /* Count of blocks */
 322 {
 323         int                     error;
 324         xfs_buf_t               *bp, *nbp;
 325         int                     level = levelin;
 326         __be64                  *pp;
 327         xfs_fsblock_t           bno = blockno;
 328         xfs_fsblock_t           nextbno;
 329         struct xfs_btree_block  *block, *nextblock;
 330         int                     numrecs;
 331
 332         error = xfs_btree_read_bufl(mp, tp, bno, 0, &bp, XFS_BMAP_BTREE_REF,
 333                                                 &xfs_bmbt_buf_ops);
 334         if (error)
 335                 return error;
 336         *count += 1;
 337         block = XFS_BUF_TO_BLOCK(bp);
 338
 339         if (--level) {
 340                 /* Not at node above leaves, count this level of nodes */
 341                 nextbno = be64_to_cpu(block->bb_u.l.bb_rightsib);
 342                 while (nextbno != NULLFSBLOCK) {
 343                         error = xfs_btree_read_bufl(mp, tp, nextbno, 0, &nbp,
 344                                                 XFS_BMAP_BTREE_REF,
 345                                                 &xfs_bmbt_buf_ops);
 346                         if (error)
 347                                 return error;
 348                         *count += 1;
 349                         nextblock = XFS_BUF_TO_BLOCK(nbp);
 350                         nextbno = be64_to_cpu(nextblock->bb_u.l.bb_rightsib);
 351                         xfs_trans_brelse(tp, nbp);
 352                 }
 353
 354                 /* Dive to the next level */
 355                 pp = XFS_BMBT_PTR_ADDR(mp, block, 1, mp->m_bmap_dmxr[1]);
 356                 bno = be64_to_cpu(*pp);
 357                 if (unlikely((error =
 358                      xfs_bmap_count_tree(mp, tp, ifp, bno, level, count)) < 0)) {
 359                         xfs_trans_brelse(tp, bp);
 360                         XFS_ERROR_REPORT("xfs_bmap_count_tree(1)",
 361                                          XFS_ERRLEVEL_LOW, mp);
 362                         return -EFSCORRUPTED;
 363                 }
 364                 xfs_trans_brelse(tp, bp);
 365         } else {
 366                 /* count all level 1 nodes and their leaves */
 367                 for (;;) {
 368                         nextbno = be64_to_cpu(block->bb_u.l.bb_rightsib);
 369                         numrecs = be16_to_cpu(block->bb_numrecs);
 370                         xfs_bmap_disk_count_leaves(mp, block, numrecs, count);
 371                         xfs_trans_brelse(tp, bp);
 372                         if (nextbno == NULLFSBLOCK)
 373                                 break;
 374                         bno = nextbno;
 375                         error = xfs_btree_read_bufl(mp, tp, bno, 0, &bp,
 376                                                 XFS_BMAP_BTREE_REF,
 377                                                 &xfs_bmbt_buf_ops);
 378                         if (error)
 379                                 return error;
 380                         *count += 1;
 381                         block = XFS_BUF_TO_BLOCK(bp);
 382                 }
 383         }
 384         return 0;
 385 }
 386
 387 /*
 388  * Count fsblocks of the given fork.
 389  */
 390 int                                             /* error */
 391 xfs_bmap_count_blocks(
 392         xfs_trans_t             *tp,            /* transaction pointer */
 393         xfs_inode_t             *ip,            /* incore inode */
 394         int                     whichfork,      /* data or attr fork */
 395         int                     *count)         /* out: count of blocks */
 396 {
 397         struct xfs_btree_block  *block; /* current btree block */
 398         xfs_fsblock_t           bno;    /* block # of "block" */
 399         xfs_ifork_t             *ifp;   /* fork structure */
 400         int                     level;  /* btree level, for checking */
 401         xfs_mount_t             *mp;    /* file system mount structure */
 402         __be64                  *pp;    /* pointer to block address */
 403
 404         bno = NULLFSBLOCK;
 405         mp = ip->i_mount;
 406         ifp = XFS_IFORK_PTR(ip, whichfork);
 407         if ( XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_EXTENTS ) {
 408                 xfs_bmap_count_leaves(ifp, 0,
 409                         ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t),
 410                         count);
 411                 return 0;
 412         }
 413
 414         /*
 415          * Root level must use BMAP_BROOT_PTR_ADDR macro to get ptr out.
 416          */
 417         block = ifp->if_broot;
 418         level = be16_to_cpu(block->bb_level);
 419         ASSERT(level > 0);
 420         pp = XFS_BMAP_BROOT_PTR_ADDR(mp, block, 1, ifp->if_broot_bytes);
 421         bno = be64_to_cpu(*pp);
 422         ASSERT(bno != NULLFSBLOCK);
 423         ASSERT(XFS_FSB_TO_AGNO(mp, bno) < mp->m_sb.sb_agcount);
 424         ASSERT(XFS_FSB_TO_AGBNO(mp, bno) < mp->m_sb.sb_agblocks);
 425
 426         if (unlikely(xfs_bmap_count_tree(mp, tp, ifp, bno, level, count) < 0)) {
 427                 XFS_ERROR_REPORT("xfs_bmap_count_blocks(2)", XFS_ERRLEVEL_LOW,
 428                                  mp);
 429                 return -EFSCORRUPTED;
 430         }
 431
 432         return 0;
 433 }
 434
 435 /*
 436  * returns 1 for success, 0 if we failed to map the extent.
 437  */
 438 STATIC int
 439 xfs_getbmapx_fix_eof_hole(
 440         xfs_inode_t             *ip,            /* xfs incore inode pointer */
 441         struct getbmapx         *out,           /* output structure */
 442         int                     prealloced,     /* this is a file with
 443                                                  * preallocated data space */
 444         __int64_t               end,            /* last block requested */
 445         xfs_fsblock_t           startblock)
 446 {
 447         __int64_t               fixlen;
 448         xfs_mount_t             *mp;            /* file system mount point */
 449         xfs_ifork_t             *ifp;           /* inode fork pointer */
 450         xfs_extnum_t            lastx;          /* last extent pointer */
 451         xfs_fileoff_t           fileblock;
 452
 453         if (startblock == HOLESTARTBLOCK) {
 454                 mp = ip->i_mount;
 455                 out->bmv_block = -1;
 456                 fixlen = XFS_FSB_TO_BB(mp, XFS_B_TO_FSB(mp, XFS_ISIZE(ip)));
 457                 fixlen -= out->bmv_offset;
 458                 if (prealloced && out->bmv_offset + out->bmv_length == end) {
 459                         /* Came to hole at EOF. Trim it. */
 460                         if (fixlen <= 0)
 461                                 return 0;
 462                         out->bmv_length = fixlen;
 463                 }
 464         } else {
 465                 if (startblock == DELAYSTARTBLOCK)
 466                         out->bmv_block = -2;
 467                 else
 468                         out->bmv_block = xfs_fsb_to_db(ip, startblock);
 469                 fileblock = XFS_BB_TO_FSB(ip->i_mount, out->bmv_offset);
 470                 ifp = XFS_IFORK_PTR(ip, XFS_DATA_FORK);
 471                 if (xfs_iext_bno_to_ext(ifp, fileblock, &lastx) &&
 472                    (lastx == (ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t))-1))
 473                         out->bmv_oflags |= BMV_OF_LAST;
 474         }
 475
 476         return 1;
 477 }
 478
 479 /*
 480  * Get inode's extents as described in bmv, and format for output.
 481  * Calls formatter to fill the user's buffer until all extents
 482  * are mapped, until the passed-in bmv->bmv_count slots have
 483  * been filled, or until the formatter short-circuits the loop,
 484  * if it is tracking filled-in extents on its own.
 485  */
 486 int                                             /* error code */
 487 xfs_getbmap(
 488         xfs_inode_t             *ip,
 489         struct getbmapx         *bmv,           /* user bmap structure */
 490         xfs_bmap_format_t       formatter,      /* format to user */
 491         void                    *arg)           /* formatter arg */
 492 {
 493         __int64_t               bmvend;         /* last block requested */
 494         int                     error = 0;      /* return value */
 495         __int64_t               fixlen;         /* length for -1 case */
 496         int                     i;              /* extent number */
 497         int                     lock;           /* lock state */
 498         xfs_bmbt_irec_t         *map;           /* buffer for user's data */
 499         xfs_mount_t             *mp;            /* file system mount point */
 500         int                     nex;            /* # of user extents can do */
 501         int                     nexleft;        /* # of user extents left */
 502         int                     subnex;         /* # of bmapi's can do */
 503         int                     nmap;           /* number of map entries */
 504         struct getbmapx         *out;           /* output structure */
 505         int                     whichfork;      /* data or attr fork */
 506         int                     prealloced;     /* this is a file with
 507                                                  * preallocated data space */
 508         int                     iflags;         /* interface flags */
 509         int                     bmapi_flags;    /* flags for xfs_bmapi */
 510         int                     cur_ext = 0;
 511
 512         mp = ip->i_mount;
 513         iflags = bmv->bmv_iflags;
 514         whichfork = iflags & BMV_IF_ATTRFORK ? XFS_ATTR_FORK : XFS_DATA_FORK;
 515
 516         if (whichfork == XFS_ATTR_FORK) {
 517                 if (XFS_IFORK_Q(ip)) {
 518                         if (ip->i_d.di_aformat != XFS_DINODE_FMT_EXTENTS &&
 519                             ip->i_d.di_aformat != XFS_DINODE_FMT_BTREE &&
 520                             ip->i_d.di_aformat != XFS_DINODE_FMT_LOCAL)
 521                                 return -EINVAL;
 522                 } else if (unlikely(
 523                            ip->i_d.di_aformat != 0 &&
 524                            ip->i_d.di_aformat != XFS_DINODE_FMT_EXTENTS)) {
 525                         XFS_ERROR_REPORT("xfs_getbmap", XFS_ERRLEVEL_LOW,
 526                                          ip->i_mount);
 527                         return -EFSCORRUPTED;
 528                 }
 529
 530                 prealloced = 0;
 531                 fixlen = 1LL << 32;
 532         } else {
 533                 if (ip->i_d.di_format != XFS_DINODE_FMT_EXTENTS &&
 534                     ip->i_d.di_format != XFS_DINODE_FMT_BTREE &&
 535                     ip->i_d.di_format != XFS_DINODE_FMT_LOCAL)
 536                         return -EINVAL;
 537
 538                 if (xfs_get_extsz_hint(ip) ||
 539                     ip->i_d.di_flags & (XFS_DIFLAG_PREALLOC|XFS_DIFLAG_APPEND)){
 540                         prealloced = 1;
 541                         fixlen = mp->m_super->s_maxbytes;
 542                 } else {
 543                         prealloced = 0;
 544                         fixlen = XFS_ISIZE(ip);
 545                 }
 546         }
 547
 548         if (bmv->bmv_length == -1) {
 549                 fixlen = XFS_FSB_TO_BB(mp, XFS_B_TO_FSB(mp, fixlen));
 550                 bmv->bmv_length =
 551                         max_t(__int64_t, fixlen - bmv->bmv_offset, 0);
 552         } else if (bmv->bmv_length == 0) {
 553                 bmv->bmv_entries = 0;
 554                 return 0;
 555         } else if (bmv->bmv_length < 0) {
 556                 return -EINVAL;
 557         }
 558
 559         nex = bmv->bmv_count - 1;
 560         if (nex <= 0)
 561                 return -EINVAL;
 562         bmvend = bmv->bmv_offset + bmv->bmv_length;
 563
 564
 565         if (bmv->bmv_count > ULONG_MAX / sizeof(struct getbmapx))
 566                 return -ENOMEM;
 567         out = kmem_zalloc_large(bmv->bmv_count * sizeof(struct getbmapx), 0);
 568         if (!out)
 569                 return -ENOMEM;
 570
 571         xfs_ilock(ip, XFS_IOLOCK_SHARED);
 572         if (whichfork == XFS_DATA_FORK) {
 573                 if (!(iflags & BMV_IF_DELALLOC) &&
 574                     (ip->i_delayed_blks || XFS_ISIZE(ip) > ip->i_d.di_size)) {
 575                         error = filemap_write_and_wait(VFS_I(ip)->i_mapping);
 576                         if (error)
 577                                 goto out_unlock_iolock;
 578
 579                         /*
 580                          * Even after flushing the inode, there can still be
 581                          * delalloc blocks on the inode beyond EOF due to
 582                          * speculative preallocation.  These are not removed
 583                          * until the release function is called or the inode
 584                          * is inactivated.  Hence we cannot assert here that
 585                          * ip->i_delayed_blks == 0.
 586                          */
 587                 }
 588
 589                 lock = xfs_ilock_data_map_shared(ip);
 590         } else {
 591                 lock = xfs_ilock_attr_map_shared(ip);
 592         }
 593
 594         /*
 595          * Don't let nex be bigger than the number of extents
 596          * we can have assuming alternating holes and real extents.
 597          */
 598         if (nex > XFS_IFORK_NEXTENTS(ip, whichfork) * 2 + 1)
 599                 nex = XFS_IFORK_NEXTENTS(ip, whichfork) * 2 + 1;
 600
 601         bmapi_flags = xfs_bmapi_aflag(whichfork);
 602         if (!(iflags & BMV_IF_PREALLOC))
 603                 bmapi_flags |= XFS_BMAPI_IGSTATE;
 604
 605         /*
 606          * Allocate enough space to handle "subnex" maps at a time.
 607          */
 608         error = -ENOMEM;
 609         subnex = 16;
 610         map = kmem_alloc(subnex * sizeof(*map), KM_MAYFAIL | KM_NOFS);
 611         if (!map)
 612                 goto out_unlock_ilock;
 613
 614         bmv->bmv_entries = 0;
 615
 616         if (XFS_IFORK_NEXTENTS(ip, whichfork) == 0 &&
 617             (whichfork == XFS_ATTR_FORK || !(iflags & BMV_IF_DELALLOC))) {
 618                 error = 0;
 619                 goto out_free_map;
 620         }
 621
 622         nexleft = nex;
 623
 624         do {
 625                 nmap = (nexleft > subnex) ? subnex : nexleft;
 626                 error = xfs_bmapi_read(ip, XFS_BB_TO_FSBT(mp, bmv->bmv_offset),
 627                                        XFS_BB_TO_FSB(mp, bmv->bmv_length),
 628                                        map, &nmap, bmapi_flags);
 629                 if (error)
 630                         goto out_free_map;
 631                 ASSERT(nmap <= subnex);
 632
 633                 for (i = 0; i < nmap && nexleft && bmv->bmv_length; i++) {
 634                         out[cur_ext].bmv_oflags = 0;
 635                         if (map[i].br_state == XFS_EXT_UNWRITTEN)
 636                                 out[cur_ext].bmv_oflags |= BMV_OF_PREALLOC;
 637                         else if (map[i].br_startblock == DELAYSTARTBLOCK)
 638                                 out[cur_ext].bmv_oflags |= BMV_OF_DELALLOC;
 639                         out[cur_ext].bmv_offset =
 640                                 XFS_FSB_TO_BB(mp, map[i].br_startoff);
 641                         out[cur_ext].bmv_length =
 642                                 XFS_FSB_TO_BB(mp, map[i].br_blockcount);
 643                         out[cur_ext].bmv_unused1 = 0;
 644                         out[cur_ext].bmv_unused2 = 0;
 645
 646                         /*
 647                          * delayed allocation extents that start beyond EOF can
 648                          * occur due to speculative EOF allocation when the
 649                          * delalloc extent is larger than the largest freespace
 650                          * extent at conversion time. These extents cannot be
 651                          * converted by data writeback, so can exist here even
 652                          * if we are not supposed to be finding delalloc
 653                          * extents.
 654                          */
 655                         if (map[i].br_startblock == DELAYSTARTBLOCK &&
 656                             map[i].br_startoff <= XFS_B_TO_FSB(mp, XFS_ISIZE(ip)))
 657                                 ASSERT((iflags & BMV_IF_DELALLOC) != 0);
 658
 659                         if (map[i].br_startblock == HOLESTARTBLOCK &&
 660                             whichfork == XFS_ATTR_FORK) {
 661                                 /* came to the end of attribute fork */
 662                                 out[cur_ext].bmv_oflags |= BMV_OF_LAST;
 663                                 goto out_free_map;
 664                         }
 665
 666                         if (!xfs_getbmapx_fix_eof_hole(ip, &out[cur_ext],
 667                                         prealloced, bmvend,
 668                                         map[i].br_startblock))
 669                                 goto out_free_map;
 670
 671                         bmv->bmv_offset =
 672                                 out[cur_ext].bmv_offset +
 673                                 out[cur_ext].bmv_length;
 674                         bmv->bmv_length =
 675                                 max_t(__int64_t, 0, bmvend - bmv->bmv_offset);
 676
 677                         /*
 678                          * In case we don't want to return the hole,
 679                          * don't increase cur_ext so that we can reuse
 680                          * it in the next loop.
 681                          */
 682                         if ((iflags & BMV_IF_NO_HOLES) &&
 683                             map[i].br_startblock == HOLESTARTBLOCK) {
 684                                 memset(&out[cur_ext], 0, sizeof(out[cur_ext]));
 685                                 continue;
 686                         }
 687
 688                         nexleft--;
 689                         bmv->bmv_entries++;
 690                         cur_ext++;
 691                 }
 692         } while (nmap && nexleft && bmv->bmv_length);
 693
 694  out_free_map:
 695         kmem_free(map);
 696  out_unlock_ilock:
 697         xfs_iunlock(ip, lock);
 698  out_unlock_iolock:
 699         xfs_iunlock(ip, XFS_IOLOCK_SHARED);
 700
 701         for (i = 0; i < cur_ext; i++) {
 702                 int full = 0;   /* user array is full */
 703
 704                 /* format results & advance arg */
 705                 error = formatter(&arg, &out[i], &full);
 706                 if (error || full)
 707                         break;
 708         }
 709
 710         kmem_free(out);
 711         return error;
 712 }
 713
 714 /*
 715  * dead simple method of punching delalyed allocation blocks from a range in
 716  * the inode. Walks a block at a time so will be slow, but is only executed in
 717  * rare error cases so the overhead is not critical. This will always punch out
 718  * both the start and end blocks, even if the ranges only partially overlap
 719  * them, so it is up to the caller to ensure that partial blocks are not
 720  * passed in.
 721  */
 722 int
 723 xfs_bmap_punch_delalloc_range(
 724         struct xfs_inode        *ip,
 725         xfs_fileoff_t           start_fsb,
 726         xfs_fileoff_t           length)
 727 {
 728         xfs_fileoff_t           remaining = length;
 729         int                     error = 0;
 730
 731         ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
 732
 733         do {
 734                 int             done;
 735                 xfs_bmbt_irec_t imap;
 736                 int             nimaps = 1;
 737                 xfs_fsblock_t   firstblock;
 738                 xfs_bmap_free_t flist;
 739
 740                 /*
 741                  * Map the range first and check that it is a delalloc extent
 742                  * before trying to unmap the range. Otherwise we will be
 743                  * trying to remove a real extent (which requires a
 744                  * transaction) or a hole, which is probably a bad idea...
 745                  */
 746                 error = xfs_bmapi_read(ip, start_fsb, 1, &imap, &nimaps,
 747                                        XFS_BMAPI_ENTIRE);
 748
 749                 if (error) {
 750                         /* something screwed, just bail */
 751                         if (!XFS_FORCED_SHUTDOWN(ip->i_mount)) {
 752                                 xfs_alert(ip->i_mount,
 753                         "Failed delalloc mapping lookup ino %lld fsb %lld.",
 754                                                 ip->i_ino, start_fsb);
 755                         }
 756                         break;
 757                 }
 758                 if (!nimaps) {
 759                         /* nothing there */
 760                         goto next_block;
 761                 }
 762                 if (imap.br_startblock != DELAYSTARTBLOCK) {
 763                         /* been converted, ignore */
 764                         goto next_block;
 765                 }
 766                 WARN_ON(imap.br_blockcount == 0);
 767
 768                 /*
 769                  * Note: while we initialise the firstblock/flist pair, they
 770                  * should never be used because blocks should never be
 771                  * allocated or freed for a delalloc extent and hence we need
 772                  * don't cancel or finish them after the xfs_bunmapi() call.
 773                  */
 774                 xfs_bmap_init(&flist, &firstblock);
 775                 error = xfs_bunmapi(NULL, ip, start_fsb, 1, 0, 1, &firstblock,
 776                                         &flist, &done);
 777                 if (error)
 778                         break;
 779
 780                 ASSERT(!flist.xbf_count && !flist.xbf_first);
 781 next_block:
 782                 start_fsb++;
 783                 remaining--;
 784         } while(remaining > 0);
 785
 786         return error;
 787 }
 788
 789 /*
 790  * Test whether it is appropriate to check an inode for and free post EOF
 791  * blocks. The 'force' parameter determines whether we should also consider
 792  * regular files that are marked preallocated or append-only.
 793  */
 794 bool
 795 xfs_can_free_eofblocks(struct xfs_inode *ip, bool force)
 796 {
 797         /* prealloc/delalloc exists only on regular files */
 798         if (!S_ISREG(ip->i_d.di_mode))
 799                 return false;
 800
 801         /*
 802          * Zero sized files with no cached pages and delalloc blocks will not
 803          * have speculative prealloc/delalloc blocks to remove.
 804          */
 805         if (VFS_I(ip)->i_size == 0 &&
 806             VFS_I(ip)->i_mapping->nrpages == 0 &&
 807             ip->i_delayed_blks == 0)
 808                 return false;
 809
 810         /* If we haven't read in the extent list, then don't do it now. */
 811         if (!(ip->i_df.if_flags & XFS_IFEXTENTS))
 812                 return false;
 813
 814         /*
 815          * Do not free real preallocated or append-only files unless the file
 816          * has delalloc blocks and we are forced to remove them.
 817          */
 818         if (ip->i_d.di_flags & (XFS_DIFLAG_PREALLOC | XFS_DIFLAG_APPEND))
 819                 if (!force || ip->i_delayed_blks == 0)
 820                         return false;
 821
 822         return true;
 823 }
 824
 825 /*
 826  * This is called by xfs_inactive to free any blocks beyond eof
 827  * when the link count isn't zero and by xfs_dm_punch_hole() when
 828  * punching a hole to EOF.
 829  */
 830 int
 831 xfs_free_eofblocks(
 832         xfs_mount_t     *mp,
 833         xfs_inode_t     *ip,
 834         bool            need_iolock)
 835 {
 836         xfs_trans_t     *tp;
 837         int             error;
 838         xfs_fileoff_t   end_fsb;
 839         xfs_fileoff_t   last_fsb;
 840         xfs_filblks_t   map_len;
 841         int             nimaps;
 842         xfs_bmbt_irec_t imap;
 843
 844         /*
 845          * Figure out if there are any blocks beyond the end
 846          * of the file.  If not, then there is nothing to do.
 847          */
 848         end_fsb = XFS_B_TO_FSB(mp, (xfs_ufsize_t)XFS_ISIZE(ip));
 849         last_fsb = XFS_B_TO_FSB(mp, mp->m_super->s_maxbytes);
 850         if (last_fsb <= end_fsb)
 851                 return 0;
 852         map_len = last_fsb - end_fsb;
 853
 854         nimaps = 1;
 855         xfs_ilock(ip, XFS_ILOCK_SHARED);
 856         error = xfs_bmapi_read(ip, end_fsb, map_len, &imap, &nimaps, 0);
 857         xfs_iunlock(ip, XFS_ILOCK_SHARED);
 858
 859         if (!error && (nimaps != 0) &&
 860             (imap.br_startblock != HOLESTARTBLOCK ||
 861              ip->i_delayed_blks)) {
 862                 /*
 863                  * Attach the dquots to the inode up front.
 864                  */
 865                 error = xfs_qm_dqattach(ip, 0);
 866                 if (error)
 867                         return error;
 868
 869                 /*
 870                  * There are blocks after the end of file.
 871                  * Free them up now by truncating the file to
 872                  * its current size.
 873                  */
 874                 tp = xfs_trans_alloc(mp, XFS_TRANS_INACTIVE);
 875
 876                 if (need_iolock) {
 877                         if (!xfs_ilock_nowait(ip, XFS_IOLOCK_EXCL)) {
 878                                 xfs_trans_cancel(tp);
 879                                 return -EAGAIN;
 880                         }
 881                 }
 882
 883                 error = xfs_trans_reserve(tp, &M_RES(mp)->tr_itruncate, 0, 0);
 884                 if (error) {
 885                         ASSERT(XFS_FORCED_SHUTDOWN(mp));
 886                         xfs_trans_cancel(tp);
 887                         if (need_iolock)
 888                                 xfs_iunlock(ip, XFS_IOLOCK_EXCL);
 889                         return error;
 890                 }
 891
 892                 xfs_ilock(ip, XFS_ILOCK_EXCL);
 893                 xfs_trans_ijoin(tp, ip, 0);
 894
 895                 /*
 896                  * Do not update the on-disk file size.  If we update the
 897                  * on-disk file size and then the system crashes before the
 898                  * contents of the file are flushed to disk then the files
 899                  * may be full of holes (ie NULL files bug).
 900                  */
 901                 error = xfs_itruncate_extents(&tp, ip, XFS_DATA_FORK,
 902                                               XFS_ISIZE(ip));
 903                 if (error) {
 904                         /*
 905                          * If we get an error at this point we simply don't
 906                          * bother truncating the file.
 907                          */
 908                         xfs_trans_cancel(tp);
 909                 } else {
 910                         error = xfs_trans_commit(tp);
 911                         if (!error)
 912                                 xfs_inode_clear_eofblocks_tag(ip);
 913                 }
 914
 915                 xfs_iunlock(ip, XFS_ILOCK_EXCL);
 916                 if (need_iolock)
 917                         xfs_iunlock(ip, XFS_IOLOCK_EXCL);
 918         }
 919         return error;
 920 }
 921
 922 int
 923 xfs_alloc_file_space(
 924         struct xfs_inode        *ip,
 925         xfs_off_t               offset,
 926         xfs_off_t               len,
 927         int                     alloc_type)
 928 {
 929         xfs_mount_t             *mp = ip->i_mount;
 930         xfs_off_t               count;
 931         xfs_filblks_t           allocated_fsb;
 932         xfs_filblks_t           allocatesize_fsb;
 933         xfs_extlen_t            extsz, temp;
 934         xfs_fileoff_t           startoffset_fsb;
 935         xfs_fsblock_t           firstfsb;
 936         int                     nimaps;
 937         int                     quota_flag;
 938         int                     rt;
 939         xfs_trans_t             *tp;
 940         xfs_bmbt_irec_t         imaps[1], *imapp;
 941         xfs_bmap_free_t         free_list;
 942         uint                    qblocks, resblks, resrtextents;
 943         int                     committed;
 944         int                     error;
 945
 946         trace_xfs_alloc_file_space(ip);
 947
 948         if (XFS_FORCED_SHUTDOWN(mp))
 949                 return -EIO;
 950
 951         error = xfs_qm_dqattach(ip, 0);
 952         if (error)
 953                 return error;
 954
 955         if (len <= 0)
 956                 return -EINVAL;
 957
 958         rt = XFS_IS_REALTIME_INODE(ip);
 959         extsz = xfs_get_extsz_hint(ip);
 960
 961         count = len;
 962         imapp = &imaps[0];
 963         nimaps = 1;
 964         startoffset_fsb = XFS_B_TO_FSBT(mp, offset);
 965         allocatesize_fsb = XFS_B_TO_FSB(mp, count);
 966
 967         /*
 968          * Allocate file space until done or until there is an error
 969          */
 970         while (allocatesize_fsb && !error) {
 971                 xfs_fileoff_t   s, e;
 972
 973                 /*
 974                  * Determine space reservations for data/realtime.
 975                  */
 976                 if (unlikely(extsz)) {
 977                         s = startoffset_fsb;
 978                         do_div(s, extsz);
 979                         s *= extsz;
 980                         e = startoffset_fsb + allocatesize_fsb;
 981                         if ((temp = do_mod(startoffset_fsb, extsz)))
 982                                 e += temp;
 983                         if ((temp = do_mod(e, extsz)))
 984                                 e += extsz - temp;
 985                 } else {
 986                         s = 0;
 987                         e = allocatesize_fsb;
 988                 }
 989
 990                 /*
 991                  * The transaction reservation is limited to a 32-bit block
 992                  * count, hence we need to limit the number of blocks we are
 993                  * trying to reserve to avoid an overflow. We can't allocate
 994                  * more than @nimaps extents, and an extent is limited on disk
 995                  * to MAXEXTLEN (21 bits), so use that to enforce the limit.
 996                  */
 997                 resblks = min_t(xfs_fileoff_t, (e - s), (MAXEXTLEN * nimaps));
 998                 if (unlikely(rt)) {
 999                         resrtextents = qblocks = resblks;
1000                         resrtextents /= mp->m_sb.sb_rextsize;
1001                         resblks = XFS_DIOSTRAT_SPACE_RES(mp, 0);
1002                         quota_flag = XFS_QMOPT_RES_RTBLKS;
1003                 } else {
1004                         resrtextents = 0;
1005                         resblks = qblocks = XFS_DIOSTRAT_SPACE_RES(mp, resblks);
1006                         quota_flag = XFS_QMOPT_RES_REGBLKS;
1007                 }
1008
1009                 /*
1010                  * Allocate and setup the transaction.
1011                  */
1012                 tp = xfs_trans_alloc(mp, XFS_TRANS_DIOSTRAT);
1013                 error = xfs_trans_reserve(tp, &M_RES(mp)->tr_write,
1014                                           resblks, resrtextents);
1015                 /*
1016                  * Check for running out of space
1017                  */
1018                 if (error) {
1019                         /*
1020                          * Free the transaction structure.
1021                          */
1022                         ASSERT(error == -ENOSPC || XFS_FORCED_SHUTDOWN(mp));
1023                         xfs_trans_cancel(tp);
1024                         break;
1025                 }
1026                 xfs_ilock(ip, XFS_ILOCK_EXCL);
1027                 error = xfs_trans_reserve_quota_nblks(tp, ip, qblocks,
1028                                                       0, quota_flag);
1029                 if (error)
1030                         goto error1;
1031
1032                 xfs_trans_ijoin(tp, ip, 0);
1033
1034                 xfs_bmap_init(&free_list, &firstfsb);
1035                 error = xfs_bmapi_write(tp, ip, startoffset_fsb,
1036                                         allocatesize_fsb, alloc_type, &firstfsb,
1037                                         0, imapp, &nimaps, &free_list);
1038                 if (error) {
1039                         goto error0;
1040                 }
1041
1042                 /*
1043                  * Complete the transaction
1044                  */
1045                 error = xfs_bmap_finish(&tp, &free_list, &committed);
1046                 if (error) {
1047                         goto error0;
1048                 }
1049
1050                 error = xfs_trans_commit(tp);
1051                 xfs_iunlock(ip, XFS_ILOCK_EXCL);
1052                 if (error) {
1053                         break;
1054                 }
1055
1056                 allocated_fsb = imapp->br_blockcount;
1057
1058                 if (nimaps == 0) {
1059                         error = -ENOSPC;
1060                         break;
1061                 }
1062
1063                 startoffset_fsb += allocated_fsb;
1064                 allocatesize_fsb -= allocated_fsb;
1065         }
1066
1067         return error;
1068
1069 error0: /* Cancel bmap, unlock inode, unreserve quota blocks, cancel trans */
1070         xfs_bmap_cancel(&free_list);
1071         xfs_trans_unreserve_quota_nblks(tp, ip, (long)qblocks, 0, quota_flag);
1072
1073 error1: /* Just cancel transaction */
1074         xfs_trans_cancel(tp);
1075         xfs_iunlock(ip, XFS_ILOCK_EXCL);
1076         return error;
1077 }
1078
1079 /*
1080  * Zero file bytes between startoff and endoff inclusive.
1081  * The iolock is held exclusive and no blocks are buffered.
1082  *
1083  * This function is used by xfs_free_file_space() to zero
1084  * partial blocks when the range to free is not block aligned.
1085  * When unreserving space with boundaries that are not block
1086  * aligned we round up the start and round down the end
1087  * boundaries and then use this function to zero the parts of
1088  * the blocks that got dropped during the rounding.
1089  */
1090 STATIC int
1091 xfs_zero_remaining_bytes(
1092         xfs_inode_t             *ip,
1093         xfs_off_t               startoff,
1094         xfs_off_t               endoff)
1095 {
1096         xfs_bmbt_irec_t         imap;
1097         xfs_fileoff_t           offset_fsb;
1098         xfs_off_t               lastoffset;
1099         xfs_off_t               offset;
1100         xfs_buf_t               *bp;
1101         xfs_mount_t             *mp = ip->i_mount;
1102         int                     nimap;
1103         int                     error = 0;
1104
1105         /*
1106          * Avoid doing I/O beyond eof - it's not necessary
1107          * since nothing can read beyond eof.  The space will
1108          * be zeroed when the file is extended anyway.
1109          */
1110         if (startoff >= XFS_ISIZE(ip))
1111                 return 0;
1112
1113         if (endoff > XFS_ISIZE(ip))
1114                 endoff = XFS_ISIZE(ip);
1115
1116         for (offset = startoff; offset <= endoff; offset = lastoffset + 1) {
1117                 uint lock_mode;
1118
1119                 offset_fsb = XFS_B_TO_FSBT(mp, offset);
1120                 nimap = 1;
1121
1122                 lock_mode = xfs_ilock_data_map_shared(ip);
1123                 error = xfs_bmapi_read(ip, offset_fsb, 1, &imap, &nimap, 0);
1124                 xfs_iunlock(ip, lock_mode);
1125
1126                 if (error || nimap < 1)
1127                         break;
1128                 ASSERT(imap.br_blockcount >= 1);
1129                 ASSERT(imap.br_startoff == offset_fsb);
1130                 ASSERT(imap.br_startblock != DELAYSTARTBLOCK);
1131
1132                 if (imap.br_startblock == HOLESTARTBLOCK ||
1133                     imap.br_state == XFS_EXT_UNWRITTEN) {
1134                         /* skip the entire extent */
1135                         lastoffset = XFS_FSB_TO_B(mp, imap.br_startoff +
1136                                                       imap.br_blockcount) - 1;
1137                         continue;
1138                 }
1139
1140                 lastoffset = XFS_FSB_TO_B(mp, imap.br_startoff + 1) - 1;
1141                 if (lastoffset > endoff)
1142                         lastoffset = endoff;
1143
1144                 /* DAX can just zero the backing device directly */
1145                 if (IS_DAX(VFS_I(ip))) {
1146                         error = dax_zero_page_range(VFS_I(ip), offset,
1147                                                     lastoffset - offset + 1,
1148                                                     xfs_get_blocks_direct);
1149                         if (error)
1150                                 return error;
1151                         continue;
1152                 }
1153
1154                 error = xfs_buf_read_uncached(XFS_IS_REALTIME_INODE(ip) ?
1155                                 mp->m_rtdev_targp : mp->m_ddev_targp,
1156                                 xfs_fsb_to_db(ip, imap.br_startblock),
1157                                 BTOBB(mp->m_sb.sb_blocksize),
1158                                 0, &bp, NULL);
1159                 if (error)
1160                         return error;
1161
1162                 memset(bp->b_addr +
1163                                 (offset - XFS_FSB_TO_B(mp, imap.br_startoff)),
1164                        0, lastoffset - offset + 1);
1165
1166                 error = xfs_bwrite(bp);
1167                 xfs_buf_relse(bp);
1168                 if (error)
1169                         return error;
1170         }
1171         return error;
1172 }
1173
1174 int
1175 xfs_free_file_space(
1176         struct xfs_inode        *ip,
1177         xfs_off_t               offset,
1178         xfs_off_t               len)
1179 {
1180         int                     committed;
1181         int                     done;
1182         xfs_fileoff_t           endoffset_fsb;
1183         int                     error;
1184         xfs_fsblock_t           firstfsb;
1185         xfs_bmap_free_t         free_list;
1186         xfs_bmbt_irec_t         imap;
1187         xfs_off_t               ioffset;
1188         xfs_off_t               iendoffset;
1189         xfs_extlen_t            mod=0;
1190         xfs_mount_t             *mp;
1191         int                     nimap;
1192         uint                    resblks;
1193         xfs_off_t               rounding;
1194         int                     rt;
1195         xfs_fileoff_t           startoffset_fsb;
1196         xfs_trans_t             *tp;
1197
1198         mp = ip->i_mount;
1199
1200         trace_xfs_free_file_space(ip);
1201
1202         error = xfs_qm_dqattach(ip, 0);
1203         if (error)
1204                 return error;
1205
1206         error = 0;
1207         if (len <= 0)   /* if nothing being freed */
1208                 return error;
1209         rt = XFS_IS_REALTIME_INODE(ip);
1210         startoffset_fsb = XFS_B_TO_FSB(mp, offset);
1211         endoffset_fsb = XFS_B_TO_FSBT(mp, offset + len);
1212
1213         /* wait for the completion of any pending DIOs */
1214         inode_dio_wait(VFS_I(ip));
1215
1216         rounding = max_t(xfs_off_t, 1 << mp->m_sb.sb_blocklog, PAGE_CACHE_SIZE);
1217         ioffset = round_down(offset, rounding);
1218         iendoffset = round_up(offset + len, rounding) - 1;
1219         error = filemap_write_and_wait_range(VFS_I(ip)->i_mapping, ioffset,
1220                                              iendoffset);
1221         if (error)
1222                 goto out;
1223         truncate_pagecache_range(VFS_I(ip), ioffset, iendoffset);
1224
1225         /*
1226          * Need to zero the stuff we're not freeing, on disk.
1227          * If it's a realtime file & can't use unwritten extents then we
1228          * actually need to zero the extent edges.  Otherwise xfs_bunmapi
1229          * will take care of it for us.
1230          */
1231         if (rt && !xfs_sb_version_hasextflgbit(&mp->m_sb)) {
1232                 nimap = 1;
1233                 error = xfs_bmapi_read(ip, startoffset_fsb, 1,
1234                                         &imap, &nimap, 0);
1235                 if (error)
1236                         goto out;
1237                 ASSERT(nimap == 0 || nimap == 1);
1238                 if (nimap && imap.br_startblock != HOLESTARTBLOCK) {
1239                         xfs_daddr_t     block;
1240
1241                         ASSERT(imap.br_startblock != DELAYSTARTBLOCK);
1242                         block = imap.br_startblock;
1243                         mod = do_div(block, mp->m_sb.sb_rextsize);
1244                         if (mod)
1245                                 startoffset_fsb += mp->m_sb.sb_rextsize - mod;
1246                 }
1247                 nimap = 1;
1248                 error = xfs_bmapi_read(ip, endoffset_fsb - 1, 1,
1249                                         &imap, &nimap, 0);
1250                 if (error)
1251                         goto out;
1252                 ASSERT(nimap == 0 || nimap == 1);
1253                 if (nimap && imap.br_startblock != HOLESTARTBLOCK) {
1254                         ASSERT(imap.br_startblock != DELAYSTARTBLOCK);
1255                         mod++;
1256                         if (mod && (mod != mp->m_sb.sb_rextsize))
1257                                 endoffset_fsb -= mod;
1258                 }
1259         }
1260         if ((done = (endoffset_fsb <= startoffset_fsb)))
1261                 /*
1262                  * One contiguous piece to clear
1263                  */
1264                 error = xfs_zero_remaining_bytes(ip, offset, offset + len - 1);
1265         else {
1266                 /*
1267                  * Some full blocks, possibly two pieces to clear
1268                  */
1269                 if (offset < XFS_FSB_TO_B(mp, startoffset_fsb))
1270                         error = xfs_zero_remaining_bytes(ip, offset,
1271                                 XFS_FSB_TO_B(mp, startoffset_fsb) - 1);
1272                 if (!error &&
1273                     XFS_FSB_TO_B(mp, endoffset_fsb) < offset + len)
1274                         error = xfs_zero_remaining_bytes(ip,
1275                                 XFS_FSB_TO_B(mp, endoffset_fsb),
1276                                 offset + len - 1);
1277         }
1278
1279         /*
1280          * free file space until done or until there is an error
1281          */
1282         resblks = XFS_DIOSTRAT_SPACE_RES(mp, 0);
1283         while (!error && !done) {
1284
1285                 /*
1286                  * allocate and setup the transaction. Allow this
1287                  * transaction to dip into the reserve blocks to ensure
1288                  * the freeing of the space succeeds at ENOSPC.
1289                  */
1290                 tp = xfs_trans_alloc(mp, XFS_TRANS_DIOSTRAT);
1291                 error = xfs_trans_reserve(tp, &M_RES(mp)->tr_write, resblks, 0);
1292
1293                 /*
1294                  * check for running out of space
1295                  */
1296                 if (error) {
1297                         /*
1298                          * Free the transaction structure.
1299                          */
1300                         ASSERT(error == -ENOSPC || XFS_FORCED_SHUTDOWN(mp));
1301                         xfs_trans_cancel(tp);
1302                         break;
1303                 }
1304                 xfs_ilock(ip, XFS_ILOCK_EXCL);
1305                 error = xfs_trans_reserve_quota(tp, mp,
1306                                 ip->i_udquot, ip->i_gdquot, ip->i_pdquot,
1307                                 resblks, 0, XFS_QMOPT_RES_REGBLKS);
1308                 if (error)
1309                         goto error1;
1310
1311                 xfs_trans_ijoin(tp, ip, 0);
1312
1313                 /*
1314                  * issue the bunmapi() call to free the blocks
1315                  */
1316                 xfs_bmap_init(&free_list, &firstfsb);
1317                 error = xfs_bunmapi(tp, ip, startoffset_fsb,
1318                                   endoffset_fsb - startoffset_fsb,
1319                                   0, 2, &firstfsb, &free_list, &done);
1320                 if (error) {
1321                         goto error0;
1322                 }
1323
1324                 /*
1325                  * complete the transaction
1326                  */
1327                 error = xfs_bmap_finish(&tp, &free_list, &committed);
1328                 if (error) {
1329                         goto error0;
1330                 }
1331
1332                 error = xfs_trans_commit(tp);
1333                 xfs_iunlock(ip, XFS_ILOCK_EXCL);
1334         }
1335
1336  out:
1337         return error;
1338
1339  error0:
1340         xfs_bmap_cancel(&free_list);
1341  error1:
1342         xfs_trans_cancel(tp);
1343         xfs_iunlock(ip, XFS_ILOCK_EXCL);
1344         goto out;
1345 }
1346
1347 /*
1348  * Preallocate and zero a range of a file. This mechanism has the allocation
1349  * semantics of fallocate and in addition converts data in the range to zeroes.
1350  */
1351 int
1352 xfs_zero_file_space(
1353         struct xfs_inode        *ip,
1354         xfs_off_t               offset,
1355         xfs_off_t               len)
1356 {
1357         struct xfs_mount        *mp = ip->i_mount;
1358         uint                    blksize;
1359         int                     error;
1360
1361         trace_xfs_zero_file_space(ip);
1362
1363         blksize = 1 << mp->m_sb.sb_blocklog;
1364
1365         /*
1366          * Punch a hole and prealloc the range. We use hole punch rather than
1367          * unwritten extent conversion for two reasons:
1368          *
1369          * 1.) Hole punch handles partial block zeroing for us.
1370          *
1371          * 2.) If prealloc returns ENOSPC, the file range is still zero-valued
1372          * by virtue of the hole punch.
1373          */
1374         error = xfs_free_file_space(ip, offset, len);
1375         if (error)
1376                 goto out;
1377
1378         error = xfs_alloc_file_space(ip, round_down(offset, blksize),
1379                                      round_up(offset + len, blksize) -
1380                                      round_down(offset, blksize),
1381                                      XFS_BMAPI_PREALLOC);
1382 out:
1383         return error;
1384
1385 }
1386
1387 /*
1388  * @next_fsb will keep track of the extent currently undergoing shift.
1389  * @stop_fsb will keep track of the extent at which we have to stop.
1390  * If we are shifting left, we will start with block (offset + len) and
1391  * shift each extent till last extent.
1392  * If we are shifting right, we will start with last extent inside file space
1393  * and continue until we reach the block corresponding to offset.
1394  */
1395 static int
1396 xfs_shift_file_space(
1397         struct xfs_inode        *ip,
1398         xfs_off_t               offset,
1399         xfs_off_t               len,
1400         enum shift_direction    direction)
1401 {
1402         int                     done = 0;
1403         struct xfs_mount        *mp = ip->i_mount;
1404         struct xfs_trans        *tp;
1405         int                     error;
1406         struct xfs_bmap_free    free_list;
1407         xfs_fsblock_t           first_block;
1408         int                     committed;
1409         xfs_fileoff_t           stop_fsb;
1410         xfs_fileoff_t           next_fsb;
1411         xfs_fileoff_t           shift_fsb;
1412
1413         ASSERT(direction == SHIFT_LEFT || direction == SHIFT_RIGHT);
1414
1415         if (direction == SHIFT_LEFT) {
1416                 next_fsb = XFS_B_TO_FSB(mp, offset + len);
1417                 stop_fsb = XFS_B_TO_FSB(mp, VFS_I(ip)->i_size);
1418         } else {
1419                 /*
1420                  * If right shift, delegate the work of initialization of
1421                  * next_fsb to xfs_bmap_shift_extent as it has ilock held.
1422                  */
1423                 next_fsb = NULLFSBLOCK;
1424                 stop_fsb = XFS_B_TO_FSB(mp, offset);
1425         }
1426
1427         shift_fsb = XFS_B_TO_FSB(mp, len);
1428
1429         /*
1430          * Trim eofblocks to avoid shifting uninitialized post-eof preallocation
1431          * into the accessible region of the file.
1432          */
1433         if (xfs_can_free_eofblocks(ip, true)) {
1434                 error = xfs_free_eofblocks(mp, ip, false);
1435                 if (error)
1436                         return error;
1437         }
1438
1439         /*
1440          * Writeback and invalidate cache for the remainder of the file as we're
1441          * about to shift down every extent from offset to EOF.
1442          */
1443         error = filemap_write_and_wait_range(VFS_I(ip)->i_mapping,
1444                                              offset, -1);
1445         if (error)
1446                 return error;
1447         error = invalidate_inode_pages2_range(VFS_I(ip)->i_mapping,
1448                                         offset >> PAGE_CACHE_SHIFT, -1);
1449         if (error)
1450                 return error;
1451
1452         /*
1453          * The extent shiting code works on extent granularity. So, if
1454          * stop_fsb is not the starting block of extent, we need to split
1455          * the extent at stop_fsb.
1456          */
1457         if (direction == SHIFT_RIGHT) {
1458                 error = xfs_bmap_split_extent(ip, stop_fsb);
1459                 if (error)
1460                         return error;
1461         }
1462
1463         while (!error && !done) {
1464                 tp = xfs_trans_alloc(mp, XFS_TRANS_DIOSTRAT);
1465                 /*
1466                  * We would need to reserve permanent block for transaction.
1467                  * This will come into picture when after shifting extent into
1468                  * hole we found that adjacent extents can be merged which
1469                  * may lead to freeing of a block during record update.
1470                  */
1471                 error = xfs_trans_reserve(tp, &M_RES(mp)->tr_write,
1472                                 XFS_DIOSTRAT_SPACE_RES(mp, 0), 0);
1473                 if (error) {
1474                         xfs_trans_cancel(tp);
1475                         break;
1476                 }
1477
1478                 xfs_ilock(ip, XFS_ILOCK_EXCL);
1479                 error = xfs_trans_reserve_quota(tp, mp, ip->i_udquot,
1480                                 ip->i_gdquot, ip->i_pdquot,
1481                                 XFS_DIOSTRAT_SPACE_RES(mp, 0), 0,
1482                                 XFS_QMOPT_RES_REGBLKS);
1483                 if (error)
1484                         goto out;
1485
1486                 xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
1487
1488                 xfs_bmap_init(&free_list, &first_block);
1489
1490                 /*
1491                  * We are using the write transaction in which max 2 bmbt
1492                  * updates are allowed
1493                  */
1494                 error = xfs_bmap_shift_extents(tp, ip, &next_fsb, shift_fsb,
1495                                 &done, stop_fsb, &first_block, &free_list,
1496                                 direction, XFS_BMAP_MAX_SHIFT_EXTENTS);
1497                 if (error)
1498                         goto out;
1499
1500                 error = xfs_bmap_finish(&tp, &free_list, &committed);
1501                 if (error)
1502                         goto out;
1503
1504                 error = xfs_trans_commit(tp);
1505         }
1506
1507         return error;
1508
1509 out:
1510         xfs_trans_cancel(tp);
1511         return error;
1512 }
1513
1514 /*
1515  * xfs_collapse_file_space()
1516  *      This routine frees disk space and shift extent for the given file.
1517  *      The first thing we do is to free data blocks in the specified range
1518  *      by calling xfs_free_file_space(). It would also sync dirty data
1519  *      and invalidate page cache over the region on which collapse range
1520  *      is working. And Shift extent records to the left to cover a hole.
1521  * RETURNS:
1522  *      0 on success
1523  *      errno on error
1524  *
1525  */
1526 int
1527 xfs_collapse_file_space(
1528         struct xfs_inode        *ip,
1529         xfs_off_t               offset,
1530         xfs_off_t               len)
1531 {
1532         int error;
1533
1534         ASSERT(xfs_isilocked(ip, XFS_IOLOCK_EXCL));
1535         trace_xfs_collapse_file_space(ip);
1536
1537         error = xfs_free_file_space(ip, offset, len);
1538         if (error)
1539                 return error;
1540
1541         return xfs_shift_file_space(ip, offset, len, SHIFT_LEFT);
1542 }
1543
1544 /*
1545  * xfs_insert_file_space()
1546  *      This routine create hole space by shifting extents for the given file.
1547  *      The first thing we do is to sync dirty data and invalidate page cache
1548  *      over the region on which insert range is working. And split an extent
1549  *      to two extents at given offset by calling xfs_bmap_split_extent.
1550  *      And shift all extent records which are laying between [offset,
1551  *      last allocated extent] to the right to reserve hole range.
1552  * RETURNS:
1553  *      0 on success
1554  *      errno on error
1555  */
1556 int
1557 xfs_insert_file_space(
1558         struct xfs_inode        *ip,
1559         loff_t                  offset,
1560         loff_t                  len)
1561 {
1562         ASSERT(xfs_isilocked(ip, XFS_IOLOCK_EXCL));
1563         trace_xfs_insert_file_space(ip);
1564
1565         return xfs_shift_file_space(ip, offset, len, SHIFT_RIGHT);
1566 }
1567
1568 /*
1569  * We need to check that the format of the data fork in the temporary inode is
1570  * valid for the target inode before doing the swap. This is not a problem with
1571  * attr1 because of the fixed fork offset, but attr2 has a dynamically sized
1572  * data fork depending on the space the attribute fork is taking so we can get
1573  * invalid formats on the target inode.
1574  *
1575  * E.g. target has space for 7 extents in extent format, temp inode only has
1576  * space for 6.  If we defragment down to 7 extents, then the tmp format is a
1577  * btree, but when swapped it needs to be in extent format. Hence we can't just
1578  * blindly swap data forks on attr2 filesystems.
1579  *
1580  * Note that we check the swap in both directions so that we don't end up with
1581  * a corrupt temporary inode, either.
1582  *
1583  * Note that fixing the way xfs_fsr sets up the attribute fork in the source
1584  * inode will prevent this situation from occurring, so all we do here is
1585  * reject and log the attempt. basically we are putting the responsibility on
1586  * userspace to get this right.
1587  */
1588 static int
1589 xfs_swap_extents_check_format(
1590         xfs_inode_t     *ip,    /* target inode */
1591         xfs_inode_t     *tip)   /* tmp inode */
1592 {
1593
1594         /* Should never get a local format */
1595         if (ip->i_d.di_format == XFS_DINODE_FMT_LOCAL ||
1596             tip->i_d.di_format == XFS_DINODE_FMT_LOCAL)
1597                 return -EINVAL;
1598
1599         /*
1600          * if the target inode has less extents that then temporary inode then
1601          * why did userspace call us?
1602          */
1603         if (ip->i_d.di_nextents < tip->i_d.di_nextents)
1604                 return -EINVAL;
1605
1606         /*
1607          * if the target inode is in extent form and the temp inode is in btree
1608          * form then we will end up with the target inode in the wrong format
1609          * as we already know there are less extents in the temp inode.
1610          */
1611         if (ip->i_d.di_format == XFS_DINODE_FMT_EXTENTS &&
1612             tip->i_d.di_format == XFS_DINODE_FMT_BTREE)
1613                 return -EINVAL;
1614
1615         /* Check temp in extent form to max in target */
1616         if (tip->i_d.di_format == XFS_DINODE_FMT_EXTENTS &&
1617             XFS_IFORK_NEXTENTS(tip, XFS_DATA_FORK) >
1618                         XFS_IFORK_MAXEXT(ip, XFS_DATA_FORK))
1619                 return -EINVAL;
1620
1621         /* Check target in extent form to max in temp */
1622         if (ip->i_d.di_format == XFS_DINODE_FMT_EXTENTS &&
1623             XFS_IFORK_NEXTENTS(ip, XFS_DATA_FORK) >
1624                         XFS_IFORK_MAXEXT(tip, XFS_DATA_FORK))
1625                 return -EINVAL;
1626
1627         /*
1628          * If we are in a btree format, check that the temp root block will fit
1629          * in the target and that it has enough extents to be in btree format
1630          * in the target.
1631          *
1632          * Note that we have to be careful to allow btree->extent conversions
1633          * (a common defrag case) which will occur when the temp inode is in
1634          * extent format...
1635          */
1636         if (tip->i_d.di_format == XFS_DINODE_FMT_BTREE) {
1637                 if (XFS_IFORK_BOFF(ip) &&
1638                     XFS_BMAP_BMDR_SPACE(tip->i_df.if_broot) > XFS_IFORK_BOFF(ip))
1639                         return -EINVAL;
1640                 if (XFS_IFORK_NEXTENTS(tip, XFS_DATA_FORK) <=
1641                     XFS_IFORK_MAXEXT(ip, XFS_DATA_FORK))
1642                         return -EINVAL;
1643         }
1644
1645         /* Reciprocal target->temp btree format checks */
1646         if (ip->i_d.di_format == XFS_DINODE_FMT_BTREE) {
1647                 if (XFS_IFORK_BOFF(tip) &&
1648                     XFS_BMAP_BMDR_SPACE(ip->i_df.if_broot) > XFS_IFORK_BOFF(tip))
1649                         return -EINVAL;
1650                 if (XFS_IFORK_NEXTENTS(ip, XFS_DATA_FORK) <=
1651                     XFS_IFORK_MAXEXT(tip, XFS_DATA_FORK))
1652                         return -EINVAL;
1653         }
1654
1655         return 0;
1656 }
1657
1658 static int
1659 xfs_swap_extent_flush(
1660         struct xfs_inode        *ip)
1661 {
1662         int     error;
1663
1664         error = filemap_write_and_wait(VFS_I(ip)->i_mapping);
1665         if (error)
1666                 return error;
1667         truncate_pagecache_range(VFS_I(ip), 0, -1);
1668
1669         /* Verify O_DIRECT for ftmp */
1670         if (VFS_I(ip)->i_mapping->nrpages)
1671                 return -EINVAL;
1672         return 0;
1673 }
1674
1675 int
1676 xfs_swap_extents(
1677         xfs_inode_t     *ip,    /* target inode */
1678         xfs_inode_t     *tip,   /* tmp inode */
1679         xfs_swapext_t   *sxp)
1680 {
1681         xfs_mount_t     *mp = ip->i_mount;
1682         xfs_trans_t     *tp;
1683         xfs_bstat_t     *sbp = &sxp->sx_stat;
1684         xfs_ifork_t     *tempifp, *ifp, *tifp;
1685         int             src_log_flags, target_log_flags;
1686         int             error = 0;
1687         int             aforkblks = 0;
1688         int             taforkblks = 0;
1689         __uint64_t      tmp;
1690         int             lock_flags;
1691
1692         tempifp = kmem_alloc(sizeof(xfs_ifork_t), KM_MAYFAIL);
1693         if (!tempifp) {
1694                 error = -ENOMEM;
1695                 goto out;
1696         }
1697
1698         /*
1699          * Lock the inodes against other IO, page faults and truncate to
1700          * begin with.  Then we can ensure the inodes are flushed and have no
1701          * page cache safely. Once we have done this we can take the ilocks and
1702          * do the rest of the checks.
1703          */
1704         lock_flags = XFS_IOLOCK_EXCL | XFS_MMAPLOCK_EXCL;
1705         xfs_lock_two_inodes(ip, tip, XFS_IOLOCK_EXCL);
1706         xfs_lock_two_inodes(ip, tip, XFS_MMAPLOCK_EXCL);
1707
1708         /* Verify that both files have the same format */
1709         if ((ip->i_d.di_mode & S_IFMT) != (tip->i_d.di_mode & S_IFMT)) {
1710                 error = -EINVAL;
1711                 goto out_unlock;
1712         }
1713
1714         /* Verify both files are either real-time or non-realtime */
1715         if (XFS_IS_REALTIME_INODE(ip) != XFS_IS_REALTIME_INODE(tip)) {
1716                 error = -EINVAL;
1717                 goto out_unlock;
1718         }
1719
1720         error = xfs_swap_extent_flush(ip);
1721         if (error)
1722                 goto out_unlock;
1723         error = xfs_swap_extent_flush(tip);
1724         if (error)
1725                 goto out_unlock;
1726
1727         tp = xfs_trans_alloc(mp, XFS_TRANS_SWAPEXT);
1728         error = xfs_trans_reserve(tp, &M_RES(mp)->tr_ichange, 0, 0);
1729         if (error) {
1730                 xfs_trans_cancel(tp);
1731                 goto out_unlock;
1732         }
1733
1734         /*
1735          * Lock and join the inodes to the tansaction so that transaction commit
1736          * or cancel will unlock the inodes from this point onwards.
1737          */
1738         xfs_lock_two_inodes(ip, tip, XFS_ILOCK_EXCL);
1739         lock_flags |= XFS_ILOCK_EXCL;
1740         xfs_trans_ijoin(tp, ip, lock_flags);
1741         xfs_trans_ijoin(tp, tip, lock_flags);
1742
1743
1744         /* Verify all data are being swapped */
1745         if (sxp->sx_offset != 0 ||
1746             sxp->sx_length != ip->i_d.di_size ||
1747             sxp->sx_length != tip->i_d.di_size) {
1748                 error = -EFAULT;
1749                 goto out_trans_cancel;
1750         }
1751
1752         trace_xfs_swap_extent_before(ip, 0);
1753         trace_xfs_swap_extent_before(tip, 1);
1754
1755         /* check inode formats now that data is flushed */
1756         error = xfs_swap_extents_check_format(ip, tip);
1757         if (error) {
1758                 xfs_notice(mp,
1759                     "%s: inode 0x%llx format is incompatible for exchanging.",
1760                                 __func__, ip->i_ino);
1761                 goto out_trans_cancel;
1762         }
1763
1764         /*
1765          * Compare the current change & modify times with that
1766          * passed in.  If they differ, we abort this swap.
1767          * This is the mechanism used to ensure the calling
1768          * process that the file was not changed out from
1769          * under it.
1770          */
1771         if ((sbp->bs_ctime.tv_sec != VFS_I(ip)->i_ctime.tv_sec) ||
1772             (sbp->bs_ctime.tv_nsec != VFS_I(ip)->i_ctime.tv_nsec) ||
1773             (sbp->bs_mtime.tv_sec != VFS_I(ip)->i_mtime.tv_sec) ||
1774             (sbp->bs_mtime.tv_nsec != VFS_I(ip)->i_mtime.tv_nsec)) {
1775                 error = -EBUSY;
1776                 goto out_trans_cancel;
1777         }
1778         /*
1779          * Count the number of extended attribute blocks
1780          */
1781         if ( ((XFS_IFORK_Q(ip) != 0) && (ip->i_d.di_anextents > 0)) &&
1782              (ip->i_d.di_aformat != XFS_DINODE_FMT_LOCAL)) {
1783                 error = xfs_bmap_count_blocks(tp, ip, XFS_ATTR_FORK, &aforkblks);
1784                 if (error)
1785                         goto out_trans_cancel;
1786         }
1787         if ( ((XFS_IFORK_Q(tip) != 0) && (tip->i_d.di_anextents > 0)) &&
1788              (tip->i_d.di_aformat != XFS_DINODE_FMT_LOCAL)) {
1789                 error = xfs_bmap_count_blocks(tp, tip, XFS_ATTR_FORK,
1790                         &taforkblks);
1791                 if (error)
1792                         goto out_trans_cancel;
1793         }
1794
1795         /*
1796          * Before we've swapped the forks, lets set the owners of the forks
1797          * appropriately. We have to do this as we are demand paging the btree
1798          * buffers, and so the validation done on read will expect the owner
1799          * field to be correctly set. Once we change the owners, we can swap the
1800          * inode forks.
1801          *
1802          * Note the trickiness in setting the log flags - we set the owner log
1803          * flag on the opposite inode (i.e. the inode we are setting the new
1804          * owner to be) because once we swap the forks and log that, log
1805          * recovery is going to see the fork as owned by the swapped inode,
1806          * not the pre-swapped inodes.
1807          */
1808         src_log_flags = XFS_ILOG_CORE;
1809         target_log_flags = XFS_ILOG_CORE;
1810         if (ip->i_d.di_version == 3 &&
1811             ip->i_d.di_format == XFS_DINODE_FMT_BTREE) {
1812                 target_log_flags |= XFS_ILOG_DOWNER;
1813                 error = xfs_bmbt_change_owner(tp, ip, XFS_DATA_FORK,
1814                                               tip->i_ino, NULL);
1815                 if (error)
1816                         goto out_trans_cancel;
1817         }
1818
1819         if (tip->i_d.di_version == 3 &&
1820             tip->i_d.di_format == XFS_DINODE_FMT_BTREE) {
1821                 src_log_flags |= XFS_ILOG_DOWNER;
1822                 error = xfs_bmbt_change_owner(tp, tip, XFS_DATA_FORK,
1823                                               ip->i_ino, NULL);
1824                 if (error)
1825                         goto out_trans_cancel;
1826         }
1827
1828         /*
1829          * Swap the data forks of the inodes
1830          */
1831         ifp = &ip->i_df;
1832         tifp = &tip->i_df;
1833         *tempifp = *ifp;        /* struct copy */
1834         *ifp = *tifp;           /* struct copy */
1835         *tifp = *tempifp;       /* struct copy */
1836
1837         /*
1838          * Fix the on-disk inode values
1839          */
1840         tmp = (__uint64_t)ip->i_d.di_nblocks;
1841         ip->i_d.di_nblocks = tip->i_d.di_nblocks - taforkblks + aforkblks;
1842         tip->i_d.di_nblocks = tmp + taforkblks - aforkblks;
1843
1844         tmp = (__uint64_t) ip->i_d.di_nextents;
1845         ip->i_d.di_nextents = tip->i_d.di_nextents;
1846         tip->i_d.di_nextents = tmp;
1847
1848         tmp = (__uint64_t) ip->i_d.di_format;
1849         ip->i_d.di_format = tip->i_d.di_format;
1850         tip->i_d.di_format = tmp;
1851
1852         /*
1853          * The extents in the source inode could still contain speculative
1854          * preallocation beyond EOF (e.g. the file is open but not modified
1855          * while defrag is in progress). In that case, we need to copy over the
1856          * number of delalloc blocks the data fork in the source inode is
1857          * tracking beyond EOF so that when the fork is truncated away when the
1858          * temporary inode is unlinked we don't underrun the i_delayed_blks
1859          * counter on that inode.
1860          */
1861         ASSERT(tip->i_delayed_blks == 0);
1862         tip->i_delayed_blks = ip->i_delayed_blks;
1863         ip->i_delayed_blks = 0;
1864
1865         switch (ip->i_d.di_format) {
1866         case XFS_DINODE_FMT_EXTENTS:
1867                 /* If the extents fit in the inode, fix the
1868                  * pointer.  Otherwise it's already NULL or
1869                  * pointing to the extent.
1870                  */
1871                 if (ip->i_d.di_nextents <= XFS_INLINE_EXTS) {
1872                         ifp->if_u1.if_extents =
1873                                 ifp->if_u2.if_inline_ext;
1874                 }
1875                 src_log_flags |= XFS_ILOG_DEXT;
1876                 break;
1877         case XFS_DINODE_FMT_BTREE:
1878                 ASSERT(ip->i_d.di_version < 3 ||
1879                        (src_log_flags & XFS_ILOG_DOWNER));
1880                 src_log_flags |= XFS_ILOG_DBROOT;
1881                 break;
1882         }
1883
1884         switch (tip->i_d.di_format) {
1885         case XFS_DINODE_FMT_EXTENTS:
1886                 /* If the extents fit in the inode, fix the
1887                  * pointer.  Otherwise it's already NULL or
1888                  * pointing to the extent.
1889                  */
1890                 if (tip->i_d.di_nextents <= XFS_INLINE_EXTS) {
1891                         tifp->if_u1.if_extents =
1892                                 tifp->if_u2.if_inline_ext;
1893                 }
1894                 target_log_flags |= XFS_ILOG_DEXT;
1895                 break;
1896         case XFS_DINODE_FMT_BTREE:
1897                 target_log_flags |= XFS_ILOG_DBROOT;
1898                 ASSERT(tip->i_d.di_version < 3 ||
1899                        (target_log_flags & XFS_ILOG_DOWNER));
1900                 break;
1901         }
1902
1903         xfs_trans_log_inode(tp, ip,  src_log_flags);
1904         xfs_trans_log_inode(tp, tip, target_log_flags);
1905
1906         /*
1907          * If this is a synchronous mount, make sure that the
1908          * transaction goes to disk before returning to the user.
1909          */
1910         if (mp->m_flags & XFS_MOUNT_WSYNC)
1911                 xfs_trans_set_sync(tp);
1912
1913         error = xfs_trans_commit(tp);
1914
1915         trace_xfs_swap_extent_after(ip, 0);
1916         trace_xfs_swap_extent_after(tip, 1);
1917 out:
1918         kmem_free(tempifp);
1919         return error;
1920
1921 out_unlock:
1922         xfs_iunlock(ip, lock_flags);
1923         xfs_iunlock(tip, lock_flags);
1924         goto out;
1925
1926 out_trans_cancel:
1927         xfs_trans_cancel(tp);
1928         goto out;
1929 }