Use generic percpu counters in XFS V2
Subsystems (3)
cover Use generic percpu counters in XFS V2
This series replaces the XFS per-cpu superblock counters with generic per-cpu counters. It adds a specialised operation to the generic counter implementation and then switches the XFS percpu superblock counters over to use the generic percpu counter implementation. The result is several hundred lines of complex code removed from XFS.
Version 2:
- use wrappers for percpu_counter_add_unless_lt() to allow custom batch sizes to be used.
- removed xfs_icsb_*() wrappers from percpu counters.
- cleaned up split of xfs_icsb_modify_counters().
_______________________________________________
xfs mailing list
[email protected]
http://oss.sgi.com/mailman/listinfo/xfs
PATCH 1/3 lib: percpu counter add unless less than functionality
From: Dave Chinner <[email protected]>
To use the generic percpu counter infrastructure for counters that require conditional addition based on a threshold value we need special handling of the counter. Further, the caller needs to know the status of the conditional addition to determine what action to take depending on whether the addition occurred or not. Examples of this sort of usage are resource counters that cannot go below zero (e.g. filesystem free blocks).
To allow XFS to replace it's complex roll-your-own per-cpu superblock counters, a single generic conditional function is
required: percpu_counter_add_unless_lt(). This will add the amount to the counter unless the result would be less than the given threshold. A caller supplied threshold is required because XFS does not necessarily use the same threshold for every counter.
percpu_counter_add_unless_lt() attempts to minimise counter lock traversals by only taking the counter lock when the threshold is within the error range of the current counter value. Hence when the threshold is not within the counter error range, the counter will still have the same scalability characteristics as the normal percpu_counter_add() function.
Adding this functionality to the generic percpu counters allows us to remove the much more complex and less efficient XFS percpu counter code (~700 lines of code) and replace it with generic percpu counters.
--- include/linux/percpu_counter.h | 27 ++++++++++++++ lib/percpu_counter.c | 79 ++++++++++++++++++++++++++++++++++++++++ 2 files changed, 106 insertions(+), 0 deletions(-)
include/linux/percpu_counter.h +27 -0
@@ -41,12 +41,21 @@ void percpu_counter_set(struct percpu_counter *fbc, s64 amount);void __percpu_counter_add (struct percpu_counter *fbc,s64 amount,s32 batch);s64 __percpu_counter_sum (struct percpu_counter *fbc);int percpu_counter_compare (struct percpu_counter *fbc,s64 rhs); +int __percpu_counter_add_unless_lt (struct percpu_counter *fbc,s64 amount, +s64 threshold,s32 batch);static inline void percpu_counter_add (struct percpu_counter *fbc,s64 amount) {__percpu_counter_add (fbc, amount, percpu_counter_batch); } +static inline int percpu_counter_add_unless_lt (struct percpu_counter *fbc, +s64 amount,s64 threshold) +{ +return __percpu_counter_add_unless_lt (fbc, amount, threshold, + percpu_counter_batch); +} +static inline s64 percpu_counter_sum_positive (struct percpu_counter *fbc) {s64 ret =__percpu_counter_sum (fbc);
@@ -153,6 +162,24 @@ static inline int percpu_counter_initialized(struct percpu_counter *fbc)return 1 ; } +static inline int percpu_counter_add_unless_lt (struct percpu_counter *fbc,s64 amount, +s64 threshold) +{ +s64 count; + int ret = ‐1; + +preempt_disable (); + count = fbc->count + amount; +if (count < threshold) + goto out; + fbc->count = count; + ret = count == threshold ?0 :1 ; +out: +preempt_enable (); +return ret; +} + +#endif /* CONFIG_SMP */ static inline void percpu_counter_inc (struct percpu_counter *fbc)
lib/percpu_counter.c +79 -0
85 lines not on this page · raw message
Signature · 6 lines
1.7.2.3 _______________________________________________ xfs mailing list [email protected] http://oss.sgi.com/mailman/listinfo/xfs
PATCH 2/3 xfs: use generic per-cpu counter infrastructure
In reply to Dave ChinnerFrom: Dave Chinner <[email protected]>
XFS has a per-cpu counter implementation for in-core superblock counters that pre-dated the generic implementation. It is complex and baroque as it is tailored directly to the needs of ENOSPC detection.
Now that the generic percpu counter infrastructure has the percpu_counter_add_unless_lt() function that implements the necessary threshold checks for us, switch the XFS per-cpu superblock counters to use the generic percpu counter infrastructure.
--- fs/xfs/linux-2.6/xfs_linux.h | 9 - fs/xfs/linux-2.6/xfs_super.c | 4 +- fs/xfs/xfs_fsops.c | 4 +- fs/xfs/xfs_mount.c | 802 ++++++++---------------------------------- fs/xfs/xfs_mount.h | 71 +--- 5 files changed, 171 insertions(+), 719 deletions(-)
fs/xfs/linux-2.6/xfs_linux.h +0 -9
@@ -88,15 +88,6 @@#include <xfs_super.h> #include <xfs_buf.h> -/* -* Feature macros (disable/enable) -*/ -#ifdef CONFIG_SMP -#define HAVE_PERCPU_SB /* per cpu superblock counters are a 2.6 feature */ -#else -#undef HAVE_PERCPU_SB/* per cpu superblock counters are a 2.6 feature */ -#endif -#define irix_sgid_inherit xfs_params.sgid_inherit.val#define irix_symlink_mode xfs_params.symlink_mode.val#define xfs_panic_mask xfs_params.panic_mask.val
fs/xfs/linux-2.6/xfs_super.c +2 -2
@@ -1229,9 +1229,9 @@ xfs_fs_statfs( statp->f_fsid.val[0 ] = (u32 )id; statp->f_fsid.val[1 ] = (u32)(id >>32 ); -xfs_icsb_sync_counters (mp,XFS_ICSB_LAZY_COUNT ); -spin_lock (&mp->m_sb_lock); +xfs_icsb_sync_counters (mp); + statp->f_bsize = sbp->sb_blocksize; lsize = sbp->sb_logstart ? sbp->sb_logblocks :0 ; statp->f_blocks = sbp->sb_dblocks - lsize;
fs/xfs/xfs_fsops.c +2 -2
@@ -478,8 +478,8 @@ xfs_fs_counts( xfs_mount_t *mp, xfs_fsop_counts_t *cnt) { -xfs_icsb_sync_counters (mp,XFS_ICSB_LAZY_COUNT );spin_lock (&mp->m_sb_lock); +xfs_icsb_sync_counters (mp); 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;
@@ -540,7 +540,7 @@ xfs_reserve_blocks(*/ retry:spin_lock (&mp->m_sb_lock); -xfs_icsb_sync_counters_locked (mp,0 ); +xfs_icsb_sync_counters (mp);/* * If our previous reservation was larger than the current value,
fs/xfs/xfs_mount.c +154 -648
848 lines not on this page · raw message
fs/xfs/xfs_mount.h +13 -58
107 lines not on this page · raw message
Signature · 6 lines
1.7.2.3 _______________________________________________ xfs mailing list [email protected] http://oss.sgi.com/mailman/listinfo/xfs
Re: [PATCH 2/3] xfs: use generic per-cpu counter infrastructure
Quoted 7 lines · Dave Chinner
From: Dave Chinner <[email protected]>
XFS has a per-cpu counter implementation for in-core superblock counters that pre-dated the generic implementation. It is complex and baroque as it is tailored directly to the needs of ENOSPC detection.
Quoted 7 lines
Now that the generic percpu counter infrastructure has the
percpu_counter_add_unless_lt()function that implements the necessary threshold checks for us, switch the XFS per-cpu superblock counters to use the generic percpu counter infrastructure.Signed-off-by Dave Chinner <[email protected]>
Looks good to me,
A little nipick:
fs/xfs/xfs_mount.c xfs_mod_incore_sb( · line 1851
Quoted 3 lines
fs/xfs/xfs_mount.c +0
-2-#ifdef HAVE_PERCPU_SB ASSERT (field <XFS_SBS_ICOUNT || field >XFS_SBS_FDBLOCKS ); -#endif
No need to keep this assert - xfs_mod_incore_sb_unlocked already has one for unknown fields.
_______________________________________________
xfs mailing list
[email protected]
http://oss.sgi.com/mailman/listinfo/xfs
PATCH 3/3 xfs: demultiplex xfs_icsb_modify_counters()
In reply to Dave ChinnerFrom: Dave Chinner <[email protected]>
With the conversion to percpu counters, xfs_icsb_modify_counters() really does not need to exist. Convert the inode counter modifications to use a common helper function for the one place that calls them, and add another function for the free block modification and convert all the callers to use that.
--- fs/xfs/xfs_bmap.c | 34 +++++------- fs/xfs/xfs_fsops.c | 3 +- fs/xfs/xfs_mount.c | 160 ++++++++++++++++++++++++--------------------------- fs/xfs/xfs_mount.h | 5 +- fs/xfs/xfs_trans.c | 23 +++---- 5 files changed, 102 insertions(+), 123 deletions(-)
fs/xfs/xfs_bmap.c +14 -20
@@ -614,8 +614,8 @@ xfs_bmap_add_extent( nblks += cur->bc_private.b.allocated;ASSERT (nblks <= da_old);if (nblks < da_old) -xfs_icsb_modify_counters (ip->i_mount,XFS_SBS_FDBLOCKS , - (int64_t )(da_old - nblks), rsvd); +xfs_icsb_modify_free_blocks (ip->i_mount, + (int64_t )(da_old - nblks), rsvd); }/* * Clear out the allocated field, done with it now in any case.
@@ -1079,7 +1079,7 @@ xfs_bmap_add_extent_delay_real( diff = (int )(temp + temp2 -startblockval (PREV .br_startblock) - (cur ? cur->bc_private.b.allocated :0 ));if (diff >0 && -xfs_icsb_modify_counters (ip->i_mount,XFS_SBS_FDBLOCKS , +xfs_icsb_modify_free_blocks (ip->i_mount, -((int64_t )diff), rsvd)) {/* * Ick gross gag me with a spoon.
@@ -1090,8 +1090,7 @@ xfs_bmap_add_extent_delay_real( temp--; diff--;if (!diff || - !xfs_icsb_modify_counters (ip->i_mount, -XFS_SBS_FDBLOCKS , + !xfs_icsb_modify_free_blocks (ip->i_mount, -((int64_t )diff), rsvd))break ; }
@@ -1099,8 +1098,7 @@ xfs_bmap_add_extent_delay_real( temp2--; diff--;if (!diff || - !xfs_icsb_modify_counters (ip->i_mount, -XFS_SBS_FDBLOCKS , + !xfs_icsb_modify_free_blocks (ip->i_mount, -((int64_t )diff), rsvd))break ; }
@@ -1769,8 +1767,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), rsvd); +xfs_icsb_modify_free_blocks (ip->i_mount, + (int64_t )(oldlen - newlen), rsvd);/* * Nothing to do for disk quota accounting here. */
@@ -3114,10 +3112,9 @@ 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), rsvd); - } +if (da_old > da_new) +xfs_icsb_modify_free_blocks (ip->i_mount, + (int64_t )(da_old - da_new), rsvd); done: *logflagsp = flags;return error;
@@ -4530,14 +4527,12 @@ xfs_bmapi( -((int64_t )extsz), (flags & XFS_BMAPI_RSVBLOCKS)); }else { - error =xfs_icsb_modify_counters (mp, -XFS_SBS_FDBLOCKS , + error =xfs_icsb_modify_free_blocks (mp, -((int64_t )alen), (flags &XFS_BMAPI_RSVBLOCKS )); }if (!error) { - error =xfs_icsb_modify_counters (mp, -XFS_SBS_FDBLOCKS , + error =xfs_icsb_modify_free_blocks (mp, -((int64_t )indlen), (flags &XFS_BMAPI_RSVBLOCKS ));if (error && rt)
@@ -4546,8 +4541,7 @@ xfs_bmapi( (int64_t )extsz, (flags & XFS_BMAPI_RSVBLOCKS)); else if (error) - xfs_icsb_modify_counters(mp, - XFS_SBS_FDBLOCKS, + xfs_icsb_modify_free_blocks(mp, (int64_t)alen, (flags & XFS_BMAPI_RSVBLOCKS)); }
@@ -5210,7 +5204,7 @@ xfs_bunmapi( ip, -((long )del.br_blockcount),0 , XFS_QMOPT_RES_RTBLKS); }else { -xfs_icsb_modify_counters (mp,XFS_SBS_FDBLOCKS , +xfs_icsb_modify_free_blocks (mp, (int64_t )del.br_blockcount, rsvd); (void)xfs_trans_reserve_quota_nblks(NULL, ip, -((long)del.br_blockcount), 0,
fs/xfs/xfs_fsops.c +1 -2
@@ -596,8 +596,7 @@ out:* the extra reserve blocks from the reserve..... */ int error; - error =xfs_icsb_modify_counters (mp,XFS_SBS_FDBLOCKS , - fdblks_delta,0 ); + error =xfs_icsb_modify_free_blocks (mp, fdblks_delta,0 );if (error ==ENOSPC ) goto retry; }
fs/xfs/xfs_mount.c +75 -85
178 lines not on this page · raw message
fs/xfs/xfs_mount.h +2 -3
@@ -75,9 +75,6 @@ enum { XFS_ICSB_MAX, }; -extern int xfs_icsb_modify_counters (struct xfs_mount *,xfs_sb_field_t , -int64_t ,int ); - typedef struct xfs_mount { struct super_block *m_super; xfs_tid_t m_tid; /* next unused tid for fs */
@@ -333,6 +330,8 @@ extern int xfs_icsb_init_counters(struct xfs_mount *);extern void xfs_icsb_reinit_counters (struct xfs_mount *);extern void xfs_icsb_destroy_counters (struct xfs_mount *);extern void xfs_icsb_sync_counters (struct xfs_mount *); +extern int xfs_icsb_modify_inodes (struct xfs_mount *,int ,int64_t ); +extern int xfs_icsb_modify_free_blocks (struct xfs_mount *,int64_t ,int );#endif /* __KERNEL__ */
fs/xfs/xfs_trans.c +10 -13
@@ -696,7 +696,7 @@ xfs_trans_reserve(* fail if the count would go below zero. */ if (blocks >0 ) { - error =xfs_icsb_modify_counters (tp->t_mountp,XFS_SBS_FDBLOCKS , + error =xfs_icsb_modify_free_blocks (tp->t_mountp, -((int64_t )blocks), rsvd);if (error !=0 ) {current_restore_flags_nested (&tp->t_pflags,PF_FSTRANS );
@@ -767,8 +767,8 @@ undo_log: undo_blocks:if (blocks >0 ) { -xfs_icsb_modify_counters (tp->t_mountp,XFS_SBS_FDBLOCKS , - (int64_t )blocks, rsvd); +xfs_icsb_modify_free_blocks (tp->t_mountp, + (int64_t )blocks, rsvd); tp->t_blk_res =0 ; }
@@ -1045,22 +1045,19 @@ xfs_trans_unreserve_and_mod_sb(/* apply the per-cpu counters */ if (blkdelta) { - error =xfs_icsb_modify_counters (mp,XFS_SBS_FDBLOCKS , - blkdelta, rsvd); + error =xfs_icsb_modify_free_blocks (mp, blkdelta, rsvd);if (error) goto out; }if (idelta) { - error =xfs_icsb_modify_counters (mp,XFS_SBS_ICOUNT , - idelta, rsvd); + error =xfs_icsb_modify_inodes (mp,XFS_ICSB_ICOUNT , idelta);if (error) goto out_undo_fdblocks; }if (ifreedelta) { - error =xfs_icsb_modify_counters (mp,XFS_SBS_IFREE , - ifreedelta, rsvd); + error =xfs_icsb_modify_inodes (mp,XFS_ICSB_IFREE , ifreedelta);if (error) goto out_undo_icount; }
@@ -1129,15 +1126,15 @@ xfs_trans_unreserve_and_mod_sb( out_undo_ifreecount:if (ifreedelta) -xfs_icsb_modify_counters (mp,XFS_SBS_IFREE , -ifreedelta, rsvd); +xfs_icsb_modify_inodes (mp,XFS_ICSB_IFREE , -ifreedelta); out_undo_icount:if (idelta) -xfs_icsb_modify_counters (mp,XFS_SBS_ICOUNT , -idelta, rsvd); +xfs_icsb_modify_inodes (mp,XFS_ICSB_ICOUNT , -idelta); out_undo_fdblocks:if (blkdelta) -xfs_icsb_modify_counters (mp,XFS_SBS_FDBLOCKS , -blkdelta, rsvd); +xfs_icsb_modify_free_blocks (mp, -blkdelta, rsvd); out: -ASSERT (error =0 ); +ASSERT (error ==0 );return ; }
Signature · 6 lines
1.7.2.3 _______________________________________________ xfs mailing list [email protected] http://oss.sgi.com/mailman/listinfo/xfs
Re: [PATCH 3/3] xfs: demultiplex xfs_icsb_modify_counters()
Quoted 6 lines · Dave Chinner
From: Dave Chinner <[email protected]>
With the conversion to percpu counters,
xfs_icsb_modify_counters()really does not need to exist. Convert the inode counter modifications to use a common helper function for the one place that calls them, and add another function for the free block modification and convert all the callers to use that.
Looks good,
_______________________________________________
xfs mailing list
[email protected]
http://oss.sgi.com/mailman/listinfo/xfs