[XFS] Prevent free space oversubscription and xfssyncd looping.

[safe/jmp/linux-2.6] / fs / xfs / xfs_fsops.c

diff --git a/fs/xfs/xfs_fsops.c b/fs/xfs/xfs_fsops.c
index d1236d6..c064e72 100644 (file)
--- a/fs/xfs/xfs_fsops.c
+++ b/fs/xfs/xfs_fsops.c
@@ -24,14 +24,12 @@
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
-#include "xfs_dir.h"
 #include "xfs_dir2.h"
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
 #include "xfs_bmap_btree.h"
 #include "xfs_alloc_btree.h"
 #include "xfs_ialloc_btree.h"
-#include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
 #include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
@@ -462,8 +460,9 @@ xfs_fs_counts(
 {
        unsigned long   s;
 
+       xfs_icsb_sync_counters_lazy(mp);
        s = XFS_SB_LOCK(mp);
-       cnt->freedata = mp->m_sb.sb_fdblocks;
+       cnt->freedata = mp->m_sb.sb_fdblocks - XFS_ALLOC_SET_ASIDE(mp);
        cnt->freertx = mp->m_sb.sb_frextents;
        cnt->freeino = mp->m_sb.sb_ifree;
        cnt->allocino = mp->m_sb.sb_icount;
@@ -476,7 +475,7 @@ xfs_fs_counts(
  *
  * xfs_reserve_blocks is called to set m_resblks
  * in the in-core mount table. The number of unused reserved blocks
- * is kept in m_resbls_avail.
+ * is kept in m_resblks_avail.
  *
  * Reserve the requested number of blocks if available. Otherwise return
  * as many as possible to satisfy the request. The actual number
@@ -501,7 +500,7 @@ xfs_reserve_blocks(
        if (inval == (__uint64_t *)NULL) {
                outval->resblks = mp->m_resblks;
                outval->resblks_avail = mp->m_resblks_avail;
-               return(0);
+               return 0;
        }
 
        request = *inval;
@@ -520,15 +519,19 @@ xfs_reserve_blocks(
                }
                mp->m_resblks = request;
        } else {
+               __int64_t       free;
+
+               free =  mp->m_sb.sb_fdblocks - XFS_ALLOC_SET_ASIDE(mp);
                delta = request - mp->m_resblks;
-               lcounter = mp->m_sb.sb_fdblocks - delta;
+               lcounter = free - delta;
                if (lcounter < 0) {
                        /* We can't satisfy the request, just get what we can */
-                       mp->m_resblks += mp->m_sb.sb_fdblocks;
-                       mp->m_resblks_avail += mp->m_sb.sb_fdblocks;
-                       mp->m_sb.sb_fdblocks = 0;
+                       mp->m_resblks += free;
+                       mp->m_resblks_avail += free;
+                       mp->m_sb.sb_fdblocks = XFS_ALLOC_SET_ASIDE(mp);
                } else {
-                       mp->m_sb.sb_fdblocks = lcounter;
+                       mp->m_sb.sb_fdblocks =
+                               lcounter + XFS_ALLOC_SET_ASIDE(mp);
                        mp->m_resblks = request;
                        mp->m_resblks_avail += delta;
                }
@@ -537,7 +540,32 @@ xfs_reserve_blocks(
        outval->resblks = mp->m_resblks;
        outval->resblks_avail = mp->m_resblks_avail;
        XFS_SB_UNLOCK(mp, s);
-       return(0);
+       return 0;
+}
+
+void
+xfs_fs_log_dummy(
+       xfs_mount_t     *mp)
+{
+       xfs_trans_t     *tp;
+       xfs_inode_t     *ip;
+
+       tp = _xfs_trans_alloc(mp, XFS_TRANS_DUMMY1);
+       if (xfs_trans_reserve(tp, 0, XFS_ICHANGE_LOG_RES(mp), 0, 0, 0)) {
+               xfs_trans_cancel(tp, 0);
+               return;
+       }
+
+       ip = mp->m_rootip;
+       xfs_ilock(ip, XFS_ILOCK_EXCL);
+
+       xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
+       xfs_trans_ihold(tp, ip);
+       xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
+       xfs_trans_set_sync(tp);
+       xfs_trans_commit(tp, 0, NULL);
+
+       xfs_iunlock(ip, XFS_ILOCK_EXCL);
 }
 
 int
@@ -547,21 +575,22 @@ xfs_fs_goingdown(
 {
        switch (inflags) {
        case XFS_FSOP_GOING_FLAGS_DEFAULT: {
-               struct vfs *vfsp = XFS_MTOVFS(mp);
+               struct bhv_vfs *vfsp = XFS_MTOVFS(mp);
                struct super_block *sb = freeze_bdev(vfsp->vfs_super->s_bdev);
 
                if (sb && !IS_ERR(sb)) {
-                       xfs_force_shutdown(mp, XFS_FORCE_UMOUNT);
+                       xfs_force_shutdown(mp, SHUTDOWN_FORCE_UMOUNT);
                        thaw_bdev(sb->s_bdev, sb);
                }
        
                break;
        }
        case XFS_FSOP_GOING_FLAGS_LOGFLUSH:
-               xfs_force_shutdown(mp, XFS_FORCE_UMOUNT);
+               xfs_force_shutdown(mp, SHUTDOWN_FORCE_UMOUNT);
                break;
        case XFS_FSOP_GOING_FLAGS_NOLOGFLUSH:
-               xfs_force_shutdown(mp, XFS_FORCE_UMOUNT|XFS_LOG_IO_ERROR);
+               xfs_force_shutdown(mp,
+                               SHUTDOWN_FORCE_UMOUNT | SHUTDOWN_LOG_IO_ERROR);
                break;
        default:
                return XFS_ERROR(EINVAL);