xfs: simplify xfs_truncate_file

xfs_truncate_file is only used for truncating quota files.  Move it to
xfs_qm_syscalls.c so it can be marked static and take advatange of the
fact by removing the unused page cache validation and taking the iget
into the helper.

Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Dave Chinner <dchinner@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>

diff --git a/fs/xfs/quota/xfs_qm_syscalls.c b/fs/xfs/quota/xfs_qm_syscalls.c
index 73f2b203975e4c05dbefd583019dfba2e68a066c..d257eb8557c43a873644ea6481ec5611b9a0051f 100644 (file)
--- a/fs/xfs/quota/xfs_qm_syscalls.c
+++ b/fs/xfs/quota/xfs_qm_syscalls.c
@@ -238,40 +238,74 @@ out_unlock:
        return error;
 }
 
+STATIC int
+xfs_qm_scall_trunc_qfile(
+       struct xfs_mount        *mp,
+       xfs_ino_t               ino)
+{
+       struct xfs_inode        *ip;
+       struct xfs_trans        *tp;
+       int                     error;
+
+       if (ino == NULLFSINO)
+               return 0;
+
+       error = xfs_iget(mp, NULL, ino, 0, 0, &ip);
+       if (error)
+               return error;
+
+       xfs_ilock(ip, XFS_IOLOCK_EXCL);
+
+       tp = xfs_trans_alloc(mp, XFS_TRANS_TRUNCATE_FILE);
+       error = xfs_trans_reserve(tp, 0, XFS_ITRUNCATE_LOG_RES(mp), 0,
+                                 XFS_TRANS_PERM_LOG_RES,
+                                 XFS_ITRUNCATE_LOG_COUNT);
+       if (error) {
+               xfs_trans_cancel(tp, 0);
+               xfs_iunlock(ip, XFS_IOLOCK_EXCL);
+               goto out_put;
+       }
+
+       xfs_ilock(ip, XFS_ILOCK_EXCL);
+       xfs_trans_ijoin(tp, ip);
+
+       error = xfs_itruncate_finish(&tp, ip, 0, XFS_DATA_FORK, 1);
+       if (error) {
+               xfs_trans_cancel(tp, XFS_TRANS_RELEASE_LOG_RES |
+                                    XFS_TRANS_ABORT);
+               goto out_unlock;
+       }
+
+       xfs_ichgtime(ip, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
+       error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
+
+out_unlock:
+       xfs_iunlock(ip, XFS_ILOCK_EXCL | XFS_IOLOCK_EXCL);
+out_put:
+       IRELE(ip);
+       return error;
+}
+
 int
 xfs_qm_scall_trunc_qfiles(
        xfs_mount_t     *mp,
        uint            flags)
 {
        int             error = 0, error2 = 0;
-       xfs_inode_t     *qip;
 
        if (!xfs_sb_version_hasquota(&mp->m_sb) || flags == 0) {
                qdprintk("qtrunc flags=%x m_qflags=%x\n", flags, mp->m_qflags);
                return XFS_ERROR(EINVAL);
        }
 
-       if ((flags & XFS_DQ_USER) && mp->m_sb.sb_uquotino != NULLFSINO) {
-               error = xfs_iget(mp, NULL, mp->m_sb.sb_uquotino, 0, 0, &qip);
-               if (!error) {
-                       error = xfs_truncate_file(mp, qip);
-                       IRELE(qip);
-               }
-       }
-
-       if ((flags & (XFS_DQ_GROUP|XFS_DQ_PROJ)) &&
-           mp->m_sb.sb_gquotino != NULLFSINO) {
-               error2 = xfs_iget(mp, NULL, mp->m_sb.sb_gquotino, 0, 0, &qip);
-               if (!error2) {
-                       error2 = xfs_truncate_file(mp, qip);
-                       IRELE(qip);
-               }
-       }
+       if (flags & XFS_DQ_USER)
+               error = xfs_qm_scall_trunc_qfile(mp, mp->m_sb.sb_uquotino);
+       if (flags & (XFS_DQ_GROUP|XFS_DQ_PROJ))
+               error2 = xfs_qm_scall_trunc_qfile(mp, mp->m_sb.sb_gquotino);
 
        return error ? error : error2;
 }
 
-
 /*
  * Switch on (a given) quota enforcement for a filesystem.  This takes
  * effect immediately.

diff --git a/fs/xfs/xfs_utils.c b/fs/xfs/xfs_utils.c
index 102ce4898ab7709ed88648f7c05b5e8a1c41fac0..b7d5769d2df04a6d5599fec813ce59693275c701 100644 (file)
--- a/fs/xfs/xfs_utils.c
+++ b/fs/xfs/xfs_utils.c
@@ -320,86 +320,3 @@ xfs_bumplink(
        xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
        return 0;
 }
-
-/*
- * Try to truncate the given file to 0 length.  Currently called
- * only out of xfs_remove when it has to truncate a file to free
- * up space for the remove to proceed.
- */
-int
-xfs_truncate_file(
-       xfs_mount_t     *mp,
-       xfs_inode_t     *ip)
-{
-       xfs_trans_t     *tp;
-       int             error;
-
-#ifdef QUOTADEBUG
-       /*
-        * This is called to truncate the quotainodes too.
-        */
-       if (XFS_IS_UQUOTA_ON(mp)) {
-               if (ip->i_ino != mp->m_sb.sb_uquotino)
-                       ASSERT(ip->i_udquot);
-       }
-       if (XFS_IS_OQUOTA_ON(mp)) {
-               if (ip->i_ino != mp->m_sb.sb_gquotino)
-                       ASSERT(ip->i_gdquot);
-       }
-#endif
-       /*
-        * Make the call to xfs_itruncate_start before starting the
-        * transaction, because we cannot make the call while we're
-        * in a transaction.
-        */
-       xfs_ilock(ip, XFS_IOLOCK_EXCL);
-       error = xfs_itruncate_start(ip, XFS_ITRUNC_DEFINITE, (xfs_fsize_t)0);
-       if (error) {
-               xfs_iunlock(ip, XFS_IOLOCK_EXCL);
-               return error;
-       }
-
-       tp = xfs_trans_alloc(mp, XFS_TRANS_TRUNCATE_FILE);
-       if ((error = xfs_trans_reserve(tp, 0, XFS_ITRUNCATE_LOG_RES(mp), 0,
-                                     XFS_TRANS_PERM_LOG_RES,
-                                     XFS_ITRUNCATE_LOG_COUNT))) {
-               xfs_trans_cancel(tp, 0);
-               xfs_iunlock(ip, XFS_IOLOCK_EXCL);
-               return error;
-       }
-
-       /*
-        * Follow the normal truncate locking protocol.  Since we
-        * hold the inode in the transaction, we know that its number
-        * of references will stay constant.
-        */
-       xfs_ilock(ip, XFS_ILOCK_EXCL);
-       xfs_trans_ijoin(tp, ip);
-
-       /*
-        * Signal a sync xaction.  The only case where that isn't
-        * the case is if we're truncating an already unlinked file
-        * on a wsync fs.  In that case, we know the blocks can't
-        * reappear in the file because the links to file are
-        * permanently toast.  Currently, we're always going to
-        * want a sync transaction because this code is being
-        * called from places where nlink is guaranteed to be 1
-        * but I'm leaving the tests in to protect against future
-        * changes -- rcc.
-        */
-       error = xfs_itruncate_finish(&tp, ip, (xfs_fsize_t)0,
-                                    XFS_DATA_FORK,
-                                    ((ip->i_d.di_nlink != 0 ||
-                                      !(mp->m_flags & XFS_MOUNT_WSYNC))
-                                     ? 1 : 0));
-       if (error) {
-               xfs_trans_cancel(tp, XFS_TRANS_RELEASE_LOG_RES |
-                                XFS_TRANS_ABORT);
-       } else {
-               xfs_ichgtime(ip, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
-               error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
-       }
-       xfs_iunlock(ip, XFS_ILOCK_EXCL | XFS_IOLOCK_EXCL);
-
-       return error;
-}

diff --git a/fs/xfs/xfs_utils.h b/fs/xfs/xfs_utils.h
index ef321225d2698cfa2f5982d24099388d0cdae0eb..f55b9678264f0edc8edb23b9aff16bab44b8f355 100644 (file)
--- a/fs/xfs/xfs_utils.h
+++ b/fs/xfs/xfs_utils.h
@@ -18,7 +18,6 @@
 #ifndef __XFS_UTILS_H__
 #define __XFS_UTILS_H__
 
-extern int xfs_truncate_file(xfs_mount_t *, xfs_inode_t *);
 extern int xfs_dir_ialloc(xfs_trans_t **, xfs_inode_t *, mode_t, xfs_nlink_t,
                                xfs_dev_t, cred_t *, prid_t, int,
                                xfs_inode_t **, int *);