Merge branch 'master' of /pub/scm/linux/kernel/git/torvalds/linux-2.6

1 files changed, 40 insertions, 43 deletions

diff --git a/fs/xfs/xfs_mount.c b/fs/xfs/xfs_mount.c
index 2fec452afbcc..da3988453b71 100644
--- a/fs/xfs/xfs_mount.c
+++ b/fs/xfs/xfs_mount.c
@@ -54,8 +54,9 @@ STATIC void	xfs_unmountfs_wait(xfs_mount_t *);
 #ifdef HAVE_PERCPU_SB
 STATIC void     xfs_icsb_destroy_counters(xfs_mount_t *);
 STATIC void     xfs_icsb_balance_counter(xfs_mount_t *, xfs_sb_field_t,
-                                                int, int);
-STATIC void     xfs_icsb_sync_counters(xfs_mount_t *);
+                                                int);
+STATIC void     xfs_icsb_balance_counter_locked(xfs_mount_t *, xfs_sb_field_t,
+                                                int);
 STATIC int      xfs_icsb_modify_counters(xfs_mount_t *, xfs_sb_field_t,
                                                 int64_t, int);
 STATIC void     xfs_icsb_disable_counter(xfs_mount_t *, xfs_sb_field_t);
@@ -63,8 +64,8 @@ STATIC void	xfs_icsb_disable_counter(xfs_mount_t *, xfs_sb_field_t);
 #else
 
 #define xfs_icsb_destroy_counters(mp)                   do { } while (0)
-#define xfs_icsb_balance_counter(mp, a, b, c)           do { } while (0)
-#define xfs_icsb_sync_counters(mp)                      do { } while (0)
+#define xfs_icsb_balance_counter(mp, a, b)              do { } while (0)
+#define xfs_icsb_balance_counter_locked(mp, a, b)       do { } while (0)
 #define xfs_icsb_modify_counters(mp, a, b, c)           do { } while (0)
 
 #endif
@@ -1400,7 +1401,7 @@ xfs_log_sbcount(
         if (!xfs_fs_writable(mp))
                 return 0;
 
-        xfs_icsb_sync_counters(mp);
+        xfs_icsb_sync_counters(mp, 0);
 
         /*
          * we don't need to do this if we are updating the superblock
@@ -2026,9 +2027,9 @@ xfs_icsb_cpu_notify(
         case CPU_ONLINE:
         case CPU_ONLINE_FROZEN:
                 xfs_icsb_lock(mp);
-                xfs_icsb_balance_counter(mp, XFS_SBS_ICOUNT, 0, 0);
-                xfs_icsb_balance_counter(mp, XFS_SBS_IFREE, 0, 0);
-                xfs_icsb_balance_counter(mp, XFS_SBS_FDBLOCKS, 0, 0);
+                xfs_icsb_balance_counter(mp, XFS_SBS_ICOUNT, 0);
+                xfs_icsb_balance_counter(mp, XFS_SBS_IFREE, 0);
+                xfs_icsb_balance_counter(mp, XFS_SBS_FDBLOCKS, 0);
                 xfs_icsb_unlock(mp);
                 break;
         case CPU_DEAD:
@@ -2048,12 +2049,9 @@ xfs_icsb_cpu_notify(
 
                 memset(cntp, 0, sizeof(xfs_icsb_cnts_t));
 
-                xfs_icsb_balance_counter(mp, XFS_SBS_ICOUNT,
-                                         XFS_ICSB_SB_LOCKED, 0);
-                xfs_icsb_balance_counter(mp, XFS_SBS_IFREE,
-                                         XFS_ICSB_SB_LOCKED, 0);
-                xfs_icsb_balance_counter(mp, XFS_SBS_FDBLOCKS,
-                                         XFS_ICSB_SB_LOCKED, 0);
+                xfs_icsb_balance_counter_locked(mp, XFS_SBS_ICOUNT, 0);
+                xfs_icsb_balance_counter_locked(mp, XFS_SBS_IFREE, 0);
+                xfs_icsb_balance_counter_locked(mp, XFS_SBS_FDBLOCKS, 0);
                 spin_unlock(&mp->m_sb_lock);
                 xfs_icsb_unlock(mp);
                 break;
@@ -2105,9 +2103,9 @@ xfs_icsb_reinit_counters(
          * initial balance kicks us off correctly
          */
         mp->m_icsb_counters = -1;
-        xfs_icsb_balance_counter(mp, XFS_SBS_ICOUNT, 0, 0);
-        xfs_icsb_balance_counter(mp, XFS_SBS_IFREE, 0, 0);
-        xfs_icsb_balance_counter(mp, XFS_SBS_FDBLOCKS, 0, 0);
+        xfs_icsb_balance_counter(mp, XFS_SBS_ICOUNT, 0);
+        xfs_icsb_balance_counter(mp, XFS_SBS_IFREE, 0);
+        xfs_icsb_balance_counter(mp, XFS_SBS_FDBLOCKS, 0);
         xfs_icsb_unlock(mp);
 }
 
@@ -2223,7 +2221,7 @@ xfs_icsb_disable_counter(
         if (!test_and_set_bit(field, &mp->m_icsb_counters)) {
                 /* drain back to superblock */
 
-                xfs_icsb_count(mp, &cnt, XFS_ICSB_SB_LOCKED|XFS_ICSB_LAZY_COUNT);
+                xfs_icsb_count(mp, &cnt, XFS_ICSB_LAZY_COUNT);
                 switch(field) {
                 case XFS_SBS_ICOUNT:
                         mp->m_sb.sb_icount = cnt.icsb_icount;
@@ -2278,38 +2276,33 @@ xfs_icsb_enable_counter(
 }
 
 void
-xfs_icsb_sync_counters_flags(
+xfs_icsb_sync_counters_locked(
         xfs_mount_t     *mp,
         int             flags)
 {
         xfs_icsb_cnts_t cnt;
 
-        /* Pass 1: lock all counters */
-        if ((flags & XFS_ICSB_SB_LOCKED) == 0)
-                spin_lock(&mp->m_sb_lock);
-
         xfs_icsb_count(mp, &cnt, flags);
 
-        /* Step 3: update mp->m_sb fields */
         if (!xfs_icsb_counter_disabled(mp, XFS_SBS_ICOUNT))
                 mp->m_sb.sb_icount = cnt.icsb_icount;
         if (!xfs_icsb_counter_disabled(mp, XFS_SBS_IFREE))
                 mp->m_sb.sb_ifree = cnt.icsb_ifree;
         if (!xfs_icsb_counter_disabled(mp, XFS_SBS_FDBLOCKS))
                 mp->m_sb.sb_fdblocks = cnt.icsb_fdblocks;
-
-        if ((flags & XFS_ICSB_SB_LOCKED) == 0)
-                spin_unlock(&mp->m_sb_lock);
 }
 
 /*
  * Accurate update of per-cpu counters to incore superblock
  */
-STATIC void
+void
 xfs_icsb_sync_counters(
-        xfs_mount_t     *mp)
+        xfs_mount_t     *mp,
+        int             flags)
 {
-        xfs_icsb_sync_counters_flags(mp, 0);
+        spin_lock(&mp->m_sb_lock);
+        xfs_icsb_sync_counters_locked(mp, flags);
+        spin_unlock(&mp->m_sb_lock);
 }
 
 /*
@@ -2332,19 +2325,15 @@ xfs_icsb_sync_counters(
 #define XFS_ICSB_FDBLK_CNTR_REENABLE(mp) \
                 (uint64_t)(512 + XFS_ALLOC_SET_ASIDE(mp))
 STATIC void
-xfs_icsb_balance_counter(
+xfs_icsb_balance_counter_locked(
         xfs_mount_t     *mp,
         xfs_sb_field_t  field,
-        int             flags,
         int             min_per_cpu)
 {
         uint64_t        count, resid;
         int             weight = num_online_cpus();
         uint64_t        min = (uint64_t)min_per_cpu;
 
-        if (!(flags & XFS_ICSB_SB_LOCKED))
-                spin_lock(&mp->m_sb_lock);
-
         /* disable counter and sync counter */
         xfs_icsb_disable_counter(mp, field);
 
@@ -2354,19 +2343,19 @@ xfs_icsb_balance_counter(
                 count = mp->m_sb.sb_icount;
                 resid = do_div(count, weight);
                 if (count < max(min, XFS_ICSB_INO_CNTR_REENABLE))
-                        goto out;
+                        return;
                 break;
         case XFS_SBS_IFREE:
                 count = mp->m_sb.sb_ifree;
                 resid = do_div(count, weight);
                 if (count < max(min, XFS_ICSB_INO_CNTR_REENABLE))
-                        goto out;
+                        return;
                 break;
         case XFS_SBS_FDBLOCKS:
                 count = mp->m_sb.sb_fdblocks;
                 resid = do_div(count, weight);
                 if (count < max(min, XFS_ICSB_FDBLK_CNTR_REENABLE(mp)))
-                        goto out;
+                        return;
                 break;
         default:
                 BUG();
@@ -2375,9 +2364,17 @@ xfs_icsb_balance_counter(
         }
 
         xfs_icsb_enable_counter(mp, field, count, resid);
-out:
-        if (!(flags & XFS_ICSB_SB_LOCKED))
-                spin_unlock(&mp->m_sb_lock);
+}
+
+STATIC void
+xfs_icsb_balance_counter(
+        xfs_mount_t     *mp,
+        xfs_sb_field_t  fields,
+        int             min_per_cpu)
+{
+        spin_lock(&mp->m_sb_lock);
+        xfs_icsb_balance_counter_locked(mp, fields, min_per_cpu);
+        spin_unlock(&mp->m_sb_lock);
 }
 
 STATIC int
@@ -2484,7 +2481,7 @@ slow_path:
          * we are done.
          */
         if (ret != ENOSPC)
-                xfs_icsb_balance_counter(mp, field, 0, 0);
+                xfs_icsb_balance_counter(mp, field, 0);
         xfs_icsb_unlock(mp);
         return ret;
 
@@ -2508,7 +2505,7 @@ balance_counter:
          * will either succeed through the fast path or slow path without
          * another balance operation being required.
          */
-        xfs_icsb_balance_counter(mp, field, 0, delta);
+        xfs_icsb_balance_counter(mp, field, delta);
         xfs_icsb_unlock(mp);
         goto again;
 }