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