1 files changed, 106 insertions, 106 deletions

diff --git a/fs/xfs/xfs_vnodeops.c b/fs/xfs/xfs_vnodeops.c
index 4c7c7bfb2b2f..619720705bc6 100644
--- a/fs/xfs/xfs_vnodeops.c
+++ b/fs/xfs/xfs_vnodeops.c
@@ -114,7 +114,7 @@ xfs_setattr(
                  */
                 ASSERT(udqp == NULL);
                 ASSERT(gdqp == NULL);
-                code = xfs_qm_vop_dqalloc(ip, uid, gid, ip->i_d.di_projid,
+                code = xfs_qm_vop_dqalloc(ip, uid, gid, xfs_get_projid(ip),
                                          qflags, &udqp, &gdqp);
                 if (code)
                         return code;
@@ -184,8 +184,11 @@ xfs_setattr(
                     ip->i_size == 0 && ip->i_d.di_nextents == 0) {
                         xfs_iunlock(ip, XFS_ILOCK_EXCL);
                         lock_flags &= ~XFS_ILOCK_EXCL;
-                        if (mask & ATTR_CTIME)
-                                xfs_ichgtime(ip, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
+                        if (mask & ATTR_CTIME) {
+                                inode->i_mtime = inode->i_ctime =
+                                                current_fs_time(inode->i_sb);
+                                xfs_mark_inode_dirty_sync(ip);
+                        }
                         code = 0;
                         goto error_return;
                 }
@@ -950,40 +953,62 @@ xfs_release(
                  * If we previously truncated this file and removed old data
                  * in the process, we want to initiate "early" writeout on
                  * the last close.  This is an attempt to combat the notorious
-                 * NULL files problem which is particularly noticable from a
+                 * NULL files problem which is particularly noticeable from a
                  * truncate down, buffered (re-)write (delalloc), followed by
                  * a crash.  What we are effectively doing here is
                  * significantly reducing the time window where we'd otherwise
                  * be exposed to that problem.
                  */
                 truncated = xfs_iflags_test_and_clear(ip, XFS_ITRUNCATED);
-                if (truncated && VN_DIRTY(VFS_I(ip)) && ip->i_delayed_blks > 0)
-                        xfs_flush_pages(ip, 0, -1, XBF_ASYNC, FI_NONE);
+                if (truncated) {
+                        xfs_iflags_clear(ip, XFS_IDIRTY_RELEASE);
+                        if (VN_DIRTY(VFS_I(ip)) && ip->i_delayed_blks > 0)
+                                xfs_flush_pages(ip, 0, -1, XBF_ASYNC, FI_NONE);
+                }
         }
 
-        if (ip->i_d.di_nlink != 0) {
-                if ((((ip->i_d.di_mode & S_IFMT) == S_IFREG) &&
-                     ((ip->i_size > 0) || (VN_CACHED(VFS_I(ip)) > 0 ||
-                       ip->i_delayed_blks > 0)) &&
-                     (ip->i_df.if_flags & XFS_IFEXTENTS))  &&
-                    (!(ip->i_d.di_flags &
-                                (XFS_DIFLAG_PREALLOC | XFS_DIFLAG_APPEND)))) {
+        if (ip->i_d.di_nlink == 0)
+                return 0;
 
-                        /*
-                         * If we can't get the iolock just skip truncating
-                         * the blocks past EOF because we could deadlock
-                         * with the mmap_sem otherwise.  We'll get another
-                         * chance to drop them once the last reference to
-                         * the inode is dropped, so we'll never leak blocks
-                         * permanently.
-                         */
-                        error = xfs_free_eofblocks(mp, ip,
-                                                   XFS_FREE_EOF_TRYLOCK);
-                        if (error)
-                                return error;
-                }
-        }
+        if ((((ip->i_d.di_mode & S_IFMT) == S_IFREG) &&
+             ((ip->i_size > 0) || (VN_CACHED(VFS_I(ip)) > 0 ||
+               ip->i_delayed_blks > 0)) &&
+             (ip->i_df.if_flags & XFS_IFEXTENTS))  &&
+            (!(ip->i_d.di_flags & (XFS_DIFLAG_PREALLOC | XFS_DIFLAG_APPEND)))) {
+
+                /*
+                 * If we can't get the iolock just skip truncating the blocks
+                 * past EOF because we could deadlock with the mmap_sem
+                 * otherwise.  We'll get another chance to drop them once the
+                 * last reference to the inode is dropped, so we'll never leak
+                 * blocks permanently.
+                 *
+                 * Further, check if the inode is being opened, written and
+                 * closed frequently and we have delayed allocation blocks
+                 * outstanding (e.g. streaming writes from the NFS server),
+                 * truncating the blocks past EOF will cause fragmentation to
+                 * occur.
+                 *
+                 * In this case don't do the truncation, either, but we have to
+                 * be careful how we detect this case. Blocks beyond EOF show
+                 * up as i_delayed_blks even when the inode is clean, so we
+                 * need to truncate them away first before checking for a dirty
+                 * release. Hence on the first dirty close we will still remove
+                 * the speculative allocation, but after that we will leave it
+                 * in place.
+                 */
+                if (xfs_iflags_test(ip, XFS_IDIRTY_RELEASE))
+                        return 0;
+
+                error = xfs_free_eofblocks(mp, ip,
+                                           XFS_FREE_EOF_TRYLOCK);
+                if (error)
+                        return error;
 
+                /* delalloc blocks after truncation means it really is dirty */
+                if (ip->i_delayed_blks)
+                        xfs_iflags_set(ip, XFS_IDIRTY_RELEASE);
+        }
         return 0;
 }
 
@@ -1167,9 +1192,8 @@ xfs_inactive(
                  * inode might be lost for a long time or forever.
                  */
                 if (!XFS_FORCED_SHUTDOWN(mp)) {
-                        cmn_err(CE_NOTE,
-                "xfs_inactive:  xfs_ifree() returned an error = %d on %s",
-                                error, mp->m_fsname);
+                        xfs_notice(mp, "%s: xfs_ifree returned error %d",
+                                __func__, error);
                         xfs_force_shutdown(mp, SHUTDOWN_META_IO_ERROR);
                 }
                 xfs_trans_cancel(tp, XFS_TRANS_RELEASE_LOG_RES|XFS_TRANS_ABORT);
@@ -1186,12 +1210,12 @@ xfs_inactive(
                  */
                 error = xfs_bmap_finish(&tp,  &free_list, &committed);
                 if (error)
-                        xfs_fs_cmn_err(CE_NOTE, mp, "xfs_inactive: "
-                                "xfs_bmap_finish() returned error %d", error);
+                        xfs_notice(mp, "%s: xfs_bmap_finish returned error %d",
+                                __func__, error);
                 error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
                 if (error)
-                        xfs_fs_cmn_err(CE_NOTE, mp, "xfs_inactive: "
-                                "xfs_trans_commit() returned error %d", error);
+                        xfs_notice(mp, "%s: xfs_trans_commit returned error %d",
+                                __func__, error);
         }
 
         /*
@@ -1253,8 +1277,7 @@ xfs_create(
         struct xfs_name         *name,
         mode_t                  mode,
         xfs_dev_t               rdev,
-        xfs_inode_t             **ipp,
-        cred_t                  *credp)
+        xfs_inode_t             **ipp)
 {
         int                     is_dir = S_ISDIR(mode);
         struct xfs_mount        *mp = dp->i_mount;
@@ -1266,7 +1289,7 @@ xfs_create(
         boolean_t               unlock_dp_on_error = B_FALSE;
         uint                    cancel_flags;
         int                     committed;
-        xfs_prid_t              prid;
+        prid_t                  prid;
         struct xfs_dquot        *udqp = NULL;
         struct xfs_dquot        *gdqp = NULL;
         uint                    resblks;
@@ -1279,9 +1302,9 @@ xfs_create(
                 return XFS_ERROR(EIO);
 
         if (dp->i_d.di_flags & XFS_DIFLAG_PROJINHERIT)
-                prid = dp->i_d.di_projid;
+                prid = xfs_get_projid(dp);
         else
-                prid = dfltprid;
+                prid = XFS_PROJID_DEFAULT;
 
         /*
          * Make sure that we have allocated dquot(s) on disk.
@@ -1289,7 +1312,7 @@ xfs_create(
         error = xfs_qm_vop_dqalloc(dp, current_fsuid(), current_fsgid(), prid,
                         XFS_QMOPT_QUOTALL | XFS_QMOPT_INHERIT, &udqp, &gdqp);
         if (error)
-                goto std_return;
+                return error;
 
         if (is_dir) {
                 rdev = 0;
@@ -1360,7 +1383,7 @@ xfs_create(
          * entry pointing to them, but a directory also the "." entry
          * pointing to itself.
          */
-        error = xfs_dir_ialloc(&tp, dp, mode, is_dir ? 2 : 1, rdev, credp,
+        error = xfs_dir_ialloc(&tp, dp, mode, is_dir ? 2 : 1, rdev,
                                prid, resblks > 0, &ip, &committed);
         if (error) {
                 if (error == ENOSPC)
@@ -1369,12 +1392,6 @@ xfs_create(
         }
 
         /*
-         * At this point, we've gotten a newly allocated inode.
-         * It is locked (and joined to the transaction).
-         */
-        ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
-
-        /*
          * Now we join the directory inode to the transaction.  We do not do it
          * earlier because xfs_dir_ialloc might commit the previous transaction
          * (and release all the locks).  An error from here on will result in
@@ -1391,7 +1408,7 @@ xfs_create(
                 ASSERT(error != ENOSPC);
                 goto out_trans_abort;
         }
-        xfs_ichgtime(dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
+        xfs_trans_ichgtime(tp, dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
         xfs_trans_log_inode(tp, dp, XFS_ILOG_CORE);
 
         if (is_dir) {
@@ -1419,22 +1436,13 @@ xfs_create(
          */
         xfs_qm_vop_create_dqattach(tp, ip, udqp, gdqp);
 
-        /*
-         * xfs_trans_commit normally decrements the vnode ref count
-         * when it unlocks the inode. Since we want to return the
-         * vnode to the caller, we bump the vnode ref count now.
-         */
-        IHOLD(ip);
-
         error = xfs_bmap_finish(&tp, &free_list, &committed);
         if (error)
-                goto out_abort_rele;
+                goto out_bmap_cancel;
 
         error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
-        if (error) {
-                IRELE(ip);
-                goto out_dqrele;
-        }
+        if (error)
+                goto out_release_inode;
 
         xfs_qm_dqrele(udqp);
         xfs_qm_dqrele(gdqp);
@@ -1448,27 +1456,21 @@ xfs_create(
         cancel_flags |= XFS_TRANS_ABORT;
  out_trans_cancel:
         xfs_trans_cancel(tp, cancel_flags);
- out_dqrele:
+ out_release_inode:
+        /*
+         * Wait until after the current transaction is aborted to
+         * release the inode.  This prevents recursive transactions
+         * and deadlocks from xfs_inactive.
+         */
+        if (ip)
+                IRELE(ip);
+
         xfs_qm_dqrele(udqp);
         xfs_qm_dqrele(gdqp);
 
         if (unlock_dp_on_error)
                 xfs_iunlock(dp, XFS_ILOCK_EXCL);
- std_return:
         return error;
-
- out_abort_rele:
-        /*
-         * Wait until after the current transaction is aborted to
-         * release the inode.  This prevents recursive transactions
-         * and deadlocks from xfs_inactive.
-         */
-        xfs_bmap_cancel(&free_list);
-        cancel_flags |= XFS_TRANS_ABORT;
-        xfs_trans_cancel(tp, cancel_flags);
-        IRELE(ip);
-        unlock_dp_on_error = B_FALSE;
-        goto out_dqrele;
 }
 
 #ifdef DEBUG
@@ -1742,7 +1744,7 @@ xfs_remove(
                 ASSERT(error != ENOENT);
                 goto out_bmap_cancel;
         }
-        xfs_ichgtime(dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
+        xfs_trans_ichgtime(tp, dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
 
         if (is_dir) {
                 /*
@@ -1880,7 +1882,7 @@ xfs_link(
          * the tree quota mechanism could be circumvented.
          */
         if (unlikely((tdp->i_d.di_flags & XFS_DIFLAG_PROJINHERIT) &&
-                     (tdp->i_d.di_projid != sip->i_d.di_projid))) {
+                     (xfs_get_projid(tdp) != xfs_get_projid(sip)))) {
                 error = XFS_ERROR(EXDEV);
                 goto error_return;
         }
@@ -1895,7 +1897,7 @@ xfs_link(
                                         &first_block, &free_list, resblks);
         if (error)
                 goto abort_return;
-        xfs_ichgtime(tdp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
+        xfs_trans_ichgtime(tp, tdp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
         xfs_trans_log_inode(tp, tdp, XFS_ILOG_CORE);
 
         error = xfs_bumplink(tp, sip);
@@ -1933,8 +1935,7 @@ xfs_symlink(
         struct xfs_name         *link_name,
         const char              *target_path,
         mode_t                  mode,
-        xfs_inode_t             **ipp,
-        cred_t                  *credp)
+        xfs_inode_t             **ipp)
 {
         xfs_mount_t             *mp = dp->i_mount;
         xfs_trans_t             *tp;
@@ -1955,7 +1956,7 @@ xfs_symlink(
         int                     byte_cnt;
         int                     n;
         xfs_buf_t               *bp;
-        xfs_prid_t              prid;
+        prid_t                  prid;
         struct xfs_dquot        *udqp, *gdqp;
         uint                    resblks;
 
@@ -1978,9 +1979,9 @@ xfs_symlink(
 
         udqp = gdqp = NULL;
         if (dp->i_d.di_flags & XFS_DIFLAG_PROJINHERIT)
-                prid = dp->i_d.di_projid;
+                prid = xfs_get_projid(dp);
         else
-                prid = (xfs_prid_t)dfltprid;
+                prid = XFS_PROJID_DEFAULT;
 
         /*
          * Make sure that we have allocated dquot(s) on disk.
@@ -2046,8 +2047,8 @@ xfs_symlink(
         /*
          * Allocate an inode for the symlink.
          */
-        error = xfs_dir_ialloc(&tp, dp, S_IFLNK | (mode & ~S_IFMT),
-                               1, 0, credp, prid, resblks > 0, &ip, NULL);
+        error = xfs_dir_ialloc(&tp, dp, S_IFLNK | (mode & ~S_IFMT), 1, 0,
+                               prid, resblks > 0, &ip, NULL);
         if (error) {
                 if (error == ENOSPC)
                         goto error_return;
@@ -2094,9 +2095,8 @@ xfs_symlink(
                                   XFS_BMAPI_WRITE | XFS_BMAPI_METADATA,
                                   &first_block, resblks, mval, &nmaps,
                                   &free_list);
-                if (error) {
-                        goto error1;
-                }
+                if (error)
+                        goto error2;
 
                 if (resblks)
                         resblks -= fs_blocks;
@@ -2128,8 +2128,8 @@ xfs_symlink(
         error = xfs_dir_createname(tp, dp, link_name, ip->i_ino,
                                         &first_block, &free_list, resblks);
         if (error)
-                goto error1;
-        xfs_ichgtime(dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
+                goto error2;
+        xfs_trans_ichgtime(tp, dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
         xfs_trans_log_inode(tp, dp, XFS_ILOG_CORE);
 
         /*
@@ -2141,13 +2141,6 @@ xfs_symlink(
                 xfs_trans_set_sync(tp);
         }
 
-        /*
-         * xfs_trans_commit normally decrements the vnode ref count
-         * when it unlocks the inode. Since we want to return the
-         * vnode to the caller, we bump the vnode ref count now.
-         */
-        IHOLD(ip);
-
         error = xfs_bmap_finish(&tp, &free_list, &committed);
         if (error) {
                 goto error2;
@@ -2272,7 +2265,7 @@ xfs_alloc_file_space(
         count = len;
         imapp = &imaps[0];
         nimaps = 1;
-        bmapi_flag = XFS_BMAPI_WRITE | (alloc_type ? XFS_BMAPI_PREALLOC : 0);
+        bmapi_flag = XFS_BMAPI_WRITE | alloc_type;
         startoffset_fsb = XFS_B_TO_FSBT(mp, offset);
         allocatesize_fsb = XFS_B_TO_FSB(mp, count);
 
@@ -2431,9 +2424,9 @@ xfs_zero_remaining_bytes(
         if (endoff > ip->i_size)
                 endoff = ip->i_size;
 
-        bp = xfs_buf_get_noaddr(mp->m_sb.sb_blocksize,
-                                XFS_IS_REALTIME_INODE(ip) ?
-                                mp->m_rtdev_targp : mp->m_ddev_targp);
+        bp = xfs_buf_get_uncached(XFS_IS_REALTIME_INODE(ip) ?
+                                        mp->m_rtdev_targp : mp->m_ddev_targp,
+                                mp->m_sb.sb_blocksize, XBF_DONT_BLOCK);
         if (!bp)
                 return XFS_ERROR(ENOMEM);
 
@@ -2459,7 +2452,7 @@ xfs_zero_remaining_bytes(
                 XFS_BUF_READ(bp);
                 XFS_BUF_SET_ADDR(bp, xfs_fsb_to_db(ip, imap.br_startblock));
                 xfsbdstrat(mp, bp);
-                error = xfs_iowait(bp);
+                error = xfs_buf_iowait(bp);
                 if (error) {
                         xfs_ioerror_alert("xfs_zero_remaining_bytes(read)",
                                           mp, bp, XFS_BUF_ADDR(bp));
@@ -2472,7 +2465,7 @@ xfs_zero_remaining_bytes(
                 XFS_BUF_UNREAD(bp);
                 XFS_BUF_WRITE(bp);
                 xfsbdstrat(mp, bp);
-                error = xfs_iowait(bp);
+                error = xfs_buf_iowait(bp);
                 if (error) {
                         xfs_ioerror_alert("xfs_zero_remaining_bytes(write)",
                                           mp, bp, XFS_BUF_ADDR(bp));
@@ -2711,6 +2704,7 @@ xfs_change_file_space(
         xfs_off_t       llen;
         xfs_trans_t     *tp;
         struct iattr    iattr;
+        int             prealloc_type;
 
         if (!S_ISREG(ip->i_d.di_mode))
                 return XFS_ERROR(EINVAL);
@@ -2753,12 +2747,17 @@ xfs_change_file_space(
          * size to be changed.
          */
         setprealloc = clrprealloc = 0;
+        prealloc_type = XFS_BMAPI_PREALLOC;
 
         switch (cmd) {
+        case XFS_IOC_ZERO_RANGE:
+                prealloc_type |= XFS_BMAPI_CONVERT;
+                xfs_tosspages(ip, startoffset, startoffset + bf->l_len, 0);
+                /* FALLTHRU */
         case XFS_IOC_RESVSP:
         case XFS_IOC_RESVSP64:
                 error = xfs_alloc_file_space(ip, startoffset, bf->l_len,
-                                                                1, attr_flags);
+                                                prealloc_type, attr_flags);
                 if (error)
                         return error;
                 setprealloc = 1;
@@ -2827,7 +2826,7 @@ xfs_change_file_space(
                 if (ip->i_d.di_mode & S_IXGRP)
                         ip->i_d.di_mode &= ~S_ISGID;
 
-                xfs_ichgtime(ip, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
+                xfs_trans_ichgtime(tp, ip, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
         }
         if (setprealloc)
                 ip->i_d.di_flags |= XFS_DIFLAG_PREALLOC;
@@ -2835,7 +2834,8 @@ xfs_change_file_space(
                 ip->i_d.di_flags &= ~XFS_DIFLAG_PREALLOC;
 
         xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
-        xfs_trans_set_sync(tp);
+        if (attr_flags & XFS_ATTR_SYNC)
+                xfs_trans_set_sync(tp);
 
         error = xfs_trans_commit(tp, 0);