xfs: use generic percpu counters for free block counter

XFS has hand-rolled per-cpu counters for the superblock since before
there was any generic implementation. The free block counter is
special in that it is used for ENOSPC detection outside transaction
contexts for for delayed allocation. This means that the counter
needs to be accurate at zero. The current per-cpu counter code jumps
through lots of hoops to ensure we never run past zero, but we don't
need to make all those jumps with the generic counter
implementation.

The generic counter implementation allows us to pass a "batch"
threshold at which the addition/subtraction to the counter value
will be folded back into global value under lock. We can use this
feature to reduce the batch size as we approach 0 in a very similar
manner to the existing counters and their rebalance algorithm. If we
use a batch size of 1 as we approach 0, then every addition and
subtraction will be done against the global value and hence allow
accurate detection of zero threshold crossing.

Hence we can replace the handrolled, accurate-at-zero counters with
generic percpu counters.

Note: this removes just enough of the icsb infrastructure to compile
without warnings. The rest will go in subsequent commits.

Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>

2 files changed, 14 insertions, 19 deletions

diff --git a/fs/xfs/libxfs/xfs_bmap.c b/fs/xfs/libxfs/xfs_bmap.c
index 61ec015dca16..e39c9e83670e 100644
--- a/fs/xfs/libxfs/xfs_bmap.c
+++ b/fs/xfs/libxfs/xfs_bmap.c
@@ -2212,9 +2212,8 @@ xfs_bmap_add_extent_delay_real(
                 diff = (int)(temp + temp2 - startblockval(PREV.br_startblock) -
                         (bma->cur ? bma->cur->bc_private.b.allocated : 0));
                 if (diff > 0) {
-                        error = xfs_icsb_modify_counters(bma->ip->i_mount,
-                                        XFS_SBS_FDBLOCKS,
-                                        -((int64_t)diff), 0);
+                        error = xfs_mod_fdblocks(bma->ip->i_mount,
+                                                 -((int64_t)diff), false);
                         ASSERT(!error);
                         if (error)
                                 goto done;
@@ -2265,9 +2264,8 @@ xfs_bmap_add_extent_delay_real(
                         temp += bma->cur->bc_private.b.allocated;
                 ASSERT(temp <= da_old);
                 if (temp < da_old)
-                        xfs_icsb_modify_counters(bma->ip->i_mount,
-                                        XFS_SBS_FDBLOCKS,
-                                        (int64_t)(da_old - temp), 0);
+                        xfs_mod_fdblocks(bma->ip->i_mount,
+                                        (int64_t)(da_old - temp), false);
         }
 
         /* clear out the allocated field, done with it now in any case. */
@@ -2944,8 +2942,8 @@ xfs_bmap_add_extent_hole_delay(
         }
         if (oldlen != newlen) {
                 ASSERT(oldlen > newlen);
-                xfs_icsb_modify_counters(ip->i_mount, XFS_SBS_FDBLOCKS,
-                        (int64_t)(oldlen - newlen), 0);
+                xfs_mod_fdblocks(ip->i_mount, (int64_t)(oldlen - newlen),
+                                 false);
                 /*
                  * Nothing to do for disk quota accounting here.
                  */
@@ -4163,15 +4161,13 @@ xfs_bmapi_reserve_delalloc(
                 error = xfs_mod_incore_sb(mp, XFS_SBS_FREXTENTS,
                                           -((int64_t)extsz), 0);
         } else {
-                error = xfs_icsb_modify_counters(mp, XFS_SBS_FDBLOCKS,
-                                                 -((int64_t)alen), 0);
+                error = xfs_mod_fdblocks(mp, -((int64_t)alen), false);
         }
 
         if (error)
                 goto out_unreserve_quota;
 
-        error = xfs_icsb_modify_counters(mp, XFS_SBS_FDBLOCKS,
-                                         -((int64_t)indlen), 0);
+        error = xfs_mod_fdblocks(mp, -((int64_t)indlen), false);
         if (error)
                 goto out_unreserve_blocks;
 
@@ -4200,7 +4196,7 @@ out_unreserve_blocks:
         if (rt)
                 xfs_mod_incore_sb(mp, XFS_SBS_FREXTENTS, extsz, 0);
         else
-                xfs_icsb_modify_counters(mp, XFS_SBS_FDBLOCKS, alen, 0);
+                xfs_mod_fdblocks(mp, alen, false);
 out_unreserve_quota:
         if (XFS_IS_QUOTA_ON(mp))
                 xfs_trans_unreserve_quota_nblks(NULL, ip, (long)alen, 0, rt ?
@@ -5012,10 +5008,8 @@ xfs_bmap_del_extent(
          * Nothing to do for disk quota accounting here.
          */
         ASSERT(da_old >= da_new);
-        if (da_old > da_new) {
-                xfs_icsb_modify_counters(mp, XFS_SBS_FDBLOCKS,
-                        (int64_t)(da_old - da_new), 0);
-        }
+        if (da_old > da_new)
+                xfs_mod_fdblocks(mp, (int64_t)(da_old - da_new), false);
 done:
         *logflagsp = flags;
         return error;
@@ -5290,8 +5284,8 @@ xfs_bunmapi(
                                         ip, -((long)del.br_blockcount), 0,
                                         XFS_QMOPT_RES_RTBLKS);
                         } else {
-                                xfs_icsb_modify_counters(mp, XFS_SBS_FDBLOCKS,
-                                                (int64_t)del.br_blockcount, 0);
+                                xfs_mod_fdblocks(mp, (int64_t)del.br_blockcount,
+                                                 false);
                                 (void)xfs_trans_reserve_quota_nblks(NULL,
                                         ip, -((long)del.br_blockcount), 0,
                                         XFS_QMOPT_RES_REGBLKS);
diff --git a/fs/xfs/libxfs/xfs_sb.c b/fs/xfs/libxfs/xfs_sb.c
index b66aeab99cfb..31a3e972f86f 100644
--- a/fs/xfs/libxfs/xfs_sb.c
+++ b/fs/xfs/libxfs/xfs_sb.c
@@ -773,6 +773,7 @@ xfs_log_sb(
 
         mp->m_sb.sb_icount = percpu_counter_sum(&mp->m_icount);
         mp->m_sb.sb_ifree = percpu_counter_sum(&mp->m_ifree);
+        mp->m_sb.sb_fdblocks = percpu_counter_sum(&mp->m_fdblocks);
 
         xfs_sb_to_disk(XFS_BUF_TO_SBP(bp), &mp->m_sb);
         xfs_trans_buf_set_type(tp, bp, XFS_BLFT_SB_BUF);