fs/xfs/xfs_vnodeops.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
  19 #include "xfs.h"
  20 #include "xfs_fs.h"
  21 #include "xfs_types.h"
  22 #include "xfs_bit.h"
  23 #include "xfs_log.h"
  24 #include "xfs_trans.h"
  25 #include "xfs_sb.h"
  26 #include "xfs_ag.h"
  27 #include "xfs_dir2.h"
  28 #include "xfs_mount.h"
  29 #include "xfs_da_btree.h"
  30 #include "xfs_bmap_btree.h"
  31 #include "xfs_ialloc_btree.h"
  32 #include "xfs_dinode.h"
  33 #include "xfs_inode.h"
  34 #include "xfs_inode_item.h"
  35 #include "xfs_itable.h"
  36 #include "xfs_ialloc.h"
  37 #include "xfs_alloc.h"
  38 #include "xfs_bmap.h"
  39 #include "xfs_acl.h"
  40 #include "xfs_attr.h"
  41 #include "xfs_error.h"
  42 #include "xfs_quota.h"
  43 #include "xfs_utils.h"
  44 #include "xfs_rtalloc.h"
  45 #include "xfs_trans_space.h"
  46 #include "xfs_log_priv.h"
  47 #include "xfs_filestream.h"
  48 #include "xfs_vnodeops.h"
  49 #include "xfs_trace.h"
  50
  51 /*
  52  * The maximum pathlen is 1024 bytes. Since the minimum file system
  53  * blocksize is 512 bytes, we can get a max of 2 extents back from
  54  * bmapi.
  55  */
  56 #define SYMLINK_MAPS 2
  57
  58 STATIC int
  59 xfs_readlink_bmap(
  60         xfs_inode_t     *ip,
  61         char            *link)
  62 {
  63         xfs_mount_t     *mp = ip->i_mount;
  64         int             pathlen = ip->i_d.di_size;
  65         int             nmaps = SYMLINK_MAPS;
  66         xfs_bmbt_irec_t mval[SYMLINK_MAPS];
  67         xfs_daddr_t     d;
  68         int             byte_cnt;
  69         int             n;
  70         xfs_buf_t       *bp;
  71         int             error = 0;
  72
  73         error = xfs_bmapi_read(ip, 0, XFS_B_TO_FSB(mp, pathlen), mval, &nmaps,
  74                                0);
  75         if (error)
  76                 goto out;
  77
  78         for (n = 0; n < nmaps; n++) {
  79                 d = XFS_FSB_TO_DADDR(mp, mval[n].br_startblock);
  80                 byte_cnt = XFS_FSB_TO_B(mp, mval[n].br_blockcount);
  81
  82                 bp = xfs_buf_read(mp->m_ddev_targp, d, BTOBB(byte_cnt), 0);
  83                 if (!bp)
  84                         return XFS_ERROR(ENOMEM);
  85                 error = bp->b_error;
  86                 if (error) {
  87                         xfs_buf_ioerror_alert(bp, __func__);
  88                         xfs_buf_relse(bp);
  89                         goto out;
  90                 }
  91                 if (pathlen < byte_cnt)
  92                         byte_cnt = pathlen;
  93                 pathlen -= byte_cnt;
  94
  95                 memcpy(link, bp->b_addr, byte_cnt);
  96                 xfs_buf_relse(bp);
  97         }
  98
  99         link[ip->i_d.di_size] = '\0';
 100         error = 0;
 101
 102  out:
 103         return error;
 104 }
 105
 106 int
 107 xfs_readlink(
 108         xfs_inode_t     *ip,
 109         char            *link)
 110 {
 111         xfs_mount_t     *mp = ip->i_mount;
 112         xfs_fsize_t     pathlen;
 113         int             error = 0;
 114
 115         trace_xfs_readlink(ip);
 116
 117         if (XFS_FORCED_SHUTDOWN(mp))
 118                 return XFS_ERROR(EIO);
 119
 120         xfs_ilock(ip, XFS_ILOCK_SHARED);
 121
 122         pathlen = ip->i_d.di_size;
 123         if (!pathlen)
 124                 goto out;
 125
 126         if (pathlen < 0 || pathlen > MAXPATHLEN) {
 127                 xfs_alert(mp, "%s: inode (%llu) bad symlink length (%lld)",
 128                          __func__, (unsigned long long) ip->i_ino,
 129                          (long long) pathlen);
 130                 ASSERT(0);
 131                 error = XFS_ERROR(EFSCORRUPTED);
 132                 goto out;
 133         }
 134
 135
 136         if (ip->i_df.if_flags & XFS_IFINLINE) {
 137                 memcpy(link, ip->i_df.if_u1.if_data, pathlen);
 138                 link[pathlen] = '\0';
 139         } else {
 140                 error = xfs_readlink_bmap(ip, link);
 141         }
 142
 143  out:
 144         xfs_iunlock(ip, XFS_ILOCK_SHARED);
 145         return error;
 146 }
 147
 148 /*
 149  * Flags for xfs_free_eofblocks
 150  */
 151 #define XFS_FREE_EOF_TRYLOCK    (1<<0)
 152
 153 /*
 154  * This is called by xfs_inactive to free any blocks beyond eof
 155  * when the link count isn't zero and by xfs_dm_punch_hole() when
 156  * punching a hole to EOF.
 157  */
 158 STATIC int
 159 xfs_free_eofblocks(
 160         xfs_mount_t     *mp,
 161         xfs_inode_t     *ip,
 162         int             flags)
 163 {
 164         xfs_trans_t     *tp;
 165         int             error;
 166         xfs_fileoff_t   end_fsb;
 167         xfs_fileoff_t   last_fsb;
 168         xfs_filblks_t   map_len;
 169         int             nimaps;
 170         xfs_bmbt_irec_t imap;
 171
 172         /*
 173          * Figure out if there are any blocks beyond the end
 174          * of the file.  If not, then there is nothing to do.
 175          */
 176         end_fsb = XFS_B_TO_FSB(mp, (xfs_ufsize_t)XFS_ISIZE(ip));
 177         last_fsb = XFS_B_TO_FSB(mp, mp->m_super->s_maxbytes);
 178         if (last_fsb <= end_fsb)
 179                 return 0;
 180         map_len = last_fsb - end_fsb;
 181
 182         nimaps = 1;
 183         xfs_ilock(ip, XFS_ILOCK_SHARED);
 184         error = xfs_bmapi_read(ip, end_fsb, map_len, &imap, &nimaps, 0);
 185         xfs_iunlock(ip, XFS_ILOCK_SHARED);
 186
 187         if (!error && (nimaps != 0) &&
 188             (imap.br_startblock != HOLESTARTBLOCK ||
 189              ip->i_delayed_blks)) {
 190                 /*
 191                  * Attach the dquots to the inode up front.
 192                  */
 193                 error = xfs_qm_dqattach(ip, 0);
 194                 if (error)
 195                         return error;
 196
 197                 /*
 198                  * There are blocks after the end of file.
 199                  * Free them up now by truncating the file to
 200                  * its current size.
 201                  */
 202                 tp = xfs_trans_alloc(mp, XFS_TRANS_INACTIVE);
 203
 204                 if (flags & XFS_FREE_EOF_TRYLOCK) {
 205                         if (!xfs_ilock_nowait(ip, XFS_IOLOCK_EXCL)) {
 206                                 xfs_trans_cancel(tp, 0);
 207                                 return 0;
 208                         }
 209                 } else {
 210                         xfs_ilock(ip, XFS_IOLOCK_EXCL);
 211                 }
 212
 213                 error = xfs_trans_reserve(tp, 0,
 214                                           XFS_ITRUNCATE_LOG_RES(mp),
 215                                           0, XFS_TRANS_PERM_LOG_RES,
 216                                           XFS_ITRUNCATE_LOG_COUNT);
 217                 if (error) {
 218                         ASSERT(XFS_FORCED_SHUTDOWN(mp));
 219                         xfs_trans_cancel(tp, 0);
 220                         xfs_iunlock(ip, XFS_IOLOCK_EXCL);
 221                         return error;
 222                 }
 223
 224                 xfs_ilock(ip, XFS_ILOCK_EXCL);
 225                 xfs_trans_ijoin(tp, ip, 0);
 226
 227                 /*
 228                  * Do not update the on-disk file size.  If we update the
 229                  * on-disk file size and then the system crashes before the
 230                  * contents of the file are flushed to disk then the files
 231                  * may be full of holes (ie NULL files bug).
 232                  */
 233                 error = xfs_itruncate_extents(&tp, ip, XFS_DATA_FORK,
 234                                               XFS_ISIZE(ip));
 235                 if (error) {
 236                         /*
 237                          * If we get an error at this point we simply don't
 238                          * bother truncating the file.
 239                          */
 240                         xfs_trans_cancel(tp,
 241                                          (XFS_TRANS_RELEASE_LOG_RES |
 242                                           XFS_TRANS_ABORT));
 243                 } else {
 244                         error = xfs_trans_commit(tp,
 245                                                 XFS_TRANS_RELEASE_LOG_RES);
 246                 }
 247                 xfs_iunlock(ip, XFS_IOLOCK_EXCL|XFS_ILOCK_EXCL);
 248         }
 249         return error;
 250 }
 251
 252 /*
 253  * Free a symlink that has blocks associated with it.
 254  */
 255 STATIC int
 256 xfs_inactive_symlink_rmt(
 257         xfs_inode_t     *ip,
 258         xfs_trans_t     **tpp)
 259 {
 260         xfs_buf_t       *bp;
 261         int             committed;
 262         int             done;
 263         int             error;
 264         xfs_fsblock_t   first_block;
 265         xfs_bmap_free_t free_list;
 266         int             i;
 267         xfs_mount_t     *mp;
 268         xfs_bmbt_irec_t mval[SYMLINK_MAPS];
 269         int             nmaps;
 270         xfs_trans_t     *ntp;
 271         int             size;
 272         xfs_trans_t     *tp;
 273
 274         tp = *tpp;
 275         mp = ip->i_mount;
 276         ASSERT(ip->i_d.di_size > XFS_IFORK_DSIZE(ip));
 277         /*
 278          * We're freeing a symlink that has some
 279          * blocks allocated to it.  Free the
 280          * blocks here.  We know that we've got
 281          * either 1 or 2 extents and that we can
 282          * free them all in one bunmapi call.
 283          */
 284         ASSERT(ip->i_d.di_nextents > 0 && ip->i_d.di_nextents <= 2);
 285
 286         /*
 287          * Lock the inode, fix the size, and join it to the transaction.
 288          * Hold it so in the normal path, we still have it locked for
 289          * the second transaction.  In the error paths we need it
 290          * held so the cancel won't rele it, see below.
 291          */
 292         size = (int)ip->i_d.di_size;
 293         ip->i_d.di_size = 0;
 294         xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
 295         /*
 296          * Find the block(s) so we can inval and unmap them.
 297          */
 298         done = 0;
 299         xfs_bmap_init(&free_list, &first_block);
 300         nmaps = ARRAY_SIZE(mval);
 301         error = xfs_bmapi_read(ip, 0, XFS_B_TO_FSB(mp, size),
 302                                 mval, &nmaps, 0);
 303         if (error)
 304                 goto error0;
 305         /*
 306          * Invalidate the block(s).
 307          */
 308         for (i = 0; i < nmaps; i++) {
 309                 bp = xfs_trans_get_buf(tp, mp->m_ddev_targp,
 310                         XFS_FSB_TO_DADDR(mp, mval[i].br_startblock),
 311                         XFS_FSB_TO_BB(mp, mval[i].br_blockcount), 0);
 312                 if (!bp) {
 313                         error = ENOMEM;
 314                         goto error1;
 315                 }
 316                 xfs_trans_binval(tp, bp);
 317         }
 318         /*
 319          * Unmap the dead block(s) to the free_list.
 320          */
 321         if ((error = xfs_bunmapi(tp, ip, 0, size, XFS_BMAPI_METADATA, nmaps,
 322                         &first_block, &free_list, &done)))
 323                 goto error1;
 324         ASSERT(done);
 325         /*
 326          * Commit the first transaction.  This logs the EFI and the inode.
 327          */
 328         if ((error = xfs_bmap_finish(&tp, &free_list, &committed)))
 329                 goto error1;
 330         /*
 331          * The transaction must have been committed, since there were
 332          * actually extents freed by xfs_bunmapi.  See xfs_bmap_finish.
 333          * The new tp has the extent freeing and EFDs.
 334          */
 335         ASSERT(committed);
 336         /*
 337          * The first xact was committed, so add the inode to the new one.
 338          * Mark it dirty so it will be logged and moved forward in the log as
 339          * part of every commit.
 340          */
 341         xfs_trans_ijoin(tp, ip, 0);
 342         xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
 343         /*
 344          * Get a new, empty transaction to return to our caller.
 345          */
 346         ntp = xfs_trans_dup(tp);
 347         /*
 348          * Commit the transaction containing extent freeing and EFDs.
 349          * If we get an error on the commit here or on the reserve below,
 350          * we need to unlock the inode since the new transaction doesn't
 351          * have the inode attached.
 352          */
 353         error = xfs_trans_commit(tp, 0);
 354         tp = ntp;
 355         if (error) {
 356                 ASSERT(XFS_FORCED_SHUTDOWN(mp));
 357                 goto error0;
 358         }
 359         /*
 360          * transaction commit worked ok so we can drop the extra ticket
 361          * reference that we gained in xfs_trans_dup()
 362          */
 363         xfs_log_ticket_put(tp->t_ticket);
 364
 365         /*
 366          * Remove the memory for extent descriptions (just bookkeeping).
 367          */
 368         if (ip->i_df.if_bytes)
 369                 xfs_idata_realloc(ip, -ip->i_df.if_bytes, XFS_DATA_FORK);
 370         ASSERT(ip->i_df.if_bytes == 0);
 371         /*
 372          * Put an itruncate log reservation in the new transaction
 373          * for our caller.
 374          */
 375         if ((error = xfs_trans_reserve(tp, 0, XFS_ITRUNCATE_LOG_RES(mp), 0,
 376                         XFS_TRANS_PERM_LOG_RES, XFS_ITRUNCATE_LOG_COUNT))) {
 377                 ASSERT(XFS_FORCED_SHUTDOWN(mp));
 378                 goto error0;
 379         }
 380
 381         xfs_trans_ijoin(tp, ip, 0);
 382         *tpp = tp;
 383         return 0;
 384
 385  error1:
 386         xfs_bmap_cancel(&free_list);
 387  error0:
 388         return error;
 389 }
 390
 391 STATIC int
 392 xfs_inactive_attrs(
 393         xfs_inode_t     *ip,
 394         xfs_trans_t     **tpp)
 395 {
 396         xfs_trans_t     *tp;
 397         int             error;
 398         xfs_mount_t     *mp;
 399
 400         ASSERT(xfs_isilocked(ip, XFS_IOLOCK_EXCL));
 401         tp = *tpp;
 402         mp = ip->i_mount;
 403         ASSERT(ip->i_d.di_forkoff != 0);
 404         error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
 405         xfs_iunlock(ip, XFS_ILOCK_EXCL);
 406         if (error)
 407                 goto error_unlock;
 408
 409         error = xfs_attr_inactive(ip);
 410         if (error)
 411                 goto error_unlock;
 412
 413         tp = xfs_trans_alloc(mp, XFS_TRANS_INACTIVE);
 414         error = xfs_trans_reserve(tp, 0,
 415                                   XFS_IFREE_LOG_RES(mp),
 416                                   0, XFS_TRANS_PERM_LOG_RES,
 417                                   XFS_INACTIVE_LOG_COUNT);
 418         if (error)
 419                 goto error_cancel;
 420
 421         xfs_ilock(ip, XFS_ILOCK_EXCL);
 422         xfs_trans_ijoin(tp, ip, 0);
 423         xfs_idestroy_fork(ip, XFS_ATTR_FORK);
 424
 425         ASSERT(ip->i_d.di_anextents == 0);
 426
 427         *tpp = tp;
 428         return 0;
 429
 430 error_cancel:
 431         ASSERT(XFS_FORCED_SHUTDOWN(mp));
 432         xfs_trans_cancel(tp, 0);
 433 error_unlock:
 434         *tpp = NULL;
 435         xfs_iunlock(ip, XFS_IOLOCK_EXCL);
 436         return error;
 437 }
 438
 439 int
 440 xfs_release(
 441         xfs_inode_t     *ip)
 442 {
 443         xfs_mount_t     *mp = ip->i_mount;
 444         int             error;
 445
 446         if (!S_ISREG(ip->i_d.di_mode) || (ip->i_d.di_mode == 0))
 447                 return 0;
 448
 449         /* If this is a read-only mount, don't do this (would generate I/O) */
 450         if (mp->m_flags & XFS_MOUNT_RDONLY)
 451                 return 0;
 452
 453         if (!XFS_FORCED_SHUTDOWN(mp)) {
 454                 int truncated;
 455
 456                 /*
 457                  * If we are using filestreams, and we have an unlinked
 458                  * file that we are processing the last close on, then nothing
 459                  * will be able to reopen and write to this file. Purge this
 460                  * inode from the filestreams cache so that it doesn't delay
 461                  * teardown of the inode.
 462                  */
 463                 if ((ip->i_d.di_nlink == 0) && xfs_inode_is_filestream(ip))
 464                         xfs_filestream_deassociate(ip);
 465
 466                 /*
 467                  * If we previously truncated this file and removed old data
 468                  * in the process, we want to initiate "early" writeout on
 469                  * the last close.  This is an attempt to combat the notorious
 470                  * NULL files problem which is particularly noticeable from a
 471                  * truncate down, buffered (re-)write (delalloc), followed by
 472                  * a crash.  What we are effectively doing here is
 473                  * significantly reducing the time window where we'd otherwise
 474                  * be exposed to that problem.
 475                  */
 476                 truncated = xfs_iflags_test_and_clear(ip, XFS_ITRUNCATED);
 477                 if (truncated) {
 478                         xfs_iflags_clear(ip, XFS_IDIRTY_RELEASE);
 479                         if (VN_DIRTY(VFS_I(ip)) && ip->i_delayed_blks > 0)
 480                                 xfs_flush_pages(ip, 0, -1, XBF_ASYNC, FI_NONE);
 481                 }
 482         }
 483
 484         if (ip->i_d.di_nlink == 0)
 485                 return 0;
 486
 487         if ((S_ISREG(ip->i_d.di_mode) &&
 488              (VFS_I(ip)->i_size > 0 ||
 489               (VN_CACHED(VFS_I(ip)) > 0 || ip->i_delayed_blks > 0)) &&
 490              (ip->i_df.if_flags & XFS_IFEXTENTS))  &&
 491             (!(ip->i_d.di_flags & (XFS_DIFLAG_PREALLOC | XFS_DIFLAG_APPEND)))) {
 492
 493                 /*
 494                  * If we can't get the iolock just skip truncating the blocks
 495                  * past EOF because we could deadlock with the mmap_sem
 496                  * otherwise.  We'll get another chance to drop them once the
 497                  * last reference to the inode is dropped, so we'll never leak
 498                  * blocks permanently.
 499                  *
 500                  * Further, check if the inode is being opened, written and
 501                  * closed frequently and we have delayed allocation blocks
 502                  * outstanding (e.g. streaming writes from the NFS server),
 503                  * truncating the blocks past EOF will cause fragmentation to
 504                  * occur.
 505                  *
 506                  * In this case don't do the truncation, either, but we have to
 507                  * be careful how we detect this case. Blocks beyond EOF show
 508                  * up as i_delayed_blks even when the inode is clean, so we
 509                  * need to truncate them away first before checking for a dirty
 510                  * release. Hence on the first dirty close we will still remove
 511                  * the speculative allocation, but after that we will leave it
 512                  * in place.
 513                  */
 514                 if (xfs_iflags_test(ip, XFS_IDIRTY_RELEASE))
 515                         return 0;
 516
 517                 error = xfs_free_eofblocks(mp, ip,
 518                                            XFS_FREE_EOF_TRYLOCK);
 519                 if (error)
 520                         return error;
 521
 522                 /* delalloc blocks after truncation means it really is dirty */
 523                 if (ip->i_delayed_blks)
 524                         xfs_iflags_set(ip, XFS_IDIRTY_RELEASE);
 525         }
 526         return 0;
 527 }
 528
 529 /*
 530  * xfs_inactive
 531  *
 532  * This is called when the vnode reference count for the vnode
 533  * goes to zero.  If the file has been unlinked, then it must
 534  * now be truncated.  Also, we clear all of the read-ahead state
 535  * kept for the inode here since the file is now closed.
 536  */
 537 int
 538 xfs_inactive(
 539         xfs_inode_t     *ip)
 540 {
 541         xfs_bmap_free_t free_list;
 542         xfs_fsblock_t   first_block;
 543         int             committed;
 544         xfs_trans_t     *tp;
 545         xfs_mount_t     *mp;
 546         int             error;
 547         int             truncate = 0;
 548
 549         /*
 550          * If the inode is already free, then there can be nothing
 551          * to clean up here.
 552          */
 553         if (ip->i_d.di_mode == 0 || is_bad_inode(VFS_I(ip))) {
 554                 ASSERT(ip->i_df.if_real_bytes == 0);
 555                 ASSERT(ip->i_df.if_broot_bytes == 0);
 556                 return VN_INACTIVE_CACHE;
 557         }
 558
 559         mp = ip->i_mount;
 560
 561         error = 0;
 562
 563         /* If this is a read-only mount, don't do this (would generate I/O) */
 564         if (mp->m_flags & XFS_MOUNT_RDONLY)
 565                 goto out;
 566
 567         if (ip->i_d.di_nlink != 0) {
 568                 if ((S_ISREG(ip->i_d.di_mode) &&
 569                     (VFS_I(ip)->i_size > 0 ||
 570                      (VN_CACHED(VFS_I(ip)) > 0 || ip->i_delayed_blks > 0)) &&
 571                     (ip->i_df.if_flags & XFS_IFEXTENTS) &&
 572                     (!(ip->i_d.di_flags &
 573                                 (XFS_DIFLAG_PREALLOC | XFS_DIFLAG_APPEND)) ||
 574                      ip->i_delayed_blks != 0))) {
 575                         error = xfs_free_eofblocks(mp, ip, 0);
 576                         if (error)
 577                                 return VN_INACTIVE_CACHE;
 578                 }
 579                 goto out;
 580         }
 581
 582         if (S_ISREG(ip->i_d.di_mode) &&
 583             (ip->i_d.di_size != 0 || XFS_ISIZE(ip) != 0 ||
 584              ip->i_d.di_nextents > 0 || ip->i_delayed_blks > 0))
 585                 truncate = 1;
 586
 587         error = xfs_qm_dqattach(ip, 0);
 588         if (error)
 589                 return VN_INACTIVE_CACHE;
 590
 591         tp = xfs_trans_alloc(mp, XFS_TRANS_INACTIVE);
 592         error = xfs_trans_reserve(tp, 0,
 593                         (truncate || S_ISLNK(ip->i_d.di_mode)) ?
 594                                 XFS_ITRUNCATE_LOG_RES(mp) :
 595                                 XFS_IFREE_LOG_RES(mp),
 596                         0,
 597                         XFS_TRANS_PERM_LOG_RES,
 598                         XFS_ITRUNCATE_LOG_COUNT);
 599         if (error) {
 600                 ASSERT(XFS_FORCED_SHUTDOWN(mp));
 601                 xfs_trans_cancel(tp, 0);
 602                 return VN_INACTIVE_CACHE;
 603         }
 604
 605         xfs_ilock(ip, XFS_IOLOCK_EXCL | XFS_ILOCK_EXCL);
 606         xfs_trans_ijoin(tp, ip, 0);
 607
 608         if (S_ISLNK(ip->i_d.di_mode)) {
 609                 /*
 610                  * Zero length symlinks _can_ exist.
 611                  */
 612                 if (ip->i_d.di_size > XFS_IFORK_DSIZE(ip)) {
 613                         error = xfs_inactive_symlink_rmt(ip, &tp);
 614                         if (error)
 615                                 goto out_cancel;
 616                 } else if (ip->i_df.if_bytes > 0) {
 617                         xfs_idata_realloc(ip, -(ip->i_df.if_bytes),
 618                                           XFS_DATA_FORK);
 619                         ASSERT(ip->i_df.if_bytes == 0);
 620                 }
 621         } else if (truncate) {
 622                 ip->i_d.di_size = 0;
 623                 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
 624
 625                 error = xfs_itruncate_extents(&tp, ip, XFS_DATA_FORK, 0);
 626                 if (error)
 627                         goto out_cancel;
 628
 629                 ASSERT(ip->i_d.di_nextents == 0);
 630         }
 631
 632         /*
 633          * If there are attributes associated with the file
 634          * then blow them away now.  The code calls a routine
 635          * that recursively deconstructs the attribute fork.
 636          * We need to just commit the current transaction
 637          * because we can't use it for xfs_attr_inactive().
 638          */
 639         if (ip->i_d.di_anextents > 0) {
 640                 error = xfs_inactive_attrs(ip, &tp);
 641                 /*
 642                  * If we got an error, the transaction is already
 643                  * cancelled, and the inode is unlocked. Just get out.
 644                  */
 645                  if (error)
 646                          return VN_INACTIVE_CACHE;
 647         } else if (ip->i_afp) {
 648                 xfs_idestroy_fork(ip, XFS_ATTR_FORK);
 649         }
 650
 651         /*
 652          * Free the inode.
 653          */
 654         xfs_bmap_init(&free_list, &first_block);
 655         error = xfs_ifree(tp, ip, &free_list);
 656         if (error) {
 657                 /*
 658                  * If we fail to free the inode, shut down.  The cancel
 659                  * might do that, we need to make sure.  Otherwise the
 660                  * inode might be lost for a long time or forever.
 661                  */
 662                 if (!XFS_FORCED_SHUTDOWN(mp)) {
 663                         xfs_notice(mp, "%s: xfs_ifree returned error %d",
 664                                 __func__, error);
 665                         xfs_force_shutdown(mp, SHUTDOWN_META_IO_ERROR);
 666                 }
 667                 xfs_trans_cancel(tp, XFS_TRANS_RELEASE_LOG_RES|XFS_TRANS_ABORT);
 668         } else {
 669                 /*
 670                  * Credit the quota account(s). The inode is gone.
 671                  */
 672                 xfs_trans_mod_dquot_byino(tp, ip, XFS_TRANS_DQ_ICOUNT, -1);
 673
 674                 /*
 675                  * Just ignore errors at this point.  There is nothing we can
 676                  * do except to try to keep going. Make sure it's not a silent
 677                  * error.
 678                  */
 679                 error = xfs_bmap_finish(&tp,  &free_list, &committed);
 680                 if (error)
 681                         xfs_notice(mp, "%s: xfs_bmap_finish returned error %d",
 682                                 __func__, error);
 683                 error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
 684                 if (error)
 685                         xfs_notice(mp, "%s: xfs_trans_commit returned error %d",
 686                                 __func__, error);
 687         }
 688
 689         /*
 690          * Release the dquots held by inode, if any.
 691          */
 692         xfs_qm_dqdetach(ip);
 693         xfs_iunlock(ip, XFS_IOLOCK_EXCL | XFS_ILOCK_EXCL);
 694
 695 out:
 696         return VN_INACTIVE_CACHE;
 697 out_cancel:
 698         xfs_trans_cancel(tp, XFS_TRANS_RELEASE_LOG_RES | XFS_TRANS_ABORT);
 699         xfs_iunlock(ip, XFS_IOLOCK_EXCL | XFS_ILOCK_EXCL);
 700         return VN_INACTIVE_CACHE;
 701 }
 702
 703 /*
 704  * Lookups up an inode from "name". If ci_name is not NULL, then a CI match
 705  * is allowed, otherwise it has to be an exact match. If a CI match is found,
 706  * ci_name->name will point to a the actual name (caller must free) or
 707  * will be set to NULL if an exact match is found.
 708  */
 709 int
 710 xfs_lookup(
 711         xfs_inode_t             *dp,
 712         struct xfs_name         *name,
 713         xfs_inode_t             **ipp,
 714         struct xfs_name         *ci_name)
 715 {
 716         xfs_ino_t               inum;
 717         int                     error;
 718         uint                    lock_mode;
 719
 720         trace_xfs_lookup(dp, name);
 721
 722         if (XFS_FORCED_SHUTDOWN(dp->i_mount))
 723                 return XFS_ERROR(EIO);
 724
 725         lock_mode = xfs_ilock_map_shared(dp);
 726         error = xfs_dir_lookup(NULL, dp, name, &inum, ci_name);
 727         xfs_iunlock_map_shared(dp, lock_mode);
 728
 729         if (error)
 730                 goto out;
 731
 732         error = xfs_iget(dp->i_mount, NULL, inum, 0, 0, ipp);
 733         if (error)
 734                 goto out_free_name;
 735
 736         return 0;
 737
 738 out_free_name:
 739         if (ci_name)
 740                 kmem_free(ci_name->name);
 741 out:
 742         *ipp = NULL;
 743         return error;
 744 }
 745
 746 int
 747 xfs_create(
 748         xfs_inode_t             *dp,
 749         struct xfs_name         *name,
 750         umode_t                 mode,
 751         xfs_dev_t               rdev,
 752         xfs_inode_t             **ipp)
 753 {
 754         int                     is_dir = S_ISDIR(mode);
 755         struct xfs_mount        *mp = dp->i_mount;
 756         struct xfs_inode        *ip = NULL;
 757         struct xfs_trans        *tp = NULL;
 758         int                     error;
 759         xfs_bmap_free_t         free_list;
 760         xfs_fsblock_t           first_block;
 761         boolean_t               unlock_dp_on_error = B_FALSE;
 762         uint                    cancel_flags;
 763         int                     committed;
 764         prid_t                  prid;
 765         struct xfs_dquot        *udqp = NULL;
 766         struct xfs_dquot        *gdqp = NULL;
 767         uint                    resblks;
 768         uint                    log_res;
 769         uint                    log_count;
 770
 771         trace_xfs_create(dp, name);
 772
 773         if (XFS_FORCED_SHUTDOWN(mp))
 774                 return XFS_ERROR(EIO);
 775
 776         if (dp->i_d.di_flags & XFS_DIFLAG_PROJINHERIT)
 777                 prid = xfs_get_projid(dp);
 778         else
 779                 prid = XFS_PROJID_DEFAULT;
 780
 781         /*
 782          * Make sure that we have allocated dquot(s) on disk.
 783          */
 784         error = xfs_qm_vop_dqalloc(dp, current_fsuid(), current_fsgid(), prid,
 785                         XFS_QMOPT_QUOTALL | XFS_QMOPT_INHERIT, &udqp, &gdqp);
 786         if (error)
 787                 return error;
 788
 789         if (is_dir) {
 790                 rdev = 0;
 791                 resblks = XFS_MKDIR_SPACE_RES(mp, name->len);
 792                 log_res = XFS_MKDIR_LOG_RES(mp);
 793                 log_count = XFS_MKDIR_LOG_COUNT;
 794                 tp = xfs_trans_alloc(mp, XFS_TRANS_MKDIR);
 795         } else {
 796                 resblks = XFS_CREATE_SPACE_RES(mp, name->len);
 797                 log_res = XFS_CREATE_LOG_RES(mp);
 798                 log_count = XFS_CREATE_LOG_COUNT;
 799                 tp = xfs_trans_alloc(mp, XFS_TRANS_CREATE);
 800         }
 801
 802         cancel_flags = XFS_TRANS_RELEASE_LOG_RES;
 803
 804         /*
 805          * Initially assume that the file does not exist and
 806          * reserve the resources for that case.  If that is not
 807          * the case we'll drop the one we have and get a more
 808          * appropriate transaction later.
 809          */
 810         error = xfs_trans_reserve(tp, resblks, log_res, 0,
 811                         XFS_TRANS_PERM_LOG_RES, log_count);
 812         if (error == ENOSPC) {
 813                 /* flush outstanding delalloc blocks and retry */
 814                 xfs_flush_inodes(dp);
 815                 error = xfs_trans_reserve(tp, resblks, log_res, 0,
 816                                 XFS_TRANS_PERM_LOG_RES, log_count);
 817         }
 818         if (error == ENOSPC) {
 819                 /* No space at all so try a "no-allocation" reservation */
 820                 resblks = 0;
 821                 error = xfs_trans_reserve(tp, 0, log_res, 0,
 822                                 XFS_TRANS_PERM_LOG_RES, log_count);
 823         }
 824         if (error) {
 825                 cancel_flags = 0;
 826                 goto out_trans_cancel;
 827         }
 828
 829         xfs_ilock(dp, XFS_ILOCK_EXCL | XFS_ILOCK_PARENT);
 830         unlock_dp_on_error = B_TRUE;
 831
 832         xfs_bmap_init(&free_list, &first_block);
 833
 834         /*
 835          * Reserve disk quota and the inode.
 836          */
 837         error = xfs_trans_reserve_quota(tp, mp, udqp, gdqp, resblks, 1, 0);
 838         if (error)
 839                 goto out_trans_cancel;
 840
 841         error = xfs_dir_canenter(tp, dp, name, resblks);
 842         if (error)
 843                 goto out_trans_cancel;
 844
 845         /*
 846          * A newly created regular or special file just has one directory
 847          * entry pointing to them, but a directory also the "." entry
 848          * pointing to itself.
 849          */
 850         error = xfs_dir_ialloc(&tp, dp, mode, is_dir ? 2 : 1, rdev,
 851                                prid, resblks > 0, &ip, &committed);
 852         if (error) {
 853                 if (error == ENOSPC)
 854                         goto out_trans_cancel;
 855                 goto out_trans_abort;
 856         }
 857
 858         /*
 859          * Now we join the directory inode to the transaction.  We do not do it
 860          * earlier because xfs_dir_ialloc might commit the previous transaction
 861          * (and release all the locks).  An error from here on will result in
 862          * the transaction cancel unlocking dp so don't do it explicitly in the
 863          * error path.
 864          */
 865         xfs_trans_ijoin(tp, dp, XFS_ILOCK_EXCL);
 866         unlock_dp_on_error = B_FALSE;
 867
 868         error = xfs_dir_createname(tp, dp, name, ip->i_ino,
 869                                         &first_block, &free_list, resblks ?
 870                                         resblks - XFS_IALLOC_SPACE_RES(mp) : 0);
 871         if (error) {
 872                 ASSERT(error != ENOSPC);
 873                 goto out_trans_abort;
 874         }
 875         xfs_trans_ichgtime(tp, dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
 876         xfs_trans_log_inode(tp, dp, XFS_ILOG_CORE);
 877
 878         if (is_dir) {
 879                 error = xfs_dir_init(tp, ip, dp);
 880                 if (error)
 881                         goto out_bmap_cancel;
 882
 883                 error = xfs_bumplink(tp, dp);
 884                 if (error)
 885                         goto out_bmap_cancel;
 886         }
 887
 888         /*
 889          * If this is a synchronous mount, make sure that the
 890          * create transaction goes to disk before returning to
 891          * the user.
 892          */
 893         if (mp->m_flags & (XFS_MOUNT_WSYNC|XFS_MOUNT_DIRSYNC))
 894                 xfs_trans_set_sync(tp);
 895
 896         /*
 897          * Attach the dquot(s) to the inodes and modify them incore.
 898          * These ids of the inode couldn't have changed since the new
 899          * inode has been locked ever since it was created.
 900          */
 901         xfs_qm_vop_create_dqattach(tp, ip, udqp, gdqp);
 902
 903         error = xfs_bmap_finish(&tp, &free_list, &committed);
 904         if (error)
 905                 goto out_bmap_cancel;
 906
 907         error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
 908         if (error)
 909                 goto out_release_inode;
 910
 911         xfs_qm_dqrele(udqp);
 912         xfs_qm_dqrele(gdqp);
 913
 914         *ipp = ip;
 915         return 0;
 916
 917  out_bmap_cancel:
 918         xfs_bmap_cancel(&free_list);
 919  out_trans_abort:
 920         cancel_flags |= XFS_TRANS_ABORT;
 921  out_trans_cancel:
 922         xfs_trans_cancel(tp, cancel_flags);
 923  out_release_inode:
 924         /*
 925          * Wait until after the current transaction is aborted to
 926          * release the inode.  This prevents recursive transactions
 927          * and deadlocks from xfs_inactive.
 928          */
 929         if (ip)
 930                 IRELE(ip);
 931
 932         xfs_qm_dqrele(udqp);
 933         xfs_qm_dqrele(gdqp);
 934
 935         if (unlock_dp_on_error)
 936                 xfs_iunlock(dp, XFS_ILOCK_EXCL);
 937         return error;
 938 }
 939
 940 #ifdef DEBUG
 941 int xfs_locked_n;
 942 int xfs_small_retries;
 943 int xfs_middle_retries;
 944 int xfs_lots_retries;
 945 int xfs_lock_delays;
 946 #endif
 947
 948 /*
 949  * Bump the subclass so xfs_lock_inodes() acquires each lock with
 950  * a different value
 951  */
 952 static inline int
 953 xfs_lock_inumorder(int lock_mode, int subclass)
 954 {
 955         if (lock_mode & (XFS_IOLOCK_SHARED|XFS_IOLOCK_EXCL))
 956                 lock_mode |= (subclass + XFS_LOCK_INUMORDER) << XFS_IOLOCK_SHIFT;
 957         if (lock_mode & (XFS_ILOCK_SHARED|XFS_ILOCK_EXCL))
 958                 lock_mode |= (subclass + XFS_LOCK_INUMORDER) << XFS_ILOCK_SHIFT;
 959
 960         return lock_mode;
 961 }
 962
 963 /*
 964  * The following routine will lock n inodes in exclusive mode.
 965  * We assume the caller calls us with the inodes in i_ino order.
 966  *
 967  * We need to detect deadlock where an inode that we lock
 968  * is in the AIL and we start waiting for another inode that is locked
 969  * by a thread in a long running transaction (such as truncate). This can
 970  * result in deadlock since the long running trans might need to wait
 971  * for the inode we just locked in order to push the tail and free space
 972  * in the log.
 973  */
 974 void
 975 xfs_lock_inodes(
 976         xfs_inode_t     **ips,
 977         int             inodes,
 978         uint            lock_mode)
 979 {
 980         int             attempts = 0, i, j, try_lock;
 981         xfs_log_item_t  *lp;
 982
 983         ASSERT(ips && (inodes >= 2)); /* we need at least two */
 984
 985         try_lock = 0;
 986         i = 0;
 987
 988 again:
 989         for (; i < inodes; i++) {
 990                 ASSERT(ips[i]);
 991
 992                 if (i && (ips[i] == ips[i-1]))  /* Already locked */
 993                         continue;
 994
 995                 /*
 996                  * If try_lock is not set yet, make sure all locked inodes
 997                  * are not in the AIL.
 998                  * If any are, set try_lock to be used later.
 999                  */
1000
1001                 if (!try_lock) {
1002                         for (j = (i - 1); j >= 0 && !try_lock; j--) {
1003                                 lp = (xfs_log_item_t *)ips[j]->i_itemp;
1004                                 if (lp && (lp->li_flags & XFS_LI_IN_AIL)) {
1005                                         try_lock++;
1006                                 }
1007                         }
1008                 }
1009
1010                 /*
1011                  * If any of the previous locks we have locked is in the AIL,
1012                  * we must TRY to get the second and subsequent locks. If
1013                  * we can't get any, we must release all we have
1014                  * and try again.
1015                  */
1016
1017                 if (try_lock) {
1018                         /* try_lock must be 0 if i is 0. */
1019                         /*
1020                          * try_lock means we have an inode locked
1021                          * that is in the AIL.
1022                          */
1023                         ASSERT(i != 0);
1024                         if (!xfs_ilock_nowait(ips[i], xfs_lock_inumorder(lock_mode, i))) {
1025                                 attempts++;
1026
1027                                 /*
1028                                  * Unlock all previous guys and try again.
1029                                  * xfs_iunlock will try to push the tail
1030                                  * if the inode is in the AIL.
1031                                  */
1032
1033                                 for(j = i - 1; j >= 0; j--) {
1034
1035                                         /*
1036                                          * Check to see if we've already
1037                                          * unlocked this one.
1038                                          * Not the first one going back,
1039                                          * and the inode ptr is the same.
1040                                          */
1041                                         if ((j != (i - 1)) && ips[j] ==
1042                                                                 ips[j+1])
1043                                                 continue;
1044
1045                                         xfs_iunlock(ips[j], lock_mode);
1046                                 }
1047
1048                                 if ((attempts % 5) == 0) {
1049                                         delay(1); /* Don't just spin the CPU */
1050 #ifdef DEBUG
1051                                         xfs_lock_delays++;
1052 #endif
1053                                 }
1054                                 i = 0;
1055                                 try_lock = 0;
1056                                 goto again;
1057                         }
1058                 } else {
1059                         xfs_ilock(ips[i], xfs_lock_inumorder(lock_mode, i));
1060                 }
1061         }
1062
1063 #ifdef DEBUG
1064         if (attempts) {
1065                 if (attempts < 5) xfs_small_retries++;
1066                 else if (attempts < 100) xfs_middle_retries++;
1067                 else xfs_lots_retries++;
1068         } else {
1069                 xfs_locked_n++;
1070         }
1071 #endif
1072 }
1073
1074 /*
1075  * xfs_lock_two_inodes() can only be used to lock one type of lock
1076  * at a time - the iolock or the ilock, but not both at once. If
1077  * we lock both at once, lockdep will report false positives saying
1078  * we have violated locking orders.
1079  */
1080 void
1081 xfs_lock_two_inodes(
1082         xfs_inode_t             *ip0,
1083         xfs_inode_t             *ip1,
1084         uint                    lock_mode)
1085 {
1086         xfs_inode_t             *temp;
1087         int                     attempts = 0;
1088         xfs_log_item_t          *lp;
1089
1090         if (lock_mode & (XFS_IOLOCK_SHARED|XFS_IOLOCK_EXCL))
1091                 ASSERT((lock_mode & (XFS_ILOCK_SHARED|XFS_ILOCK_EXCL)) == 0);
1092         ASSERT(ip0->i_ino != ip1->i_ino);
1093
1094         if (ip0->i_ino > ip1->i_ino) {
1095                 temp = ip0;
1096                 ip0 = ip1;
1097                 ip1 = temp;
1098         }
1099
1100  again:
1101         xfs_ilock(ip0, xfs_lock_inumorder(lock_mode, 0));
1102
1103         /*
1104          * If the first lock we have locked is in the AIL, we must TRY to get
1105          * the second lock. If we can't get it, we must release the first one
1106          * and try again.
1107          */
1108         lp = (xfs_log_item_t *)ip0->i_itemp;
1109         if (lp && (lp->li_flags & XFS_LI_IN_AIL)) {
1110                 if (!xfs_ilock_nowait(ip1, xfs_lock_inumorder(lock_mode, 1))) {
1111                         xfs_iunlock(ip0, lock_mode);
1112                         if ((++attempts % 5) == 0)
1113                                 delay(1); /* Don't just spin the CPU */
1114                         goto again;
1115                 }
1116         } else {
1117                 xfs_ilock(ip1, xfs_lock_inumorder(lock_mode, 1));
1118         }
1119 }
1120
1121 int
1122 xfs_remove(
1123         xfs_inode_t             *dp,
1124         struct xfs_name         *name,
1125         xfs_inode_t             *ip)
1126 {
1127         xfs_mount_t             *mp = dp->i_mount;
1128         xfs_trans_t             *tp = NULL;
1129         int                     is_dir = S_ISDIR(ip->i_d.di_mode);
1130         int                     error = 0;
1131         xfs_bmap_free_t         free_list;
1132         xfs_fsblock_t           first_block;
1133         int                     cancel_flags;
1134         int                     committed;
1135         int                     link_zero;
1136         uint                    resblks;
1137         uint                    log_count;
1138
1139         trace_xfs_remove(dp, name);
1140
1141         if (XFS_FORCED_SHUTDOWN(mp))
1142                 return XFS_ERROR(EIO);
1143
1144         error = xfs_qm_dqattach(dp, 0);
1145         if (error)
1146                 goto std_return;
1147
1148         error = xfs_qm_dqattach(ip, 0);
1149         if (error)
1150                 goto std_return;
1151
1152         if (is_dir) {
1153                 tp = xfs_trans_alloc(mp, XFS_TRANS_RMDIR);
1154                 log_count = XFS_DEFAULT_LOG_COUNT;
1155         } else {
1156                 tp = xfs_trans_alloc(mp, XFS_TRANS_REMOVE);
1157                 log_count = XFS_REMOVE_LOG_COUNT;
1158         }
1159         cancel_flags = XFS_TRANS_RELEASE_LOG_RES;
1160
1161         /*
1162          * We try to get the real space reservation first,
1163          * allowing for directory btree deletion(s) implying
1164          * possible bmap insert(s).  If we can't get the space
1165          * reservation then we use 0 instead, and avoid the bmap
1166          * btree insert(s) in the directory code by, if the bmap
1167          * insert tries to happen, instead trimming the LAST
1168          * block from the directory.
1169          */
1170         resblks = XFS_REMOVE_SPACE_RES(mp);
1171         error = xfs_trans_reserve(tp, resblks, XFS_REMOVE_LOG_RES(mp), 0,
1172                                   XFS_TRANS_PERM_LOG_RES, log_count);
1173         if (error == ENOSPC) {
1174                 resblks = 0;
1175                 error = xfs_trans_reserve(tp, 0, XFS_REMOVE_LOG_RES(mp), 0,
1176                                           XFS_TRANS_PERM_LOG_RES, log_count);
1177         }
1178         if (error) {
1179                 ASSERT(error != ENOSPC);
1180                 cancel_flags = 0;
1181                 goto out_trans_cancel;
1182         }
1183
1184         xfs_lock_two_inodes(dp, ip, XFS_ILOCK_EXCL);
1185
1186         xfs_trans_ijoin(tp, dp, XFS_ILOCK_EXCL);
1187         xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
1188
1189         /*
1190          * If we're removing a directory perform some additional validation.
1191          */
1192         if (is_dir) {
1193                 ASSERT(ip->i_d.di_nlink >= 2);
1194                 if (ip->i_d.di_nlink != 2) {
1195                         error = XFS_ERROR(ENOTEMPTY);
1196                         goto out_trans_cancel;
1197                 }
1198                 if (!xfs_dir_isempty(ip)) {
1199                         error = XFS_ERROR(ENOTEMPTY);
1200                         goto out_trans_cancel;
1201                 }
1202         }
1203
1204         xfs_bmap_init(&free_list, &first_block);
1205         error = xfs_dir_removename(tp, dp, name, ip->i_ino,
1206                                         &first_block, &free_list, resblks);
1207         if (error) {
1208                 ASSERT(error != ENOENT);
1209                 goto out_bmap_cancel;
1210         }
1211         xfs_trans_ichgtime(tp, dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
1212
1213         if (is_dir) {
1214                 /*
1215                  * Drop the link from ip's "..".
1216                  */
1217                 error = xfs_droplink(tp, dp);
1218                 if (error)
1219                         goto out_bmap_cancel;
1220
1221                 /*
1222                  * Drop the "." link from ip to self.
1223                  */
1224                 error = xfs_droplink(tp, ip);
1225                 if (error)
1226                         goto out_bmap_cancel;
1227         } else {
1228                 /*
1229                  * When removing a non-directory we need to log the parent
1230                  * inode here.  For a directory this is done implicitly
1231                  * by the xfs_droplink call for the ".." entry.
1232                  */
1233                 xfs_trans_log_inode(tp, dp, XFS_ILOG_CORE);
1234         }
1235
1236         /*
1237          * Drop the link from dp to ip.
1238          */
1239         error = xfs_droplink(tp, ip);
1240         if (error)
1241                 goto out_bmap_cancel;
1242
1243         /*
1244          * Determine if this is the last link while
1245          * we are in the transaction.
1246          */
1247         link_zero = (ip->i_d.di_nlink == 0);
1248
1249         /*
1250          * If this is a synchronous mount, make sure that the
1251          * remove transaction goes to disk before returning to
1252          * the user.
1253          */
1254         if (mp->m_flags & (XFS_MOUNT_WSYNC|XFS_MOUNT_DIRSYNC))
1255                 xfs_trans_set_sync(tp);
1256
1257         error = xfs_bmap_finish(&tp, &free_list, &committed);
1258         if (error)
1259                 goto out_bmap_cancel;
1260
1261         error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
1262         if (error)
1263                 goto std_return;
1264
1265         /*
1266          * If we are using filestreams, kill the stream association.
1267          * If the file is still open it may get a new one but that
1268          * will get killed on last close in xfs_close() so we don't
1269          * have to worry about that.
1270          */
1271         if (!is_dir && link_zero && xfs_inode_is_filestream(ip))
1272                 xfs_filestream_deassociate(ip);
1273
1274         return 0;
1275
1276  out_bmap_cancel:
1277         xfs_bmap_cancel(&free_list);
1278         cancel_flags |= XFS_TRANS_ABORT;
1279  out_trans_cancel:
1280         xfs_trans_cancel(tp, cancel_flags);
1281  std_return:
1282         return error;
1283 }
1284
1285 int
1286 xfs_link(
1287         xfs_inode_t             *tdp,
1288         xfs_inode_t             *sip,
1289         struct xfs_name         *target_name)
1290 {
1291         xfs_mount_t             *mp = tdp->i_mount;
1292         xfs_trans_t             *tp;
1293         int                     error;
1294         xfs_bmap_free_t         free_list;
1295         xfs_fsblock_t           first_block;
1296         int                     cancel_flags;
1297         int                     committed;
1298         int                     resblks;
1299
1300         trace_xfs_link(tdp, target_name);
1301
1302         ASSERT(!S_ISDIR(sip->i_d.di_mode));
1303
1304         if (XFS_FORCED_SHUTDOWN(mp))
1305                 return XFS_ERROR(EIO);
1306
1307         error = xfs_qm_dqattach(sip, 0);
1308         if (error)
1309                 goto std_return;
1310
1311         error = xfs_qm_dqattach(tdp, 0);
1312         if (error)
1313                 goto std_return;
1314
1315         tp = xfs_trans_alloc(mp, XFS_TRANS_LINK);
1316         cancel_flags = XFS_TRANS_RELEASE_LOG_RES;
1317         resblks = XFS_LINK_SPACE_RES(mp, target_name->len);
1318         error = xfs_trans_reserve(tp, resblks, XFS_LINK_LOG_RES(mp), 0,
1319                         XFS_TRANS_PERM_LOG_RES, XFS_LINK_LOG_COUNT);
1320         if (error == ENOSPC) {
1321                 resblks = 0;
1322                 error = xfs_trans_reserve(tp, 0, XFS_LINK_LOG_RES(mp), 0,
1323                                 XFS_TRANS_PERM_LOG_RES, XFS_LINK_LOG_COUNT);
1324         }
1325         if (error) {
1326                 cancel_flags = 0;
1327                 goto error_return;
1328         }
1329
1330         xfs_lock_two_inodes(sip, tdp, XFS_ILOCK_EXCL);
1331
1332         xfs_trans_ijoin(tp, sip, XFS_ILOCK_EXCL);
1333         xfs_trans_ijoin(tp, tdp, XFS_ILOCK_EXCL);
1334
1335         /*
1336          * If we are using project inheritance, we only allow hard link
1337          * creation in our tree when the project IDs are the same; else
1338          * the tree quota mechanism could be circumvented.
1339          */
1340         if (unlikely((tdp->i_d.di_flags & XFS_DIFLAG_PROJINHERIT) &&
1341                      (xfs_get_projid(tdp) != xfs_get_projid(sip)))) {
1342                 error = XFS_ERROR(EXDEV);
1343                 goto error_return;
1344         }
1345
1346         error = xfs_dir_canenter(tp, tdp, target_name, resblks);
1347         if (error)
1348                 goto error_return;
1349
1350         xfs_bmap_init(&free_list, &first_block);
1351
1352         error = xfs_dir_createname(tp, tdp, target_name, sip->i_ino,
1353                                         &first_block, &free_list, resblks);
1354         if (error)
1355                 goto abort_return;
1356         xfs_trans_ichgtime(tp, tdp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
1357         xfs_trans_log_inode(tp, tdp, XFS_ILOG_CORE);
1358
1359         error = xfs_bumplink(tp, sip);
1360         if (error)
1361                 goto abort_return;
1362
1363         /*
1364          * If this is a synchronous mount, make sure that the
1365          * link transaction goes to disk before returning to
1366          * the user.
1367          */
1368         if (mp->m_flags & (XFS_MOUNT_WSYNC|XFS_MOUNT_DIRSYNC)) {
1369                 xfs_trans_set_sync(tp);
1370         }
1371
1372         error = xfs_bmap_finish (&tp, &free_list, &committed);
1373         if (error) {
1374                 xfs_bmap_cancel(&free_list);
1375                 goto abort_return;
1376         }
1377
1378         return xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
1379
1380  abort_return:
1381         cancel_flags |= XFS_TRANS_ABORT;
1382  error_return:
1383         xfs_trans_cancel(tp, cancel_flags);
1384  std_return:
1385         return error;
1386 }
1387
1388 int
1389 xfs_symlink(
1390         xfs_inode_t             *dp,
1391         struct xfs_name         *link_name,
1392         const char              *target_path,
1393         umode_t                 mode,
1394         xfs_inode_t             **ipp)
1395 {
1396         xfs_mount_t             *mp = dp->i_mount;
1397         xfs_trans_t             *tp;
1398         xfs_inode_t             *ip;
1399         int                     error;
1400         int                     pathlen;
1401         xfs_bmap_free_t         free_list;
1402         xfs_fsblock_t           first_block;
1403         boolean_t               unlock_dp_on_error = B_FALSE;
1404         uint                    cancel_flags;
1405         int                     committed;
1406         xfs_fileoff_t           first_fsb;
1407         xfs_filblks_t           fs_blocks;
1408         int                     nmaps;
1409         xfs_bmbt_irec_t         mval[SYMLINK_MAPS];
1410         xfs_daddr_t             d;
1411         const char              *cur_chunk;
1412         int                     byte_cnt;
1413         int                     n;
1414         xfs_buf_t               *bp;
1415         prid_t                  prid;
1416         struct xfs_dquot        *udqp, *gdqp;
1417         uint                    resblks;
1418
1419         *ipp = NULL;
1420         error = 0;
1421         ip = NULL;
1422         tp = NULL;
1423
1424         trace_xfs_symlink(dp, link_name);
1425
1426         if (XFS_FORCED_SHUTDOWN(mp))
1427                 return XFS_ERROR(EIO);
1428
1429         /*
1430          * Check component lengths of the target path name.
1431          */
1432         pathlen = strlen(target_path);
1433         if (pathlen >= MAXPATHLEN)      /* total string too long */
1434                 return XFS_ERROR(ENAMETOOLONG);
1435
1436         udqp = gdqp = NULL;
1437         if (dp->i_d.di_flags & XFS_DIFLAG_PROJINHERIT)
1438                 prid = xfs_get_projid(dp);
1439         else
1440                 prid = XFS_PROJID_DEFAULT;
1441
1442         /*
1443          * Make sure that we have allocated dquot(s) on disk.
1444          */
1445         error = xfs_qm_vop_dqalloc(dp, current_fsuid(), current_fsgid(), prid,
1446                         XFS_QMOPT_QUOTALL | XFS_QMOPT_INHERIT, &udqp, &gdqp);
1447         if (error)
1448                 goto std_return;
1449
1450         tp = xfs_trans_alloc(mp, XFS_TRANS_SYMLINK);
1451         cancel_flags = XFS_TRANS_RELEASE_LOG_RES;
1452         /*
1453          * The symlink will fit into the inode data fork?
1454          * There can't be any attributes so we get the whole variable part.
1455          */
1456         if (pathlen <= XFS_LITINO(mp))
1457                 fs_blocks = 0;
1458         else
1459                 fs_blocks = XFS_B_TO_FSB(mp, pathlen);
1460         resblks = XFS_SYMLINK_SPACE_RES(mp, link_name->len, fs_blocks);
1461         error = xfs_trans_reserve(tp, resblks, XFS_SYMLINK_LOG_RES(mp), 0,
1462                         XFS_TRANS_PERM_LOG_RES, XFS_SYMLINK_LOG_COUNT);
1463         if (error == ENOSPC && fs_blocks == 0) {
1464                 resblks = 0;
1465                 error = xfs_trans_reserve(tp, 0, XFS_SYMLINK_LOG_RES(mp), 0,
1466                                 XFS_TRANS_PERM_LOG_RES, XFS_SYMLINK_LOG_COUNT);
1467         }
1468         if (error) {
1469                 cancel_flags = 0;
1470                 goto error_return;
1471         }
1472
1473         xfs_ilock(dp, XFS_ILOCK_EXCL | XFS_ILOCK_PARENT);
1474         unlock_dp_on_error = B_TRUE;
1475
1476         /*
1477          * Check whether the directory allows new symlinks or not.
1478          */
1479         if (dp->i_d.di_flags & XFS_DIFLAG_NOSYMLINKS) {
1480                 error = XFS_ERROR(EPERM);
1481                 goto error_return;
1482         }
1483
1484         /*
1485          * Reserve disk quota : blocks and inode.
1486          */
1487         error = xfs_trans_reserve_quota(tp, mp, udqp, gdqp, resblks, 1, 0);
1488         if (error)
1489                 goto error_return;
1490
1491         /*
1492          * Check for ability to enter directory entry, if no space reserved.
1493          */
1494         error = xfs_dir_canenter(tp, dp, link_name, resblks);
1495         if (error)
1496                 goto error_return;
1497         /*
1498          * Initialize the bmap freelist prior to calling either
1499          * bmapi or the directory create code.
1500          */
1501         xfs_bmap_init(&free_list, &first_block);
1502
1503         /*
1504          * Allocate an inode for the symlink.
1505          */
1506         error = xfs_dir_ialloc(&tp, dp, S_IFLNK | (mode & ~S_IFMT), 1, 0,
1507                                prid, resblks > 0, &ip, NULL);
1508         if (error) {
1509                 if (error == ENOSPC)
1510                         goto error_return;
1511                 goto error1;
1512         }
1513
1514         /*
1515          * An error after we've joined dp to the transaction will result in the
1516          * transaction cancel unlocking dp so don't do it explicitly in the
1517          * error path.
1518          */
1519         xfs_trans_ijoin(tp, dp, XFS_ILOCK_EXCL);
1520         unlock_dp_on_error = B_FALSE;
1521
1522         /*
1523          * Also attach the dquot(s) to it, if applicable.
1524          */
1525         xfs_qm_vop_create_dqattach(tp, ip, udqp, gdqp);
1526
1527         if (resblks)
1528                 resblks -= XFS_IALLOC_SPACE_RES(mp);
1529         /*
1530          * If the symlink will fit into the inode, write it inline.
1531          */
1532         if (pathlen <= XFS_IFORK_DSIZE(ip)) {
1533                 xfs_idata_realloc(ip, pathlen, XFS_DATA_FORK);
1534                 memcpy(ip->i_df.if_u1.if_data, target_path, pathlen);
1535                 ip->i_d.di_size = pathlen;
1536
1537                 /*
1538                  * The inode was initially created in extent format.
1539                  */
1540                 ip->i_df.if_flags &= ~(XFS_IFEXTENTS | XFS_IFBROOT);
1541                 ip->i_df.if_flags |= XFS_IFINLINE;
1542
1543                 ip->i_d.di_format = XFS_DINODE_FMT_LOCAL;
1544                 xfs_trans_log_inode(tp, ip, XFS_ILOG_DDATA | XFS_ILOG_CORE);
1545
1546         } else {
1547                 first_fsb = 0;
1548                 nmaps = SYMLINK_MAPS;
1549
1550                 error = xfs_bmapi_write(tp, ip, first_fsb, fs_blocks,
1551                                   XFS_BMAPI_METADATA, &first_block, resblks,
1552                                   mval, &nmaps, &free_list);
1553                 if (error)
1554                         goto error2;
1555
1556                 if (resblks)
1557                         resblks -= fs_blocks;
1558                 ip->i_d.di_size = pathlen;
1559                 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
1560
1561                 cur_chunk = target_path;
1562                 for (n = 0; n < nmaps; n++) {
1563                         d = XFS_FSB_TO_DADDR(mp, mval[n].br_startblock);
1564                         byte_cnt = XFS_FSB_TO_B(mp, mval[n].br_blockcount);
1565                         bp = xfs_trans_get_buf(tp, mp->m_ddev_targp, d,
1566                                                BTOBB(byte_cnt), 0);
1567                         if (!bp) {
1568                                 error = ENOMEM;
1569                                 goto error2;
1570                         }
1571                         if (pathlen < byte_cnt) {
1572                                 byte_cnt = pathlen;
1573                         }
1574                         pathlen -= byte_cnt;
1575
1576                         memcpy(bp->b_addr, cur_chunk, byte_cnt);
1577                         cur_chunk += byte_cnt;
1578
1579                         xfs_trans_log_buf(tp, bp, 0, byte_cnt - 1);
1580                 }
1581         }
1582
1583         /*
1584          * Create the directory entry for the symlink.
1585          */
1586         error = xfs_dir_createname(tp, dp, link_name, ip->i_ino,
1587                                         &first_block, &free_list, resblks);
1588         if (error)
1589                 goto error2;
1590         xfs_trans_ichgtime(tp, dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
1591         xfs_trans_log_inode(tp, dp, XFS_ILOG_CORE);
1592
1593         /*
1594          * If this is a synchronous mount, make sure that the
1595          * symlink transaction goes to disk before returning to
1596          * the user.
1597          */
1598         if (mp->m_flags & (XFS_MOUNT_WSYNC|XFS_MOUNT_DIRSYNC)) {
1599                 xfs_trans_set_sync(tp);
1600         }
1601
1602         error = xfs_bmap_finish(&tp, &free_list, &committed);
1603         if (error) {
1604                 goto error2;
1605         }
1606         error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
1607         xfs_qm_dqrele(udqp);
1608         xfs_qm_dqrele(gdqp);
1609
1610         *ipp = ip;
1611         return 0;
1612
1613  error2:
1614         IRELE(ip);
1615  error1:
1616         xfs_bmap_cancel(&free_list);
1617         cancel_flags |= XFS_TRANS_ABORT;
1618  error_return:
1619         xfs_trans_cancel(tp, cancel_flags);
1620         xfs_qm_dqrele(udqp);
1621         xfs_qm_dqrele(gdqp);
1622
1623         if (unlock_dp_on_error)
1624                 xfs_iunlock(dp, XFS_ILOCK_EXCL);
1625  std_return:
1626         return error;
1627 }
1628
1629 int
1630 xfs_set_dmattrs(
1631         xfs_inode_t     *ip,
1632         u_int           evmask,
1633         u_int16_t       state)
1634 {
1635         xfs_mount_t     *mp = ip->i_mount;
1636         xfs_trans_t     *tp;
1637         int             error;
1638
1639         if (!capable(CAP_SYS_ADMIN))
1640                 return XFS_ERROR(EPERM);
1641
1642         if (XFS_FORCED_SHUTDOWN(mp))
1643                 return XFS_ERROR(EIO);
1644
1645         tp = xfs_trans_alloc(mp, XFS_TRANS_SET_DMATTRS);
1646         error = xfs_trans_reserve(tp, 0, XFS_ICHANGE_LOG_RES (mp), 0, 0, 0);
1647         if (error) {
1648                 xfs_trans_cancel(tp, 0);
1649                 return error;
1650         }
1651         xfs_ilock(ip, XFS_ILOCK_EXCL);
1652         xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
1653
1654         ip->i_d.di_dmevmask = evmask;
1655         ip->i_d.di_dmstate  = state;
1656
1657         xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
1658         error = xfs_trans_commit(tp, 0);
1659
1660         return error;
1661 }
1662
1663 /*
1664  * xfs_alloc_file_space()
1665  *      This routine allocates disk space for the given file.
1666  *
1667  *      If alloc_type == 0, this request is for an ALLOCSP type
1668  *      request which will change the file size.  In this case, no
1669  *      DMAPI event will be generated by the call.  A TRUNCATE event
1670  *      will be generated later by xfs_setattr.
1671  *
1672  *      If alloc_type != 0, this request is for a RESVSP type
1673  *      request, and a DMAPI DM_EVENT_WRITE will be generated if the
1674  *      lower block boundary byte address is less than the file's
1675  *      length.
1676  *
1677  * RETURNS:
1678  *       0 on success
1679  *      errno on error
1680  *
1681  */
1682 STATIC int
1683 xfs_alloc_file_space(
1684         xfs_inode_t             *ip,
1685         xfs_off_t               offset,
1686         xfs_off_t               len,
1687         int                     alloc_type,
1688         int                     attr_flags)
1689 {
1690         xfs_mount_t             *mp = ip->i_mount;
1691         xfs_off_t               count;
1692         xfs_filblks_t           allocated_fsb;
1693         xfs_filblks_t           allocatesize_fsb;
1694         xfs_extlen_t            extsz, temp;
1695         xfs_fileoff_t           startoffset_fsb;
1696         xfs_fsblock_t           firstfsb;
1697         int                     nimaps;
1698         int                     quota_flag;
1699         int                     rt;
1700         xfs_trans_t             *tp;
1701         xfs_bmbt_irec_t         imaps[1], *imapp;
1702         xfs_bmap_free_t         free_list;
1703         uint                    qblocks, resblks, resrtextents;
1704         int                     committed;
1705         int                     error;
1706
1707         trace_xfs_alloc_file_space(ip);
1708
1709         if (XFS_FORCED_SHUTDOWN(mp))
1710                 return XFS_ERROR(EIO);
1711
1712         error = xfs_qm_dqattach(ip, 0);
1713         if (error)
1714                 return error;
1715
1716         if (len <= 0)
1717                 return XFS_ERROR(EINVAL);
1718
1719         rt = XFS_IS_REALTIME_INODE(ip);
1720         extsz = xfs_get_extsz_hint(ip);
1721
1722         count = len;
1723         imapp = &imaps[0];
1724         nimaps = 1;
1725         startoffset_fsb = XFS_B_TO_FSBT(mp, offset);
1726         allocatesize_fsb = XFS_B_TO_FSB(mp, count);
1727
1728         /*
1729          * Allocate file space until done or until there is an error
1730          */
1731         while (allocatesize_fsb && !error) {
1732                 xfs_fileoff_t   s, e;
1733
1734                 /*
1735                  * Determine space reservations for data/realtime.
1736                  */
1737                 if (unlikely(extsz)) {
1738                         s = startoffset_fsb;
1739                         do_div(s, extsz);
1740                         s *= extsz;
1741                         e = startoffset_fsb + allocatesize_fsb;
1742                         if ((temp = do_mod(startoffset_fsb, extsz)))
1743                                 e += temp;
1744                         if ((temp = do_mod(e, extsz)))
1745                                 e += extsz - temp;
1746                 } else {
1747                         s = 0;
1748                         e = allocatesize_fsb;
1749                 }
1750
1751                 /*
1752                  * The transaction reservation is limited to a 32-bit block
1753                  * count, hence we need to limit the number of blocks we are
1754                  * trying to reserve to avoid an overflow. We can't allocate
1755                  * more than @nimaps extents, and an extent is limited on disk
1756                  * to MAXEXTLEN (21 bits), so use that to enforce the limit.
1757                  */
1758                 resblks = min_t(xfs_fileoff_t, (e - s), (MAXEXTLEN * nimaps));
1759                 if (unlikely(rt)) {
1760                         resrtextents = qblocks = resblks;
1761                         resrtextents /= mp->m_sb.sb_rextsize;
1762                         resblks = XFS_DIOSTRAT_SPACE_RES(mp, 0);
1763                         quota_flag = XFS_QMOPT_RES_RTBLKS;
1764                 } else {
1765                         resrtextents = 0;
1766                         resblks = qblocks = XFS_DIOSTRAT_SPACE_RES(mp, resblks);
1767                         quota_flag = XFS_QMOPT_RES_REGBLKS;
1768                 }
1769
1770                 /*
1771                  * Allocate and setup the transaction.
1772                  */
1773                 tp = xfs_trans_alloc(mp, XFS_TRANS_DIOSTRAT);
1774                 error = xfs_trans_reserve(tp, resblks,
1775                                           XFS_WRITE_LOG_RES(mp), resrtextents,
1776                                           XFS_TRANS_PERM_LOG_RES,
1777                                           XFS_WRITE_LOG_COUNT);
1778                 /*
1779                  * Check for running out of space
1780                  */
1781                 if (error) {
1782                         /*
1783                          * Free the transaction structure.
1784                          */
1785                         ASSERT(error == ENOSPC || XFS_FORCED_SHUTDOWN(mp));
1786                         xfs_trans_cancel(tp, 0);
1787                         break;
1788                 }
1789                 xfs_ilock(ip, XFS_ILOCK_EXCL);
1790                 error = xfs_trans_reserve_quota_nblks(tp, ip, qblocks,
1791                                                       0, quota_flag);
1792                 if (error)
1793                         goto error1;
1794
1795                 xfs_trans_ijoin(tp, ip, 0);
1796
1797                 xfs_bmap_init(&free_list, &firstfsb);
1798                 error = xfs_bmapi_write(tp, ip, startoffset_fsb,
1799                                         allocatesize_fsb, alloc_type, &firstfsb,
1800                                         0, imapp, &nimaps, &free_list);
1801                 if (error) {
1802                         goto error0;
1803                 }
1804
1805                 /*
1806                  * Complete the transaction
1807                  */
1808                 error = xfs_bmap_finish(&tp, &free_list, &committed);
1809                 if (error) {
1810                         goto error0;
1811                 }
1812
1813                 error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
1814                 xfs_iunlock(ip, XFS_ILOCK_EXCL);
1815                 if (error) {
1816                         break;
1817                 }
1818
1819                 allocated_fsb = imapp->br_blockcount;
1820
1821                 if (nimaps == 0) {
1822                         error = XFS_ERROR(ENOSPC);
1823                         break;
1824                 }
1825
1826                 startoffset_fsb += allocated_fsb;
1827                 allocatesize_fsb -= allocated_fsb;
1828         }
1829
1830         return error;
1831
1832 error0: /* Cancel bmap, unlock inode, unreserve quota blocks, cancel trans */
1833         xfs_bmap_cancel(&free_list);
1834         xfs_trans_unreserve_quota_nblks(tp, ip, (long)qblocks, 0, quota_flag);
1835
1836 error1: /* Just cancel transaction */
1837         xfs_trans_cancel(tp, XFS_TRANS_RELEASE_LOG_RES | XFS_TRANS_ABORT);
1838         xfs_iunlock(ip, XFS_ILOCK_EXCL);
1839         return error;
1840 }
1841
1842 /*
1843  * Zero file bytes between startoff and endoff inclusive.
1844  * The iolock is held exclusive and no blocks are buffered.
1845  *
1846  * This function is used by xfs_free_file_space() to zero
1847  * partial blocks when the range to free is not block aligned.
1848  * When unreserving space with boundaries that are not block
1849  * aligned we round up the start and round down the end
1850  * boundaries and then use this function to zero the parts of
1851  * the blocks that got dropped during the rounding.
1852  */
1853 STATIC int
1854 xfs_zero_remaining_bytes(
1855         xfs_inode_t             *ip,
1856         xfs_off_t               startoff,
1857         xfs_off_t               endoff)
1858 {
1859         xfs_bmbt_irec_t         imap;
1860         xfs_fileoff_t           offset_fsb;
1861         xfs_off_t               lastoffset;
1862         xfs_off_t               offset;
1863         xfs_buf_t               *bp;
1864         xfs_mount_t             *mp = ip->i_mount;
1865         int                     nimap;
1866         int                     error = 0;
1867
1868         /*
1869          * Avoid doing I/O beyond eof - it's not necessary
1870          * since nothing can read beyond eof.  The space will
1871          * be zeroed when the file is extended anyway.
1872          */
1873         if (startoff >= XFS_ISIZE(ip))
1874                 return 0;
1875
1876         if (endoff > XFS_ISIZE(ip))
1877                 endoff = XFS_ISIZE(ip);
1878
1879         bp = xfs_buf_get_uncached(XFS_IS_REALTIME_INODE(ip) ?
1880                                         mp->m_rtdev_targp : mp->m_ddev_targp,
1881                                   BTOBB(mp->m_sb.sb_blocksize), 0);
1882         if (!bp)
1883                 return XFS_ERROR(ENOMEM);
1884
1885         xfs_buf_unlock(bp);
1886
1887         for (offset = startoff; offset <= endoff; offset = lastoffset + 1) {
1888                 offset_fsb = XFS_B_TO_FSBT(mp, offset);
1889                 nimap = 1;
1890                 error = xfs_bmapi_read(ip, offset_fsb, 1, &imap, &nimap, 0);
1891                 if (error || nimap < 1)
1892                         break;
1893                 ASSERT(imap.br_blockcount >= 1);
1894                 ASSERT(imap.br_startoff == offset_fsb);
1895                 lastoffset = XFS_FSB_TO_B(mp, imap.br_startoff + 1) - 1;
1896                 if (lastoffset > endoff)
1897                         lastoffset = endoff;
1898                 if (imap.br_startblock == HOLESTARTBLOCK)
1899                         continue;
1900                 ASSERT(imap.br_startblock != DELAYSTARTBLOCK);
1901                 if (imap.br_state == XFS_EXT_UNWRITTEN)
1902                         continue;
1903                 XFS_BUF_UNDONE(bp);
1904                 XFS_BUF_UNWRITE(bp);
1905                 XFS_BUF_READ(bp);
1906                 XFS_BUF_SET_ADDR(bp, xfs_fsb_to_db(ip, imap.br_startblock));
1907                 xfsbdstrat(mp, bp);
1908                 error = xfs_buf_iowait(bp);
1909                 if (error) {
1910                         xfs_buf_ioerror_alert(bp,
1911                                         "xfs_zero_remaining_bytes(read)");
1912                         break;
1913                 }
1914                 memset(bp->b_addr +
1915                         (offset - XFS_FSB_TO_B(mp, imap.br_startoff)),
1916                       0, lastoffset - offset + 1);
1917                 XFS_BUF_UNDONE(bp);
1918                 XFS_BUF_UNREAD(bp);
1919                 XFS_BUF_WRITE(bp);
1920                 xfsbdstrat(mp, bp);
1921                 error = xfs_buf_iowait(bp);
1922                 if (error) {
1923                         xfs_buf_ioerror_alert(bp,
1924                                         "xfs_zero_remaining_bytes(write)");
1925                         break;
1926                 }
1927         }
1928         xfs_buf_free(bp);
1929         return error;
1930 }
1931
1932 /*
1933  * xfs_free_file_space()
1934  *      This routine frees disk space for the given file.
1935  *
1936  *      This routine is only called by xfs_change_file_space
1937  *      for an UNRESVSP type call.
1938  *
1939  * RETURNS:
1940  *       0 on success
1941  *      errno on error
1942  *
1943  */
1944 STATIC int
1945 xfs_free_file_space(
1946         xfs_inode_t             *ip,
1947         xfs_off_t               offset,
1948         xfs_off_t               len,
1949         int                     attr_flags)
1950 {
1951         int                     committed;
1952         int                     done;
1953         xfs_fileoff_t           endoffset_fsb;
1954         int                     error;
1955         xfs_fsblock_t           firstfsb;
1956         xfs_bmap_free_t         free_list;
1957         xfs_bmbt_irec_t         imap;
1958         xfs_off_t               ioffset;
1959         xfs_extlen_t            mod=0;
1960         xfs_mount_t             *mp;
1961         int                     nimap;
1962         uint                    resblks;
1963         uint                    rounding;
1964         int                     rt;
1965         xfs_fileoff_t           startoffset_fsb;
1966         xfs_trans_t             *tp;
1967         int                     need_iolock = 1;
1968
1969         mp = ip->i_mount;
1970
1971         trace_xfs_free_file_space(ip);
1972
1973         error = xfs_qm_dqattach(ip, 0);
1974         if (error)
1975                 return error;
1976
1977         error = 0;
1978         if (len <= 0)   /* if nothing being freed */
1979                 return error;
1980         rt = XFS_IS_REALTIME_INODE(ip);
1981         startoffset_fsb = XFS_B_TO_FSB(mp, offset);
1982         endoffset_fsb = XFS_B_TO_FSBT(mp, offset + len);
1983
1984         if (attr_flags & XFS_ATTR_NOLOCK)
1985                 need_iolock = 0;
1986         if (need_iolock) {
1987                 xfs_ilock(ip, XFS_IOLOCK_EXCL);
1988                 /* wait for the completion of any pending DIOs */
1989                 inode_dio_wait(VFS_I(ip));
1990         }
1991
1992         rounding = max_t(uint, 1 << mp->m_sb.sb_blocklog, PAGE_CACHE_SIZE);
1993         ioffset = offset & ~(rounding - 1);
1994
1995         if (VN_CACHED(VFS_I(ip)) != 0) {
1996                 error = xfs_flushinval_pages(ip, ioffset, -1, FI_REMAPF_LOCKED);
1997                 if (error)
1998                         goto out_unlock_iolock;
1999         }
2000
2001         /*
2002          * Need to zero the stuff we're not freeing, on disk.
2003          * If it's a realtime file & can't use unwritten extents then we
2004          * actually need to zero the extent edges.  Otherwise xfs_bunmapi
2005          * will take care of it for us.
2006          */
2007         if (rt && !xfs_sb_version_hasextflgbit(&mp->m_sb)) {
2008                 nimap = 1;
2009                 error = xfs_bmapi_read(ip, startoffset_fsb, 1,
2010                                         &imap, &nimap, 0);
2011                 if (error)
2012                         goto out_unlock_iolock;
2013                 ASSERT(nimap == 0 || nimap == 1);
2014                 if (nimap && imap.br_startblock != HOLESTARTBLOCK) {
2015                         xfs_daddr_t     block;
2016
2017                         ASSERT(imap.br_startblock != DELAYSTARTBLOCK);
2018                         block = imap.br_startblock;
2019                         mod = do_div(block, mp->m_sb.sb_rextsize);
2020                         if (mod)
2021                                 startoffset_fsb += mp->m_sb.sb_rextsize - mod;
2022                 }
2023                 nimap = 1;
2024                 error = xfs_bmapi_read(ip, endoffset_fsb - 1, 1,
2025                                         &imap, &nimap, 0);
2026                 if (error)
2027                         goto out_unlock_iolock;
2028                 ASSERT(nimap == 0 || nimap == 1);
2029                 if (nimap && imap.br_startblock != HOLESTARTBLOCK) {
2030                         ASSERT(imap.br_startblock != DELAYSTARTBLOCK);
2031                         mod++;
2032                         if (mod && (mod != mp->m_sb.sb_rextsize))
2033                                 endoffset_fsb -= mod;
2034                 }
2035         }
2036         if ((done = (endoffset_fsb <= startoffset_fsb)))
2037                 /*
2038                  * One contiguous piece to clear
2039                  */
2040                 error = xfs_zero_remaining_bytes(ip, offset, offset + len - 1);
2041         else {
2042                 /*
2043                  * Some full blocks, possibly two pieces to clear
2044                  */
2045                 if (offset < XFS_FSB_TO_B(mp, startoffset_fsb))
2046                         error = xfs_zero_remaining_bytes(ip, offset,
2047                                 XFS_FSB_TO_B(mp, startoffset_fsb) - 1);
2048                 if (!error &&
2049                     XFS_FSB_TO_B(mp, endoffset_fsb) < offset + len)
2050                         error = xfs_zero_remaining_bytes(ip,
2051                                 XFS_FSB_TO_B(mp, endoffset_fsb),
2052                                 offset + len - 1);
2053         }
2054
2055         /*
2056          * free file space until done or until there is an error
2057          */
2058         resblks = XFS_DIOSTRAT_SPACE_RES(mp, 0);
2059         while (!error && !done) {
2060
2061                 /*
2062                  * allocate and setup the transaction. Allow this
2063                  * transaction to dip into the reserve blocks to ensure
2064                  * the freeing of the space succeeds at ENOSPC.
2065                  */
2066                 tp = xfs_trans_alloc(mp, XFS_TRANS_DIOSTRAT);
2067                 tp->t_flags |= XFS_TRANS_RESERVE;
2068                 error = xfs_trans_reserve(tp,
2069                                           resblks,
2070                                           XFS_WRITE_LOG_RES(mp),
2071                                           0,
2072                                           XFS_TRANS_PERM_LOG_RES,
2073                                           XFS_WRITE_LOG_COUNT);
2074
2075                 /*
2076                  * check for running out of space
2077                  */
2078                 if (error) {
2079                         /*
2080                          * Free the transaction structure.
2081                          */
2082                         ASSERT(error == ENOSPC || XFS_FORCED_SHUTDOWN(mp));
2083                         xfs_trans_cancel(tp, 0);
2084                         break;
2085                 }
2086                 xfs_ilock(ip, XFS_ILOCK_EXCL);
2087                 error = xfs_trans_reserve_quota(tp, mp,
2088                                 ip->i_udquot, ip->i_gdquot,
2089                                 resblks, 0, XFS_QMOPT_RES_REGBLKS);
2090                 if (error)
2091                         goto error1;
2092
2093                 xfs_trans_ijoin(tp, ip, 0);
2094
2095                 /*
2096                  * issue the bunmapi() call to free the blocks
2097                  */
2098                 xfs_bmap_init(&free_list, &firstfsb);
2099                 error = xfs_bunmapi(tp, ip, startoffset_fsb,
2100                                   endoffset_fsb - startoffset_fsb,
2101                                   0, 2, &firstfsb, &free_list, &done);
2102                 if (error) {
2103                         goto error0;
2104                 }
2105
2106                 /*
2107                  * complete the transaction
2108                  */
2109                 error = xfs_bmap_finish(&tp, &free_list, &committed);
2110                 if (error) {
2111                         goto error0;
2112                 }
2113
2114                 error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
2115                 xfs_iunlock(ip, XFS_ILOCK_EXCL);
2116         }
2117
2118  out_unlock_iolock:
2119         if (need_iolock)
2120                 xfs_iunlock(ip, XFS_IOLOCK_EXCL);
2121         return error;
2122
2123  error0:
2124         xfs_bmap_cancel(&free_list);
2125  error1:
2126         xfs_trans_cancel(tp, XFS_TRANS_RELEASE_LOG_RES | XFS_TRANS_ABORT);
2127         xfs_iunlock(ip, need_iolock ? (XFS_ILOCK_EXCL | XFS_IOLOCK_EXCL) :
2128                     XFS_ILOCK_EXCL);
2129         return error;
2130 }
2131
2132 /*
2133  * xfs_change_file_space()
2134  *      This routine allocates or frees disk space for the given file.
2135  *      The user specified parameters are checked for alignment and size
2136  *      limitations.
2137  *
2138  * RETURNS:
2139  *       0 on success
2140  *      errno on error
2141  *
2142  */
2143 int
2144 xfs_change_file_space(
2145         xfs_inode_t     *ip,
2146         int             cmd,
2147         xfs_flock64_t   *bf,
2148         xfs_off_t       offset,
2149         int             attr_flags)
2150 {
2151         xfs_mount_t     *mp = ip->i_mount;
2152         int             clrprealloc;
2153         int             error;
2154         xfs_fsize_t     fsize;
2155         int             setprealloc;
2156         xfs_off_t       startoffset;
2157         xfs_off_t       llen;
2158         xfs_trans_t     *tp;
2159         struct iattr    iattr;
2160         int             prealloc_type;
2161
2162         if (!S_ISREG(ip->i_d.di_mode))
2163                 return XFS_ERROR(EINVAL);
2164
2165         switch (bf->l_whence) {
2166         case 0: /*SEEK_SET*/
2167                 break;
2168         case 1: /*SEEK_CUR*/
2169                 bf->l_start += offset;
2170                 break;
2171         case 2: /*SEEK_END*/
2172                 bf->l_start += XFS_ISIZE(ip);
2173                 break;
2174         default:
2175                 return XFS_ERROR(EINVAL);
2176         }
2177
2178         llen = bf->l_len > 0 ? bf->l_len - 1 : bf->l_len;
2179
2180         if (bf->l_start < 0 ||
2181             bf->l_start > mp->m_super->s_maxbytes ||
2182             bf->l_start + llen < 0 ||
2183             bf->l_start + llen > mp->m_super->s_maxbytes)
2184                 return XFS_ERROR(EINVAL);
2185
2186         bf->l_whence = 0;
2187
2188         startoffset = bf->l_start;
2189         fsize = XFS_ISIZE(ip);
2190
2191         /*
2192          * XFS_IOC_RESVSP and XFS_IOC_UNRESVSP will reserve or unreserve
2193          * file space.
2194          * These calls do NOT zero the data space allocated to the file,
2195          * nor do they change the file size.
2196          *
2197          * XFS_IOC_ALLOCSP and XFS_IOC_FREESP will allocate and free file
2198          * space.
2199          * These calls cause the new file data to be zeroed and the file
2200          * size to be changed.
2201          */
2202         setprealloc = clrprealloc = 0;
2203         prealloc_type = XFS_BMAPI_PREALLOC;
2204
2205         switch (cmd) {
2206         case XFS_IOC_ZERO_RANGE:
2207                 prealloc_type |= XFS_BMAPI_CONVERT;
2208                 xfs_tosspages(ip, startoffset, startoffset + bf->l_len, 0);
2209                 /* FALLTHRU */
2210         case XFS_IOC_RESVSP:
2211         case XFS_IOC_RESVSP64:
2212                 error = xfs_alloc_file_space(ip, startoffset, bf->l_len,
2213                                                 prealloc_type, attr_flags);
2214                 if (error)
2215                         return error;
2216                 setprealloc = 1;
2217                 break;
2218
2219         case XFS_IOC_UNRESVSP:
2220         case XFS_IOC_UNRESVSP64:
2221                 if ((error = xfs_free_file_space(ip, startoffset, bf->l_len,
2222                                                                 attr_flags)))
2223                         return error;
2224                 break;
2225
2226         case XFS_IOC_ALLOCSP:
2227         case XFS_IOC_ALLOCSP64:
2228         case XFS_IOC_FREESP:
2229         case XFS_IOC_FREESP64:
2230                 /*
2231                  * These operations actually do IO when extending the file, but
2232                  * the allocation is done seperately to the zeroing that is
2233                  * done. This set of operations need to be serialised against
2234                  * other IO operations, such as truncate and buffered IO. We
2235                  * need to take the IOLOCK here to serialise the allocation and
2236                  * zeroing IO to prevent other IOLOCK holders (e.g. getbmap,
2237                  * truncate, direct IO) from racing against the transient
2238                  * allocated but not written state we can have here.
2239                  */
2240                 xfs_ilock(ip, XFS_IOLOCK_EXCL);
2241                 if (startoffset > fsize) {
2242                         error = xfs_alloc_file_space(ip, fsize,
2243                                         startoffset - fsize, 0,
2244                                         attr_flags | XFS_ATTR_NOLOCK);
2245                         if (error) {
2246                                 xfs_iunlock(ip, XFS_IOLOCK_EXCL);
2247                                 break;
2248                         }
2249                 }
2250
2251                 iattr.ia_valid = ATTR_SIZE;
2252                 iattr.ia_size = startoffset;
2253
2254                 error = xfs_setattr_size(ip, &iattr,
2255                                          attr_flags | XFS_ATTR_NOLOCK);
2256                 xfs_iunlock(ip, XFS_IOLOCK_EXCL);
2257
2258                 if (error)
2259                         return error;
2260
2261                 clrprealloc = 1;
2262                 break;
2263
2264         default:
2265                 ASSERT(0);
2266                 return XFS_ERROR(EINVAL);
2267         }
2268
2269         /*
2270          * update the inode timestamp, mode, and prealloc flag bits
2271          */
2272         tp = xfs_trans_alloc(mp, XFS_TRANS_WRITEID);
2273
2274         if ((error = xfs_trans_reserve(tp, 0, XFS_WRITEID_LOG_RES(mp),
2275                                       0, 0, 0))) {
2276                 /* ASSERT(0); */
2277                 xfs_trans_cancel(tp, 0);
2278                 return error;
2279         }
2280
2281         xfs_ilock(ip, XFS_ILOCK_EXCL);
2282         xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
2283
2284         if ((attr_flags & XFS_ATTR_DMI) == 0) {
2285                 ip->i_d.di_mode &= ~S_ISUID;
2286
2287                 /*
2288                  * Note that we don't have to worry about mandatory
2289                  * file locking being disabled here because we only
2290                  * clear the S_ISGID bit if the Group execute bit is
2291                  * on, but if it was on then mandatory locking wouldn't
2292                  * have been enabled.
2293                  */
2294                 if (ip->i_d.di_mode & S_IXGRP)
2295                         ip->i_d.di_mode &= ~S_ISGID;
2296
2297                 xfs_trans_ichgtime(tp, ip, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
2298         }
2299         if (setprealloc)
2300                 ip->i_d.di_flags |= XFS_DIFLAG_PREALLOC;
2301         else if (clrprealloc)
2302                 ip->i_d.di_flags &= ~XFS_DIFLAG_PREALLOC;
2303
2304         xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
2305         if (attr_flags & XFS_ATTR_SYNC)
2306                 xfs_trans_set_sync(tp);
2307         return xfs_trans_commit(tp, 0);
2308 }