xfs: use generic percpu counters for icsb
cover xfs: use generic percpu counters for icsb
Hi folks,
After listening to Eric swear about the per-cpu counter implementation we have for the in-core superblock all week, I decided the best thing to do woul dbe to simply replace them with generic per-cpu counters. The current icsb counters were implemented long before we had generic counter infrastructure, and it's remained that way because if it ain't broke....
Anyway, we do have a couple of issues with the counters to do with enforcing the maximum inode count on small filesystems. Fixing these problems is what Eric spend time swearing about.
Anyway, to cut a long story short, there is nothing unique about the inode counters - neither the allocated inode count nor the free inode count need to be accurate at zero as they are not used for ENOSPC enforcement at this limit, and the allocated inode count doesn't need to be perfectly accurate at the maximum count, either. Hence we can just replace them with generic per-cpu coutners without second thoughts.
The free block counter is a little different. We need to be able to accurately determine zero free blocks due to ENOSPC detection requirements, and this is where all the complexity came from in the existing infrastructure. The key technique that the existing infrastructure uses to be accurate at zero is that it goes back to a global lock and serialisation as it approaches zero. hence we trade off scalability for accuracy at ENOSPC.
It turns out we can play the same trick with the generic per-cpu counter infrastructure. They allow a customised "batch" value, which is the threshold at which the local per-cpu counter is folded back into the global counter. By setting this batch to 1 we effectively serialise all modifications to the counter as any change will be over the batch fold threshold. Hence we can add a simple check on the global counter value and switch from large batch values to small values as we approach the zero threshold.
This patchset has passed xfstests with no regressions, and there are no performance impacts measurable on my 16p test VM on inode allocation/freeing intensive workloads, nor on delayed allocation workloads (which reserve a block at a time and hence trigger extremely frequent updates) at IO rates of over 1GB/s. it also fixes the maxicount enforcement issue on small filesystems that started this off...
SGI: this is a change that you are going to want to test for regressions on one of your large machines that has multiple GB/s of IO bandwidth. I don't expect there to be any problems, but if there are we might need to tweak batch thresholds based on CPU count......
This patchset is based on for-next, as it is dependent on the superblock logging changes that are already queued for the next cycle. Diffstat is as follows:
fs/xfs/libxfs/xfs_bmap.c | 16 +- fs/xfs/libxfs/xfs_format.h | 96 +------ fs/xfs/libxfs/xfs_ialloc.c | 6 +- fs/xfs/libxfs/xfs_sb.c | 43 +-- fs/xfs/xfs_fsops.c | 16 +- fs/xfs/xfs_iomap.c | 3 +- fs/xfs/xfs_linux.h | 9 - fs/xfs/xfs_log_recover.c | 5 +- fs/xfs/xfs_mount.c | 730 ++++++----------------------------------------- fs/xfs/xfs_mount.h | 67 +---- fs/xfs/xfs_rtalloc.c | 6 +- fs/xfs/xfs_super.c | 101 +++++-- fs/xfs/xfs_super.h | 83 ++++++ fs/xfs/xfs_trans.c | 19 +- 14 files changed, 309 insertions(+), 891 deletions(-)
Comments, thoughts?
-Dave.
_______________________________________________
xfs mailing list
[email protected]
http://oss.sgi.com/mailman/listinfo/xfs
PATCH 1/5 xfs: struct xfs_sb is no longer tied to the on-disk format
From: Dave Chinner <[email protected]>
With the removal of the bitfield based superblock logging code, the in-core struct xfs_sb is no longer tied to the on-disk format. That means it can be moved out of xfs_format.h and into a kernel specific header. This allows the in-core superblock change size, shape and structure to suit the requirements of the in-memory processing rather than be constrained by the on-disk layout.
--- fs/xfs/libxfs/xfs_format.h | 96 ++-------------------------------------------- fs/xfs/libxfs/xfs_sb.c | 4 +- fs/xfs/xfs_log_recover.c | 2 +- fs/xfs/xfs_mount.c | 18 ++++----- fs/xfs/xfs_mount.h | 2 +- fs/xfs/xfs_rtalloc.c | 6 +-- fs/xfs/xfs_super.c | 6 +-- fs/xfs/xfs_super.h | 81 ++++++++++++++++++++++++++++++++++++++ 8 files changed, 103 insertions(+), 112 deletions(-)
fs/xfs/libxfs/xfs_format.h +3 -93
@@ -91,98 +91,7 @@ struct xfs_ifork; XFS_SB_VERSION2_FTYPE)/* -* Superblock - in core version. Must match the ondisk version below. -* Must be padded to 64 bit alignment. -*/ -typedef struct xfs_sb { -__uint32_t sb_magicnum;/* magic number == XFS_SB_MAGIC */ -__uint32_t sb_blocksize;/* logical block size, bytes */ -xfs_rfsblock_t sb_dblocks;/* number of data blocks */ -xfs_rfsblock_t sb_rblocks;/* number of realtime blocks */ -xfs_rtblock_t sb_rextents;/* number of realtime extents */ -uuid_t sb_uuid;/* file system unique id */ -xfs_fsblock_t sb_logstart;/* starting block of log if internal */ -xfs_ino_t sb_rootino;/* root inode number */ -xfs_ino_t sb_rbmino;/* bitmap inode for realtime extents */ -xfs_ino_t sb_rsumino;/* summary inode for rt bitmap */ -xfs_agblock_t sb_rextsize;/* realtime extent size, blocks */ -xfs_agblock_t sb_agblocks;/* size of an allocation group */ -xfs_agnumber_t sb_agcount;/* number of allocation groups */ -xfs_extlen_t sb_rbmblocks;/* number of rt bitmap blocks */ -xfs_extlen_t sb_logblocks;/* number of log blocks */ -__uint16_t sb_versionnum;/* header version == XFS_SB_VERSION */ -__uint16_t sb_sectsize;/* volume sector size, bytes */ -__uint16_t sb_inodesize;/* inode size, bytes */ -__uint16_t sb_inopblock;/* inodes per block */ -char sb_fname[12 ];/* file system name */ -__uint8_t sb_blocklog;/* log2 of sb_blocksize */ -__uint8_t sb_sectlog;/* log2 of sb_sectsize */ -__uint8_t sb_inodelog;/* log2 of sb_inodesize */ -__uint8_t sb_inopblog;/* log2 of sb_inopblock */ -__uint8_t sb_agblklog;/* log2 of sb_agblocks (rounded up) */ -__uint8_t sb_rextslog;/* log2 of sb_rextents */ -__uint8_t sb_inprogress;/* mkfs is in progress, don't mount */ -__uint8_t sb_imax_pct;/* max % of fs for inode space */ -/* statistics */ -/* -* These fields must remain contiguous. If you really -* want to change their layout, make sure you fix the -* code in xfs_trans_apply_sb_deltas(). -*/ -__uint64_t sb_icount;/* allocated inodes */ -__uint64_t sb_ifree;/* free inodes */ -__uint64_t sb_fdblocks;/* free data blocks */ -__uint64_t sb_frextents;/* free realtime extents */ -/* -* End contiguous fields. -*/ -xfs_ino_t sb_uquotino;/* user quota inode */ -xfs_ino_t sb_gquotino;/* group quota inode */ -__uint16_t sb_qflags;/* quota flags */ -__uint8_t sb_flags;/* misc. flags */ -__uint8_t sb_shared_vn;/* shared version number */ -xfs_extlen_t sb_inoalignmt;/* inode chunk alignment, fsblocks */ -__uint32_t sb_unit;/* stripe or raid unit */ -__uint32_t sb_width;/* stripe or raid width */ -__uint8_t sb_dirblklog;/* log2 of dir block size (fsbs) */ -__uint8_t sb_logsectlog;/* log2 of the log sector size */ -__uint16_t sb_logsectsize;/* sector size for the log, bytes */ -__uint32_t sb_logsunit;/* stripe unit size for the log */ -__uint32_t sb_features2;/* additional feature bits */ - -/* -* bad features2 field as a result of failing to pad the sb structure to -* 64 bits. Some machines will be using this field for features2 bits. -* Easiest just to mark it bad and not use it for anything else. -* -* This is not kept up to date in memory; it is always overwritten by -* the value in sb_features2 when formatting the incore superblock to -* the disk buffer. -*/ -__uint32_t sb_bad_features2; - -/* version 5 superblock fields start here */ - -/* feature masks */ -__uint32_t sb_features_compat; -__uint32_t sb_features_ro_compat; -__uint32_t sb_features_incompat; -__uint32_t sb_features_log_incompat; - -__uint32_t sb_crc;/* superblock crc */ -__uint32_t sb_pad; - -xfs_ino_t sb_pquotino;/* project quota inode */ -xfs_lsn_t sb_lsn;/* last write sequence */ - -/* must be padded to 64 bit alignment */ -}xfs_sb_t ; - -#define XFS_SB_CRC_OFF offsetof(struct xfs_sb, sb_crc) - -/* -* Superblock - on disk version. Must match the in core version above. -* Must be padded to 64 bit alignment. +* Superblock - on disk version. Must be padded to 64 bit alignment. */ typedef struct xfs_dsb { __be32 sb_magicnum; /* magic number == XFS_SB_MAGIC */
@@ -255,6 +164,7 @@ typedef struct xfs_dsb {__be32 sb_features_incompat;__be32 sb_features_log_incompat; +#define XFS_SB_CRC_OFF offsetof(struct xfs_dsb, sb_crc)__le32 sb_crc;/* superblock crc */ __be32 sb_pad;
@@ -562,7 +472,7 @@ static inline int xfs_sb_version_hasftype(struct xfs_sb *sbp) (sbp->sb_features2 & XFS_SB_VERSION2_FTYPE)); } -static inline int xfs_sb_version_hasfinobt (xfs_sb_t *sbp) +static inline int xfs_sb_version_hasfinobt (struct xfs_sb *sbp) {return (XFS_SB_VERSION_NUM (sbp) ==XFS_SB_VERSION_5 ) && (sbp->sb_features_ro_compat &XFS_SB_FEAT_RO_COMPAT_FINOBT );
fs/xfs/libxfs/xfs_sb.c +2 -2
@@ -107,7 +107,7 @@ xfs_perag_put( STATIC intxfs_mount_validate_sb (xfs_mount_t *mp, -xfs_sb_t *sbp, +struct xfs_sb *sbp,bool check_inprogress,bool check_version) {
@@ -714,7 +714,7 @@ xfs_initialize_perag_data( {xfs_agnumber_t index;xfs_perag_t *pag; -xfs_sb_t *sbp = &mp->m_sb; +struct xfs_sb *sbp = &mp->m_sb;uint64_t ifree =0 ;uint64_t ialloc =0 ;uint64_t bfree =0 ;
fs/xfs/xfs_log_recover.c +1 -1
@@ -4410,7 +4410,7 @@ xlog_do_recover( {int error;xfs_buf_t *bp; -xfs_sb_t *sbp; +struct xfs_sb *sbp;/* * First replay the images in the log.
fs/xfs/xfs_mount.c +9 -9
@@ -166,7 +166,7 @@ xfs_free_perag(*/ int xfs_sb_validate_fsb_count ( -xfs_sb_t *sbp, +struct xfs_sb *sbp,__uint64_t nblocks) {ASSERT (PAGE_SHIFT >= sbp->sb_blocklog);
@@ -189,7 +189,7 @@ xfs_initialize_perag(xfs_perag_t *pag;xfs_agino_t agino;xfs_ino_t ino; -xfs_sb_t *sbp = &mp->m_sb; +struct xfs_sb *sbp = &mp->m_sb;int error = -ENOMEM ;/*
@@ -368,7 +368,7 @@ release_buf: STATIC intxfs_update_alignment (xfs_mount_t *mp) { -xfs_sb_t *sbp = &(mp->m_sb); +struct xfs_sb *sbp = &(mp->m_sb);if (mp->m_dalign) {/*
@@ -434,7 +434,7 @@ xfs_update_alignment(xfs_mount_t *mp) STATIC voidxfs_set_maxicount (xfs_mount_t *mp) { -xfs_sb_t *sbp = &(mp->m_sb); +struct xfs_sb *sbp = &(mp->m_sb);__uint64_t icount;if (sbp->sb_imax_pct) {
@@ -461,7 +461,7 @@ xfs_set_maxicount(xfs_mount_t *mp) STATIC voidxfs_set_rw_sizes (xfs_mount_t *mp) { -xfs_sb_t *sbp = &(mp->m_sb); +struct xfs_sb *sbp = &(mp->m_sb);int readio_log, writeio_log;if (!(mp->m_flags &XFS_MOUNT_DFLT_IOSIZE )) {
@@ -630,7 +630,7 @@ intxfs_mountfs ( xfs_mount_t *mp) { -xfs_sb_t *sbp = &(mp->m_sb); +struct xfs_sb *sbp = &(mp->m_sb);xfs_inode_t *rip;__uint64_t resblks;uint quotamount =0 ;
@@ -642,9 +642,9 @@ xfs_mountfs(/* * Check for a mismatched features2 values. Older kernels read & wrote * into the wrong sb offset for sb_features2 on some platforms due to -* xfs_sb_t not being 64bit size aligned when sb_features2 was added, -* which made older superblock reading/writing routines swap it as a -* 64-bit value. +* struct xfs_sb not being 64bit size aligned when sb_features2 was +* added, which made older superblock reading/writing routines swap it +* as a 64-bit value. * * For backwards compatibility, we make both slots equal. *
fs/xfs/xfs_mount.h +1 -1
@@ -81,7 +81,7 @@ typedef struct xfs_mount {struct super_block *m_super;xfs_tid_t m_tid;/* next unused tid for fs */ struct xfs_ail *m_ail;/* fs active log item list */ -xfs_sb_t m_sb;/* copy of fs superblock */ +struct xfs_sb m_sb;/* copy of fs superblock */ spinlock_t m_sb_lock;/* sb counter lock */ struct xfs_buf *m_sb_bp;/* buffer for superblock */ char *m_fsname;/* filesystem name */
fs/xfs/xfs_rtalloc.c +3 -3
@@ -897,10 +897,10 @@ xfs_growfs_rt(xfs_extlen_t nrsumblocks;/* new number of summary blocks */ uint nrsumlevels;/* new rt summary levels */ uint nrsumsize;/* new size of rt summary, bytes */ -xfs_sb_t *nsbp;/* new superblock */ +struct xfs_sb *nsbp;/* new superblock */ xfs_extlen_t rbmblocks;/* current number of rt bitmap blocks */ xfs_extlen_t rsumblocks;/* current number of rt summary blks */ -xfs_sb_t *sbp;/* old superblock */ +struct xfs_sb *sbp;/* old superblock */ xfs_fsblock_t sumbno;/* summary block number */ sbp = &mp->m_sb;
@@ -1227,7 +1227,7 @@ xfs_rtmount_inodes( xfs_mount_t *mp) /* file system mount structure */ {int error;/* error return value */ -xfs_sb_t *sbp; +struct xfs_sb *sbp; sbp = &mp->m_sb;if (sbp->sb_rbmino ==NULLFSINO )
fs/xfs/xfs_super.c +3 -3
@@ -602,7 +602,7 @@ xfs_set_inode32(struct xfs_mount *mp, xfs_agnumber_t agcount) {xfs_agnumber_t index =0 ;xfs_agnumber_t maxagi =0 ; -xfs_sb_t *sbp = &mp->m_sb; +struct xfs_sb *sbp = &mp->m_sb;xfs_agnumber_t max_metadata;xfs_agino_t agino;xfs_ino_t ino;
@@ -1084,7 +1084,7 @@ xfs_fs_statfs( struct kstatfs *statp) {struct xfs_mount *mp =XFS_M (dentry->d_sb); -xfs_sb_t *sbp = &mp->m_sb; +struct xfs_sb *sbp = &mp->m_sb;struct xfs_inode *ip =XFS_I (dentry->d_inode);__uint64_t fakeinos, id;xfs_extlen_t lsize;
@@ -1198,7 +1198,7 @@ xfs_fs_remount( char *options) {struct xfs_mount *mp =XFS_M (sb); -xfs_sb_t *sbp = &mp->m_sb; +struct xfs_sb *sbp = &mp->m_sb;substring_t args[MAX_OPT_ARGS ];char *p;int error;
fs/xfs/xfs_super.h +81 -0
87 lines not on this page · raw message
Signature · 6 lines
2.0.0 _______________________________________________ xfs mailing list [email protected] http://oss.sgi.com/mailman/listinfo/xfs
Re: [PATCH 1/5] xfs: struct xfs_sb is no longer tied to the on-disk format
fs/xfs/libxfs/xfs_format.h struct xfs_ifork;
Quoted 10 lines
/*
- * Superblock - in core version. Must match the ondisk version below.
- * Must be padded to 64 bit alignment.
- */fs/xfs/libxfs/xfs_format.h +1
-4-typedef struct xfs_sb { - __uint32_t sb_magicnum; /* magic number == XFS_SB_MAGIC */ - __uint32_t sb_blocksize; /* logical block size, bytes */ -static inline int xfs_sb_version_hasfinobt(xfs_sb_t *sbp) +static inline int xfs_sb_version_hasfinobt (struct xfs_sb *sbp)
So xfs_format.h now requires struct xfs_sb to be defined before it can be included? I guess we need to move these macros around as well.
Quoted 5 lines
fs/xfs/xfs_super.h +0
-0
fs/xfs/xfs_super.h struct xfs_mount; · line 69
Quoted 9 lines
fs/xfs/xfs_super.h +6
-0@@ -61,6 +61,87 @@ struct xfs_mount;struct xfs_buftarg ;struct block_device ; +/* +* Superblock - in core version. This does not have ot match the size and shape +* of the on-disk superblock, but must contain all the fields that we use in the +* on-disk superblock. +*/ +struct xfs_sb {
Is this really the right header? xfs_super.h only really is for bits related to linux super block operastions.
I'd expect to move it close to stuct xfs_mount, and maybe even merge it into that in the long run.
_______________________________________________
xfs mailing list
[email protected]
http://oss.sgi.com/mailman/listinfo/xfs
Re: [PATCH 1/5] xfs: struct xfs_sb is no longer tied to the on-disk format
Quoted 8 lines · Christoph Hellwig
Quoted 7 lines
/*
- * Superblock - in core version. Must match the ondisk version below.
- * Must be padded to 64 bit alignment.
- */fs/xfs/libxfs/xfs_format.h +0
-3-typedef struct xfs_sb { - __uint32_t sb_magicnum; /* magic number == XFS_SB_MAGIC */ - __uint32_t sb_blocksize; /* logical block size, bytes */
Quoted 5 lines
fs/xfs/libxfs/xfs_format.h static inline int xfs_sb_version_hasftype(struct xfs_sb *sbp) · line 475
Quoted 2 lines
fs/xfs/libxfs/xfs_format.h +1
-1-static inline int xfs_sb_version_hasfinobt (xfs_sb_t *sbp) +static inline int xfs_sb_version_hasfinobt (struct xfs_sb *sbp)So
xfs_format.hnow requires structxfs_sbto be defined before it can be included? I guess we need to move these macros around as well.
Yes, that's why I moved it to xfs_super.h, which is included from xfs_linux.h. I just wanted to move it from xfs_format.h to /somewhere/ to demonstrate that it isn't part of the on-disk format anymore.
Quoted 8 lines
Quoted 8 lines
fs/xfs/xfs_super.h +0
-0@@ -61,6 +61,87 @@ struct xfs_mount;struct xfs_buftarg ;struct block_device ;
Quoted 9 lines
fs/xfs/xfs_super.h struct xfs_mount; · line 69
Quoted 6 lines
fs/xfs/xfs_super.h +6
-0+/* +* Superblock - in core version. This does not have ot match the size and shape +* of the on-disk superblock, but must contain all the fields that we use in the +* on-disk superblock. +*/ +struct xfs_sb {Is this really the right header?
xfs_super.honly really is for bits related to linux super block operastions.
No, probably not, but it was expedient and good enough for an RFC and sanity testing. I thought about xfs_mount.h, but then realised that just introduces a new dependency between xfs_mount.h and libxfs, which is something I'm trying to reduce.
Quoted 2 lines
I'd expect to move it close to stuct
xfs_mount, and maybe even merge it into that in the long run.
I guess moving the structure there is fine, but we still want all the version functions to be shared with userspace, which then makes for an interesting set of dependencies. Any other ideas?
Cheers,
Dave.
Signature · 7 lines
Dave Chinner [email protected] _______________________________________________ xfs mailing list [email protected] http://oss.sgi.com/mailman/listinfo/xfs
Re: [PATCH 1/5] xfs: struct xfs_sb is no longer tied to the on-disk format
Quoted 6 lines · Dave Chinner
Quoted 2 lines
I'd expect to move it close to stuct
xfs_mount, and maybe even merge it into that in the long run.I guess moving the structure there is fine, but we still want all the version functions to be shared with userspace, which then makes for an interesting set of dependencies. Any other ideas?
Are they really worth the sharing? If they are worth it we'll need somethign that can expect a xfs_sb/xfs_mount to be defined.
_______________________________________________
xfs mailing list
[email protected]
http://oss.sgi.com/mailman/listinfo/xfs
Re: [PATCH 1/5] xfs: struct xfs_sb is no longer tied to the on-disk format
Quoted 10 lines · Christoph Hellwig
Quoted 6 lines · Dave Chinner
Quoted 2 lines
I'd expect to move it close to stuct
xfs_mount, and maybe even merge it into that in the long run.I guess moving the structure there is fine, but we still want all the version functions to be shared with userspace, which then makes for an interesting set of dependencies. Any other ideas?
Are they really worth the sharing? If they are worth it we'll need somethign that can expect a xfs_sb/xfs_mount to be defined.
I suppose we could stop sharing them - they change rarely enough and it's only a few lines of code for each new feature that would then need to be duplicated. Not a huge burden...
Cheers,
Dave.
Signature · 7 lines
Dave Chinner [email protected] _______________________________________________ xfs mailing list [email protected] http://oss.sgi.com/mailman/listinfo/xfs
Re: [PATCH 1/5] xfs: struct xfs_sb is no longer tied to the on-disk format
Quoted 9 lines · Dave Chinner
Quoted 8 lines · Christoph Hellwig
Quoted 6 lines · Dave Chinner
Quoted 2 lines
I'd expect to move it close to stuct
xfs_mount, and maybe even merge it into that in the long run.I guess moving the structure there is fine, but we still want all the version functions to be shared with userspace, which then makes for an interesting set of dependencies. Any other ideas?
Quoted 6 lines
Quoted 2 lines
Are they really worth the sharing? If they are worth it we'll need somethign that can expect a xfs_sb/xfs_mount to be defined.
I suppose we could stop sharing them - they change rarely enough and it's only a few lines of code for each new feature that would then need to be duplicated. Not a huge burden...
Just a further thought on this - I might keep the per-cpu counters in the struct mount. That way the to/from disk code only needs to sum/set the per-cpu counter values to/from the m_sb as they currently do and so the xfs_sb can remain unchanged for the moment.
That might be a cleaner way to start this patchset, especially as we already have the per-cpu counter hooks in all the places we need them.
Cheers,
Dave.
Signature · 7 lines
Dave Chinner [email protected] _______________________________________________ xfs mailing list [email protected] http://oss.sgi.com/mailman/listinfo/xfs
PATCH 2/5 xfs: use generic percpu counters for inode counter
In reply to Dave ChinnerXFS has hand-rolled per-cpu counters for the superblock since before there was any generic implementation. There are some warts around the use of them for the inode counter as the hand rolled counter is designed to be accurate at zero, but has no specific accurracy at any other value. This design causes problems for the maximum inode count threshold enforcement, as there is no trigger that balances the counters as they get close tothe maximum threshold.
Instead of designing new triggers for balancing, just replace the handrolled per-cpu counter with a generic counter directly in the incore superblock. This enables us to update the counter throught eh normal superblock modification funtions, rather than having to go around them and then fall back to the normal modificaiton functions if the per-cpu nature of the counter has been turned off.
The result is a much simpler counter implementation that can be used accurately across it's entire range of values rather than just near to zero values.
--- fs/xfs/libxfs/xfs_ialloc.c | 6 +++-- fs/xfs/libxfs/xfs_sb.c | 10 +++++--- fs/xfs/xfs_fsops.c | 3 ++- fs/xfs/xfs_mount.c | 58 +++++++++++++++++----------------------------- fs/xfs/xfs_mount.h | 1 - fs/xfs/xfs_super.c | 8 ++++--- fs/xfs/xfs_super.h | 4 +++- fs/xfs/xfs_trans.c | 5 ++-- 8 files changed, 44 insertions(+), 51 deletions(-)
fs/xfs/libxfs/xfs_ialloc.c +4 -2
@@ -376,7 +376,8 @@ xfs_ialloc_ag_alloc(*/ newlen = args.mp->m_ialloc_inos;if (args.mp->m_maxicount && - args.mp->m_sb.sb_icount + newlen > args.mp->m_maxicount) +percpu_counter_read (&args.mp->m_sb.sb_icount) + newlen > + args.mp->m_maxicount)return -ENOSPC ; args.minlen = args.maxlen = args.mp->m_ialloc_blks;/*
@@ -1340,7 +1341,8 @@ xfs_dialloc(* inode. */ if (mp->m_maxicount && - mp->m_sb.sb_icount + mp->m_ialloc_inos > mp->m_maxicount) { +percpu_counter_read (&mp->m_sb.sb_icount) + mp->m_ialloc_inos > + mp->m_maxicount) { noroom =1 ; okalloc =0 ; }
fs/xfs/libxfs/xfs_sb.c +7 -3
@@ -357,7 +357,8 @@ __xfs_sb_from_disk( to->sb_rextslog = from->sb_rextslog; to->sb_inprogress = from->sb_inprogress; to->sb_imax_pct = from->sb_imax_pct; - to->sb_icount =be64_to_cpu (from->sb_icount); +if (percpu_counter_initialized (&to->sb_icount)) +percpu_counter_set (&to->sb_icount,be64_to_cpu (from->sb_icount)); to->sb_ifree =be64_to_cpu (from->sb_ifree); to->sb_fdblocks =be64_to_cpu (from->sb_fdblocks); to->sb_frextents =be64_to_cpu (from->sb_frextents);
@@ -492,7 +493,7 @@ xfs_sb_to_disk( to->sb_rextslog = from->sb_rextslog; to->sb_inprogress = from->sb_inprogress; to->sb_imax_pct = from->sb_imax_pct; - to->sb_icount =cpu_to_be64 (from->sb_icount); + to->sb_icount =cpu_to_be64 (percpu_counter_sum (&from->sb_icount)); to->sb_ifree =cpu_to_be64 (from->sb_ifree); to->sb_fdblocks =cpu_to_be64 (from->sb_fdblocks); to->sb_frextents =cpu_to_be64 (from->sb_frextents);
@@ -537,6 +538,9 @@ xfs_sb_verify(struct xfs_mount *mp = bp->b_target->bt_mount;struct xfs_sb sb; +/* don't need to validate icount here */ + sb.sb_icount.counters =NULL ; +/* * Use call variant which doesn't convert quota flags from disk * format, because xfs_mount_validate_sb checks the on-disk flags.
@@ -748,7 +752,7 @@ xfs_initialize_perag_data(*/ spin_lock (&mp->m_sb_lock); sbp->sb_ifree = ifree; - sbp->sb_icount = ialloc; +percpu_counter_set (&sbp->sb_icount, ialloc); sbp->sb_fdblocks = bfree + bfreelst + btree;spin_unlock (&mp->m_sb_lock);
fs/xfs/xfs_fsops.c +2 -1
@@ -631,11 +631,12 @@ xfs_fs_counts( xfs_fsop_counts_t *cnt) {xfs_icsb_sync_counters (mp,XFS_ICSB_LAZY_COUNT ); + cnt->allocino =percpu_counter_read_positive (&mp->m_sb.sb_icount); +spin_lock (&mp->m_sb_lock); 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;spin_unlock (&mp->m_sb_lock);return 0 ; }
fs/xfs/xfs_mount.c +21 -37
167 lines not on this page · raw message
fs/xfs/xfs_mount.h +0 -1
@@ -41,7 +41,6 @@ struct xfs_da_geometry;typedef struct xfs_icsb_cnts {uint64_t icsb_fdblocks;uint64_t icsb_ifree; -uint64_t icsb_icount;unsigned long icsb_flags; }xfs_icsb_cnts_t ;
fs/xfs/xfs_super.c +5 -3
@@ -1087,6 +1087,7 @@ xfs_fs_statfs(struct xfs_sb *sbp = &mp->m_sb;struct xfs_inode *ip =XFS_I (dentry->d_inode);__uint64_t fakeinos, id; +__uint64_t sb_icount;xfs_extlen_t lsize;__int64_t ffree;
@@ -1098,6 +1099,7 @@ xfs_fs_statfs( statp->f_fsid.val[1 ] = (u32)(id >>32 );xfs_icsb_sync_counters (mp,XFS_ICSB_LAZY_COUNT ); + sb_icount =percpu_counter_sum (&sbp->sb_icount);spin_lock (&mp->m_sb_lock); statp->f_bsize = sbp->sb_blocksize;
@@ -1106,15 +1108,15 @@ xfs_fs_statfs( statp->f_bfree = statp->f_bavail = sbp->sb_fdblocks -XFS_ALLOC_SET_ASIDE (mp); fakeinos = statp->f_bfree << sbp->sb_inopblog; - statp->f_files = -MIN (sbp->sb_icount + fakeinos, (__uint64_t )XFS_MAXINUMBER ); + statp->f_files =MIN (sb_icount + fakeinos, + (__uint64_t )XFS_MAXINUMBER );if (mp->m_maxicount) statp->f_files =min_t (typeof (statp->f_files), statp->f_files, mp->m_maxicount);/* make sure statp->f_ffree does not underflow */ - ffree = statp->f_files - (sbp->sb_icount - sbp->sb_ifree); + ffree = statp->f_files - (sb_icount - sbp->sb_ifree); statp->f_ffree =max_t (__int64_t, ffree,0 );spin_unlock (&mp->m_sb_lock);
fs/xfs/xfs_super.h +3 -1
@@ -96,7 +96,9 @@ struct xfs_sb {__uint8_t sb_inprogress;/* mkfs is in progress, don't mount */ __uint8_t sb_imax_pct;/* max % of fs for inode space */ /* statistics */ -__uint64_t sb_icount;/* allocated inodes */ + +struct percpu_counter sb_icount;/* allocated inodes */ +__uint64_t sb_ifree;/* free inodes */ __uint64_t sb_fdblocks;/* free data blocks */ __uint64_t sb_frextents;/* free realtime extents */
fs/xfs/xfs_trans.c +2 -3
@@ -554,8 +554,7 @@ xfs_trans_unreserve_and_mod_sb( }if (idelta) { - error =xfs_icsb_modify_counters (mp,XFS_SBS_ICOUNT , - idelta, rsvd); + error =xfs_mod_incore_sb (mp,XFS_SBS_ICOUNT , idelta, rsvd);if (error) goto out_undo_fdblocks; }
@@ -634,7 +633,7 @@ out_undo_ifreecount:xfs_icsb_modify_counters (mp,XFS_SBS_IFREE , -ifreedelta, rsvd); out_undo_icount:if (idelta) -xfs_icsb_modify_counters (mp,XFS_SBS_ICOUNT , -idelta, rsvd); +xfs_mod_incore_sb (mp,XFS_SBS_ICOUNT , -idelta, rsvd); out_undo_fdblocks:if (blkdelta)xfs_icsb_modify_counters (mp,XFS_SBS_FDBLOCKS , -blkdelta, rsvd);
Signature · 6 lines
2.0.0 _______________________________________________ xfs mailing list [email protected] http://oss.sgi.com/mailman/listinfo/xfs
Re: [PATCH 2/5] xfs: use generic percpu counters for inode counter
fs/xfs/libxfs/xfs_sb.c __xfs_sb_from_disk( · line 361
Quoted 11 lines
fs/xfs/libxfs/xfs_sb.c +2
-1@@ -357,7 +357,8 @@ __xfs_sb_from_disk( to->sb_rextslog = from->sb_rextslog; to->sb_inprogress = from->sb_inprogress; to->sb_imax_pct = from->sb_imax_pct; - to->sb_icount =be64_to_cpu (from->sb_icount); +if (percpu_counter_initialized (&to->sb_icount)) +percpu_counter_set (&to->sb_icount,be64_to_cpu (from->sb_icount));
Why would the percpu counter not be initialized here? Oh, I guess this is for xfs_sb_verify(). But why can't xfs_mount_validate_sb simply operate on the disk endian SB to avoid that whole issue?
Quoted 19 lines
fs/xfs/xfs_mount.c +4
-0@@ -1127,13 +1127,13 @@ xfs_mod_incore_sb_unlocked(*/ switch (field) {case XFS_SBS_ICOUNT : +/* deltas are +/-64, hence the large batch size of 128. */ +__percpu_counter_add (&mp->m_sb.sb_icount, delta,128 ); +if (percpu_counter_compare (&mp->m_sb.sb_icount,0 ) <0 ) {ASSERT (0 ); +percpu_counter_add (&mp->m_sb.sb_icount, -delta);return -EINVAL ; }return 0 ;case XFS_SBS_IFREE : lcounter = (long long )mp->m_sb.sb_ifree;
fs/xfs/xfs_mount.c xfs_mod_incore_sb( · line 1295
Quoted 9 lines
fs/xfs/xfs_mount.c +4
-1@@ -1288,8 +1288,11 @@ xfs_mod_incore_sb(int status;#ifdef HAVE_PERCPU_SB -ASSERT (field <XFS_SBS_ICOUNT || field >XFS_SBS_FDBLOCKS ); +ASSERT (field <XFS_SBS_IFREE || field >XFS_SBS_FDBLOCKS );#endif +if (field ==XFS_SBS_ICOUNT ) +return xfs_mod_incore_sb_unlocked (mp, field, delta, rsvd); +
Why is this multiplexd through xfs_mod_incore_sb_unlocked while needing a different locking context? Shouldn't we simply use a different helper for this case?
Quoted 5 lines
fs/xfs/xfs_mount.c +2
-0xfs_icsb_cnts_t *cntp;int i; + i =percpu_counter_init (&mp->m_sb.sb_icount,0 ,GFP_KERNEL ); +if (i)
fs/xfs/xfs_mount.c xfs_icsb_init_counters( · line 1545
Quoted 10 lines
fs/xfs/xfs_mount.c +5
-1+return ENOMEM ; + mp->m_sb_cnts =alloc_percpu (xfs_icsb_cnts_t); -if (mp->m_sb_cnts ==NULL ) +if (!mp->m_sb_cnts) { +percpu_counter_destroy (&mp->m_sb.sb_icount);return -ENOMEM ; + }for_each_online_cpu (i) {
Reusing a variable for both an errno value and a loop iterator is not very readable, just add an additional "error" variabe.
Also percpu_counter_init returns a proper egative errno value, no need to turn that into the incorrect postive ENOMEM.
Additionally should this use goto unwining?
fs/xfs/xfs_mount.c
Quoted 4 lines
fs/xfs/xfs_mount.c +1
-2if (idelta) { - error =xfs_icsb_modify_counters (mp,XFS_SBS_ICOUNT , - idelta, rsvd); + error =xfs_mod_incore_sb (mp,XFS_SBS_ICOUNT , idelta, rsvd);
Why go through xfs_mod_incore_sb here instead of directly jumping to the function that does the work?
_______________________________________________
xfs mailing list
[email protected]
http://oss.sgi.com/mailman/listinfo/xfs
Re: [PATCH 2/5] xfs: use generic percpu counters for inode counter
Quoted 7 lines · Christoph Hellwig
Quoted 7 lines
fs/xfs/libxfs/xfs_sb.c +0
-0@@ -357,7 +357,8 @@ __xfs_sb_from_disk( to->sb_rextslog = from->sb_rextslog; to->sb_inprogress = from->sb_inprogress;
Quoted 8 lines
fs/xfs/libxfs/xfs_sb.c __xfs_sb_from_disk( · line 361
Quoted 4 lines
fs/xfs/libxfs/xfs_sb.c +2
-1to->sb_imax_pct = from->sb_imax_pct; - to->sb_icount =be64_to_cpu (from->sb_icount); +if (percpu_counter_initialized (&to->sb_icount)) +percpu_counter_set (&to->sb_icount,be64_to_cpu (from->sb_icount));Why would the percpu counter not be initialized here? Oh, I guess this is for
xfs_sb_verify(). But why can'txfs_mount_validate_sbsimply operate on the disk endian SB to avoid that whole issue?
Possibly. I'll look into it.
Quoted 14 lines
fs/xfs/libxfs/xfs_sb.c xfs_mod_incore_sb( · line 1295
Quoted 10 lines
fs/xfs/libxfs/xfs_sb.c +4
-1@@ -1288,8 +1288,11 @@ xfs_mod_incore_sb(int status;#ifdef HAVE_PERCPU_SB -ASSERT (field <XFS_SBS_ICOUNT || field >XFS_SBS_FDBLOCKS ); +ASSERT (field <XFS_SBS_IFREE || field >XFS_SBS_FDBLOCKS );#endif +if (field ==XFS_SBS_ICOUNT ) +return xfs_mod_incore_sb_unlocked (mp, field, delta, rsvd); +Why is this multiplexd through
xfs_mod_incore_sb_unlockedwhile needing a different locking context? Shouldn't we simply use a different helper for this case?
Again, expedient. To fix, I need to exportxfs_mod_incore_sb_unlocked().
Quoted 14 lines
Quoted 14 lines
fs/xfs/libxfs/xfs_sb.c +7
-1xfs_icsb_cnts_t *cntp;int i; + i =percpu_counter_init (&mp->m_sb.sb_icount,0 ,GFP_KERNEL ); +if (i) +return ENOMEM ; + mp->m_sb_cnts =alloc_percpu (xfs_icsb_cnts_t); -if (mp->m_sb_cnts ==NULL ) +if (!mp->m_sb_cnts) { +percpu_counter_destroy (&mp->m_sb.sb_icount);return -ENOMEM ; + }
Quoted 4 lines
Quoted 1 line
for_each_online_cpu(i){Reusing a variable for both an errno value and a loop iterator is not very readable, just add an additional "error" variabe.
In the end it gets renamed to error. I'll fix it up.
Quoted 2 lines
Also
percpu_counter_initreturns a proper egative errno value, no need to turn that into the incorrect postive ENOMEM.
Oversight. Will fix.
Cheers,
Dave.
Signature · 7 lines
Dave Chinner [email protected] _______________________________________________ xfs mailing list [email protected] http://oss.sgi.com/mailman/listinfo/xfs
Re: [PATCH 2/5] xfs: use generic percpu counters for inode counter
Quoted 5 lines · Dave Chinner
Quoted 3 lines
Why would the percpu counter not be initialized here? Oh, I guess this is for
xfs_sb_verify(). But why can'txfs_mount_validate_sbsimply operate on the disk endian SB to avoid that whole issue?Possibly. I'll look into it.
A simpler alternative would be to move them out of __xfs_sb_from_disk into the one caller that needs these values.
_______________________________________________
xfs mailing list
[email protected]
http://oss.sgi.com/mailman/listinfo/xfs
PATCH 3/5 xfs: use generic percpu counters for free inode counter
In reply to Dave ChinnerFrom: Dave Chinner <[email protected]>
XFS has hand-rolled per-cpu counters for the superblock since before there was any generic implementation. The free inode counter is not used for any limit enforcement - the per-AG free inode counters are used during allocation to determine if there are inode available for allocation.
Hence we don't need any of the complexity of the hand-rolled counters and we can simply replace them with generic per-cpu counters similar to the inode counter.
--- fs/xfs/libxfs/xfs_sb.c | 8 ++++--- fs/xfs/xfs_fsops.c | 2 +- fs/xfs/xfs_mount.c | 62 +++++++++++++++++--------------------------------- fs/xfs/xfs_super.c | 4 +++- fs/xfs/xfs_super.h | 2 +- fs/xfs/xfs_trans.c | 5 ++-- 6 files changed, 33 insertions(+), 50 deletions(-)
fs/xfs/libxfs/xfs_sb.c +5 -3
@@ -359,7 +359,8 @@ __xfs_sb_from_disk( to->sb_imax_pct = from->sb_imax_pct;if (percpu_counter_initialized (&to->sb_icount))percpu_counter_set (&to->sb_icount,be64_to_cpu (from->sb_icount)); - to->sb_ifree =be64_to_cpu (from->sb_ifree); +if (percpu_counter_initialized (&to->sb_icount)) +percpu_counter_set (&to->sb_ifree,be64_to_cpu (from->sb_ifree)); to->sb_fdblocks =be64_to_cpu (from->sb_fdblocks); to->sb_frextents =be64_to_cpu (from->sb_frextents); to->sb_uquotino =be64_to_cpu (from->sb_uquotino);
@@ -494,7 +495,7 @@ xfs_sb_to_disk( to->sb_inprogress = from->sb_inprogress; to->sb_imax_pct = from->sb_imax_pct; to->sb_icount =cpu_to_be64 (percpu_counter_sum (&from->sb_icount)); - to->sb_ifree =cpu_to_be64 (from->sb_ifree); + to->sb_ifree =cpu_to_be64 (percpu_counter_sum (&from->sb_ifree)); to->sb_fdblocks =cpu_to_be64 (from->sb_fdblocks); to->sb_frextents =cpu_to_be64 (from->sb_frextents);
@@ -540,6 +541,7 @@ xfs_sb_verify(/* don't need to validate icount here */ sb.sb_icount.counters =NULL ; + sb.sb_ifree.counters =NULL ;/* * Use call variant which doesn't convert quota flags from disk
@@ -751,7 +753,7 @@ xfs_initialize_perag_data(* Overwrite incore superblock counters with just-read data */ spin_lock (&mp->m_sb_lock); - sbp->sb_ifree = ifree; +percpu_counter_set (&sbp->sb_ifree, ifree);percpu_counter_set (&sbp->sb_icount, ialloc); sbp->sb_fdblocks = bfree + bfreelst + btree;spin_unlock (&mp->m_sb_lock);
fs/xfs/xfs_fsops.c +1 -1
@@ -632,11 +632,11 @@ xfs_fs_counts( {xfs_icsb_sync_counters (mp,XFS_ICSB_LAZY_COUNT ); cnt->allocino =percpu_counter_read_positive (&mp->m_sb.sb_icount); + cnt->freeino =percpu_counter_read_positive (&mp->m_sb.sb_ifree);spin_lock (&mp->m_sb_lock); 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;spin_unlock (&mp->m_sb_lock);return 0 ; }
fs/xfs/xfs_mount.c +21 -41
174 lines not on this page · raw message
fs/xfs/xfs_super.c +3 -1
@@ -1088,6 +1088,7 @@ xfs_fs_statfs(struct xfs_inode *ip =XFS_I (dentry->d_inode);__uint64_t fakeinos, id;__uint64_t sb_icount; +__uint64_t sb_ifree;xfs_extlen_t lsize;__int64_t ffree;
@@ -1100,6 +1101,7 @@ xfs_fs_statfs(xfs_icsb_sync_counters (mp,XFS_ICSB_LAZY_COUNT ); sb_icount =percpu_counter_sum (&sbp->sb_icount); + sb_ifree =percpu_counter_sum (&sbp->sb_ifree);spin_lock (&mp->m_sb_lock); statp->f_bsize = sbp->sb_blocksize;
@@ -1116,7 +1118,7 @@ xfs_fs_statfs( mp->m_maxicount);/* make sure statp->f_ffree does not underflow */ - ffree = statp->f_files - (sb_icount - sbp->sb_ifree); + ffree = statp->f_files - (sb_icount - sb_ifree); statp->f_ffree =max_t (__int64_t, ffree,0 );spin_unlock (&mp->m_sb_lock);
fs/xfs/xfs_super.h +1 -1
@@ -98,8 +98,8 @@ struct xfs_sb {/* statistics */ struct percpu_counter sb_icount;/* allocated inodes */ +struct percpu_counter sb_ifree;/* free inodes */ -__uint64_t sb_ifree;/* free inodes */ __uint64_t sb_fdblocks;/* free data blocks */ __uint64_t sb_frextents;/* free realtime extents */ xfs_ino_t sb_uquotino;/* user quota inode */
fs/xfs/xfs_trans.c +2 -3
@@ -560,8 +560,7 @@ xfs_trans_unreserve_and_mod_sb( }if (ifreedelta) { - error =xfs_icsb_modify_counters (mp,XFS_SBS_IFREE , - ifreedelta, rsvd); + error =xfs_mod_incore_sb (mp,XFS_SBS_IFREE , ifreedelta, rsvd);if (error) goto out_undo_icount; }
@@ -630,7 +629,7 @@ xfs_trans_unreserve_and_mod_sb( out_undo_ifreecount:if (ifreedelta) -xfs_icsb_modify_counters (mp,XFS_SBS_IFREE , -ifreedelta, rsvd); +xfs_mod_incore_sb (mp,XFS_SBS_IFREE , -ifreedelta, rsvd); out_undo_icount:if (idelta)xfs_mod_incore_sb (mp,XFS_SBS_ICOUNT , -idelta, rsvd);
Signature · 6 lines
2.0.0 _______________________________________________ xfs mailing list [email protected] http://oss.sgi.com/mailman/listinfo/xfs
Re: [PATCH 3/5] xfs: use generic percpu counters for free inode counter
Quoted 27 lines · Dave Chinner
From: Dave Chinner <[email protected]>
XFS has hand-rolled per-cpu counters for the superblock since before there was any generic implementation. The free inode counter is not used for any limit enforcement - the per-AG free inode counters are used during allocation to determine if there are inode available for allocation.
Hence we don't need any of the complexity of the hand-rolled counters and we can simply replace them with generic per-cpu counters similar to the inode counter.
Signed-off-by Dave Chinner <[email protected]>--- fs/xfs/libxfs/xfs_sb.c | 8 ++++--- fs/xfs/xfs_fsops.c | 2 +- fs/xfs/xfs_mount.c | 62 +++++++++++++++++--------------------------------- fs/xfs/xfs_super.c | 4 +++- fs/xfs/xfs_super.h | 2 +- fs/xfs/xfs_trans.c | 5 ++-- 6 files changed, 33 insertions(+), 50 deletions(-)fs/xfs/libxfs/xfs_sb.c +0
-0
fs/xfs/libxfs/xfs_sb.c __xfs_sb_from_disk( · line 362
Quoted 5 lines
fs/xfs/libxfs/xfs_sb.c +1
-1@@ -359,7 +359,8 @@ __xfs_sb_from_disk( to->sb_imax_pct = from->sb_imax_pct;if (percpu_counter_initialized (&to->sb_icount))percpu_counter_set (&to->sb_icount,be64_to_cpu (from->sb_icount)); - to->sb_ifree =be64_to_cpu (from->sb_ifree); +if (percpu_counter_initialized (&to->sb_icount))
sb_ifree
Brian
Quoted 314 lines
fs/xfs/libxfs/xfs_sb.c +4
-2+percpu_counter_set (&to->sb_ifree,be64_to_cpu (from->sb_ifree)); to->sb_fdblocks =be64_to_cpu (from->sb_fdblocks); to->sb_frextents =be64_to_cpu (from->sb_frextents); to->sb_uquotino =be64_to_cpu (from->sb_uquotino);@@ -494,7 +495,7 @@ xfs_sb_to_disk( to->sb_inprogress = from->sb_inprogress; to->sb_imax_pct = from->sb_imax_pct; to->sb_icount =cpu_to_be64 (percpu_counter_sum (&from->sb_icount)); - to->sb_ifree =cpu_to_be64 (from->sb_ifree); + to->sb_ifree =cpu_to_be64 (percpu_counter_sum (&from->sb_ifree)); to->sb_fdblocks =cpu_to_be64 (from->sb_fdblocks); to->sb_frextents =cpu_to_be64 (from->sb_frextents);@@ -540,6 +541,7 @@ xfs_sb_verify(/* don't need to validate icount here */ sb.sb_icount.counters =NULL ; + sb.sb_ifree.counters =NULL ;/* * Use call variant which doesn't convert quota flags from disk @@ -751,7 +753,7 @@ xfs_initialize_perag_data(* Overwrite incore superblock counters with just-read data */ spin_lock (&mp->m_sb_lock); - sbp->sb_ifree = ifree; +percpu_counter_set (&sbp->sb_ifree, ifree);percpu_counter_set (&sbp->sb_icount, ialloc); sbp->sb_fdblocks = bfree + bfreelst + btree;spin_unlock (&mp->m_sb_lock);fs/xfs/xfs_fsops.c +1
-1@@ -632,11 +632,11 @@ xfs_fs_counts( {xfs_icsb_sync_counters (mp,XFS_ICSB_LAZY_COUNT ); cnt->allocino =percpu_counter_read_positive (&mp->m_sb.sb_icount); + cnt->freeino =percpu_counter_read_positive (&mp->m_sb.sb_ifree);spin_lock (&mp->m_sb_lock); 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;spin_unlock (&mp->m_sb_lock);return 0 ; }fs/xfs/xfs_mount.c +21
-41@@ -1136,13 +1136,12 @@ xfs_mod_incore_sb_unlocked( }return 0 ;case XFS_SBS_IFREE : - lcounter = (long long )mp->m_sb.sb_ifree; - lcounter += delta; -if (lcounter <0 ) { +percpu_counter_add (&mp->m_sb.sb_ifree, delta); +if (percpu_counter_compare (&mp->m_sb.sb_ifree,0 ) <0 ) {ASSERT (0 ); +percpu_counter_add (&mp->m_sb.sb_ifree, -delta);return -EINVAL ; } - mp->m_sb.sb_ifree = lcounter;return 0 ;case XFS_SBS_FDBLOCKS : lcounter = (long long)@@ -1288,9 +1287,9 @@ xfs_mod_incore_sb(int status;#ifdef HAVE_PERCPU_SB -ASSERT (field <XFS_SBS_IFREE || field >XFS_SBS_FDBLOCKS ); +ASSERT (field !=XFS_SBS_FDBLOCKS );#endif -if (field ==XFS_SBS_ICOUNT ) +if (field ==XFS_SBS_ICOUNT || field ==XFS_SBS_IFREE )return xfs_mod_incore_sb_unlocked (mp, field, delta, rsvd);spin_lock (&mp->m_sb_lock);@@ -1495,7 +1494,6 @@ xfs_icsb_cpu_notify(case CPU_ONLINE :case CPU_ONLINE_FROZEN :xfs_icsb_lock (mp); -xfs_icsb_balance_counter (mp,XFS_SBS_IFREE ,0 );xfs_icsb_balance_counter (mp,XFS_SBS_FDBLOCKS ,0 );xfs_icsb_unlock (mp);break ;@@ -1506,15 +1504,12 @@ xfs_icsb_cpu_notify(* re-enable the counters. */ xfs_icsb_lock (mp);spin_lock (&mp->m_sb_lock); -xfs_icsb_disable_counter (mp,XFS_SBS_IFREE );xfs_icsb_disable_counter (mp,XFS_SBS_FDBLOCKS ); - mp->m_sb.sb_ifree += cntp->icsb_ifree; mp->m_sb.sb_fdblocks += cntp->icsb_fdblocks;memset (cntp,0 ,sizeof (xfs_icsb_cnts_t)); -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);@@ -1536,11 +1531,13 @@ xfs_icsb_init_counters(if (i)return ENOMEM ; + i =percpu_counter_init (&mp->m_sb.sb_ifree,0 ,GFP_KERNEL ); +if (i) + goto free_icount; + mp->m_sb_cnts =alloc_percpu (xfs_icsb_cnts_t); -if (!mp->m_sb_cnts) { -percpu_counter_destroy (&mp->m_sb.sb_icount); -return -ENOMEM ; - } +if (!mp->m_sb_cnts) + goto free_ifree;for_each_online_cpu (i) { cntp = (xfs_icsb_cnts_t *)per_cpu_ptr (mp->m_sb_cnts, i);@@ -1562,6 +1559,12 @@ xfs_icsb_init_counters(#endif /* CONFIG_HOTPLUG_CPU */ return 0 ; + +free_ifree: +percpu_counter_destroy (&mp->m_sb.sb_ifree); +free_icount: +percpu_counter_destroy (&mp->m_sb.sb_icount); +return -ENOMEM ; }void @@ -1574,7 +1577,6 @@ xfs_icsb_reinit_counters(* initial balance kicks us off correctly */ mp->m_icsb_counters =-1 ; -xfs_icsb_balance_counter (mp,XFS_SBS_IFREE ,0 );xfs_icsb_balance_counter (mp,XFS_SBS_FDBLOCKS ,0 );xfs_icsb_unlock (mp); }@@ -1589,6 +1591,7 @@ xfs_icsb_destroy_counters( }percpu_counter_destroy (&mp->m_sb.sb_icount); +percpu_counter_destroy (&mp->m_sb.sb_ifree);mutex_destroy (&mp->m_icsb_mutex); }@@ -1652,7 +1655,6 @@ xfs_icsb_count(for_each_online_cpu (i) { cntp = (xfs_icsb_cnts_t *)per_cpu_ptr (mp->m_sb_cnts, i); - cnt->icsb_ifree += cntp->icsb_ifree; cnt->icsb_fdblocks += cntp->icsb_fdblocks; }@@ -1665,7 +1667,7 @@ xfs_icsb_counter_disabled( xfs_mount_t *mp, xfs_sb_field_t field) { -ASSERT ((field >=XFS_SBS_IFREE ) && (field <=XFS_SBS_FDBLOCKS )); +ASSERT (field ==XFS_SBS_FDBLOCKS );return test_bit (field, &mp->m_icsb_counters); }@@ -1676,7 +1678,7 @@ xfs_icsb_disable_counter( {xfs_icsb_cnts_t cnt; -ASSERT ((field >=XFS_SBS_IFREE ) && (field <=XFS_SBS_FDBLOCKS )); +ASSERT (field ==XFS_SBS_FDBLOCKS );/* * If we are already disabled, then there is nothing to do @@ -1695,9 +1697,6 @@ xfs_icsb_disable_counter(xfs_icsb_count (mp, &cnt,XFS_ICSB_LAZY_COUNT );switch (field) { -case XFS_SBS_IFREE : - mp->m_sb.sb_ifree = cnt.icsb_ifree; -break ;case XFS_SBS_FDBLOCKS : mp->m_sb.sb_fdblocks = cnt.icsb_fdblocks;break ;@@ -1719,15 +1718,12 @@ xfs_icsb_enable_counter(xfs_icsb_cnts_t *cntp;int i; -ASSERT ((field >=XFS_SBS_IFREE ) && (field <=XFS_SBS_FDBLOCKS )); +ASSERT (field ==XFS_SBS_FDBLOCKS );xfs_icsb_lock_all_counters (mp);for_each_online_cpu (i) { cntp =per_cpu_ptr (mp->m_sb_cnts, i);switch (field) { -case XFS_SBS_IFREE : - cntp->icsb_ifree = count + resid; -break ;case XFS_SBS_FDBLOCKS : cntp->icsb_fdblocks = count + resid;break ;@@ -1750,8 +1746,6 @@ xfs_icsb_sync_counters_locked(xfs_icsb_count (mp, &cnt, flags); -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; }@@ -1803,12 +1797,6 @@ xfs_icsb_balance_counter_locked(/* update counters - first CPU gets residual*/ switch (field) { -case XFS_SBS_IFREE : - count = mp->m_sb.sb_ifree; - resid =do_div (count, weight); -if (count <max (min,XFS_ICSB_INO_CNTR_REENABLE )) -return ; -break ;case XFS_SBS_FDBLOCKS : count = mp->m_sb.sb_fdblocks; resid =do_div (count, weight);@@ -1863,14 +1851,6 @@ again: }switch (field) { -case XFS_SBS_IFREE : - lcounter = icsbp->icsb_ifree; - lcounter += delta; -if (unlikely (lcounter <0 )) - goto balance_counter; - icsbp->icsb_ifree = lcounter; -break ; -case XFS_SBS_FDBLOCKS :BUG_ON ((mp->m_resblks - mp->m_resblks_avail) !=0 );fs/xfs/xfs_super.c +3
-1@@ -1088,6 +1088,7 @@ xfs_fs_statfs(struct xfs_inode *ip =XFS_I (dentry->d_inode);__uint64_t fakeinos, id;__uint64_t sb_icount; +__uint64_t sb_ifree;xfs_extlen_t lsize;__int64_t ffree;@@ -1100,6 +1101,7 @@ xfs_fs_statfs(xfs_icsb_sync_counters (mp,XFS_ICSB_LAZY_COUNT ); sb_icount =percpu_counter_sum (&sbp->sb_icount); + sb_ifree =percpu_counter_sum (&sbp->sb_ifree);spin_lock (&mp->m_sb_lock); statp->f_bsize = sbp->sb_blocksize;@@ -1116,7 +1118,7 @@ xfs_fs_statfs( mp->m_maxicount);/* make sure statp->f_ffree does not underflow */ - ffree = statp->f_files - (sb_icount - sbp->sb_ifree); + ffree = statp->f_files - (sb_icount - sb_ifree); statp->f_ffree =max_t (__int64_t, ffree,0 );spin_unlock (&mp->m_sb_lock);fs/xfs/xfs_super.h +1
-1@@ -98,8 +98,8 @@ struct xfs_sb {/* statistics */ struct percpu_counter sb_icount;/* allocated inodes */ +struct percpu_counter sb_ifree;/* free inodes */ -__uint64_t sb_ifree;/* free inodes */ __uint64_t sb_fdblocks;/* free data blocks */ __uint64_t sb_frextents;/* free realtime extents */ xfs_ino_t sb_uquotino;/* user quota inode */ fs/xfs/xfs_trans.c +2
-3@@ -560,8 +560,7 @@ xfs_trans_unreserve_and_mod_sb( }if (ifreedelta) { - error =xfs_icsb_modify_counters (mp,XFS_SBS_IFREE , - ifreedelta, rsvd); + error =xfs_mod_incore_sb (mp,XFS_SBS_IFREE , ifreedelta, rsvd);if (error) goto out_undo_icount; }@@ -630,7 +629,7 @@ xfs_trans_unreserve_and_mod_sb( out_undo_ifreecount:if (ifreedelta) -xfs_icsb_modify_counters (mp,XFS_SBS_IFREE , -ifreedelta, rsvd); +xfs_mod_incore_sb (mp,XFS_SBS_IFREE , -ifreedelta, rsvd); out_undo_icount:if (idelta)xfs_mod_incore_sb (mp,XFS_SBS_ICOUNT , -idelta, rsvd);Signature · 6 lines
2.0.0 _______________________________________________ xfs mailing list [email protected] http://oss.sgi.com/mailman/listinfo/xfs
_______________________________________________
xfs mailing list
[email protected]
http://oss.sgi.com/mailman/listinfo/xfs
PATCH 4/5 xfs: use generic percpu counters for free block counter
In reply to Dave ChinnerXFS 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.
--- fs/xfs/libxfs/xfs_sb.c | 11 +++- fs/xfs/xfs_fsops.c | 9 +-- fs/xfs/xfs_iomap.c | 2 +- fs/xfs/xfs_mount.c | 167 ++++++++++++++++++++++++------------------------- fs/xfs/xfs_super.c | 11 +++- fs/xfs/xfs_super.h | 2 +- fs/xfs/xfs_trans.c | 9 ++- 7 files changed, 109 insertions(+), 102 deletions(-)
fs/xfs/libxfs/xfs_sb.c +8 -3
@@ -357,11 +357,15 @@ __xfs_sb_from_disk( to->sb_rextslog = from->sb_rextslog; to->sb_inprogress = from->sb_inprogress; to->sb_imax_pct = from->sb_imax_pct; +if (percpu_counter_initialized (&to->sb_icount))percpu_counter_set (&to->sb_icount,be64_to_cpu (from->sb_icount));if (percpu_counter_initialized (&to->sb_icount))percpu_counter_set (&to->sb_ifree,be64_to_cpu (from->sb_ifree)); - to->sb_fdblocks =be64_to_cpu (from->sb_fdblocks); +if (percpu_counter_initialized (&to->sb_fdblocks)) +percpu_counter_set (&to->sb_fdblocks, +be64_to_cpu (from->sb_fdblocks)); + to->sb_frextents =be64_to_cpu (from->sb_frextents); to->sb_uquotino =be64_to_cpu (from->sb_uquotino); to->sb_gquotino =be64_to_cpu (from->sb_gquotino);
@@ -496,7 +500,7 @@ xfs_sb_to_disk( to->sb_imax_pct = from->sb_imax_pct; to->sb_icount =cpu_to_be64 (percpu_counter_sum (&from->sb_icount)); to->sb_ifree =cpu_to_be64 (percpu_counter_sum (&from->sb_ifree)); - to->sb_fdblocks =cpu_to_be64 (from->sb_fdblocks); + to->sb_fdblocks =cpu_to_be64 (percpu_counter_sum (&from->sb_fdblocks)); to->sb_frextents =cpu_to_be64 (from->sb_frextents); to->sb_flags = from->sb_flags;
@@ -542,6 +546,7 @@ xfs_sb_verify(/* don't need to validate icount here */ sb.sb_icount.counters =NULL ; sb.sb_ifree.counters =NULL ; + sb.sb_fdblocks.counters =NULL ;/* * Use call variant which doesn't convert quota flags from disk
@@ -755,7 +760,7 @@ xfs_initialize_perag_data(spin_lock (&mp->m_sb_lock);percpu_counter_set (&sbp->sb_ifree, ifree);percpu_counter_set (&sbp->sb_icount, ialloc); - sbp->sb_fdblocks = bfree + bfreelst + btree; +percpu_counter_set (&sbp->sb_fdblocks, bfree + bfreelst + btree);spin_unlock (&mp->m_sb_lock);/* Fixup the per-cpu counters as well. */
fs/xfs/xfs_fsops.c +5 -4
@@ -633,9 +633,10 @@ xfs_fs_counts(xfs_icsb_sync_counters (mp,XFS_ICSB_LAZY_COUNT ); cnt->allocino =percpu_counter_read_positive (&mp->m_sb.sb_icount); cnt->freeino =percpu_counter_read_positive (&mp->m_sb.sb_ifree); + cnt->freedata =percpu_counter_read_positive (&mp->m_sb.sb_fdblocks) - +XFS_ALLOC_SET_ASIDE (mp);spin_lock (&mp->m_sb_lock); - cnt->freedata = mp->m_sb.sb_fdblocks -XFS_ALLOC_SET_ASIDE (mp); cnt->freertx = mp->m_sb.sb_frextents;spin_unlock (&mp->m_sb_lock);return 0 ;
@@ -710,7 +711,8 @@ retry: }else {__int64_t free; - free = mp->m_sb.sb_fdblocks -XFS_ALLOC_SET_ASIDE (mp); + free =percpu_counter_sum (&mp->m_sb.sb_fdblocks) - +XFS_ALLOC_SET_ASIDE (mp);if (!free) goto out;/* ENOSPC and fdblks_delta = 0 */
@@ -749,8 +751,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_mod_incore_sb (mp,XFS_SBS_FDBLOCKS , fdblks_delta,0 );if (error == -ENOSPC ) goto retry; }
fs/xfs/xfs_iomap.c +1 -1
@@ -461,7 +461,7 @@ xfs_iomap_prealloc_size( alloc_blocks);xfs_icsb_sync_counters (mp,XFS_ICSB_LAZY_COUNT ); - freesp = mp->m_sb.sb_fdblocks; + freesp =percpu_counter_read_positive (&mp->m_sb.sb_fdblocks);if (freesp < mp->m_low_space[XFS_LOWSP_5_PCNT ]) { shift =2 ;if (freesp < mp->m_low_space[XFS_LOWSP_4_PCNT ])
fs/xfs/xfs_mount.c +82 -85
316 lines not on this page · raw message
fs/xfs/xfs_super.c +8 -3
@@ -1089,6 +1089,7 @@ xfs_fs_statfs(__uint64_t fakeinos, id;__uint64_t sb_icount;__uint64_t sb_ifree; +__uint64_t sb_fdblocks;xfs_extlen_t lsize;__int64_t ffree;
@@ -1100,15 +1101,20 @@ xfs_fs_statfs( statp->f_fsid.val[1 ] = (u32)(id >>32 );xfs_icsb_sync_counters (mp,XFS_ICSB_LAZY_COUNT ); + sb_icount =percpu_counter_sum (&sbp->sb_icount); sb_ifree =percpu_counter_sum (&sbp->sb_ifree); + sb_fdblocks =percpu_counter_sum (&sbp->sb_fdblocks);spin_lock (&mp->m_sb_lock); statp->f_bsize = sbp->sb_blocksize; lsize = sbp->sb_logstart ? sbp->sb_logblocks :0 ; statp->f_blocks = sbp->sb_dblocks - lsize; - statp->f_bfree = statp->f_bavail = - sbp->sb_fdblocks -XFS_ALLOC_SET_ASIDE (mp); +spin_unlock (&mp->m_sb_lock); + + statp->f_bfree = sb_fdblocks -XFS_ALLOC_SET_ASIDE (mp); + statp->f_bavail = statp->f_bfree; + fakeinos = statp->f_bfree << sbp->sb_inopblog; statp->f_files =MIN (sb_icount + fakeinos, (__uint64_t )XFS_MAXINUMBER );
@@ -1121,7 +1127,6 @@ xfs_fs_statfs( ffree = statp->f_files - (sb_icount - sb_ifree); statp->f_ffree =max_t (__int64_t, ffree,0 ); -spin_unlock (&mp->m_sb_lock);if ((ip->i_d.di_flags &XFS_DIFLAG_PROJINHERIT ) && ((mp->m_qflags & (XFS_PQUOTA_ACCT|XFS_PQUOTA_ENFD))) ==
fs/xfs/xfs_super.h +1 -1
@@ -99,8 +99,8 @@ struct xfs_sb {struct percpu_counter sb_icount;/* allocated inodes */ struct percpu_counter sb_ifree;/* free inodes */ +struct percpu_counter sb_fdblocks;/* free data blocks */ -__uint64_t sb_fdblocks;/* free data blocks */ __uint64_t sb_frextents;/* free realtime extents */ xfs_ino_t sb_uquotino;/* user quota inode */ xfs_ino_t sb_gquotino;/* group quota inode */
fs/xfs/xfs_trans.c +4 -5
@@ -184,7 +184,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_mod_incore_sb (tp->t_mountp,XFS_SBS_FDBLOCKS , -((int64_t )blocks), rsvd);if (error !=0 ) {current_restore_flags_nested (&tp->t_pflags,PF_FSTRANS );
@@ -268,7 +268,7 @@ undo_log: undo_blocks:if (blocks >0 ) { -xfs_icsb_modify_counters (tp->t_mountp,XFS_SBS_FDBLOCKS , +xfs_mod_incore_sb (tp->t_mountp,XFS_SBS_FDBLOCKS , (int64_t )blocks, rsvd); tp->t_blk_res =0 ; }
@@ -547,8 +547,7 @@ 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_mod_incore_sb (mp,XFS_SBS_FDBLOCKS , blkdelta, rsvd);if (error) goto out; }
@@ -635,7 +634,7 @@ out_undo_icount:xfs_mod_incore_sb (mp,XFS_SBS_ICOUNT , -idelta, rsvd); out_undo_fdblocks:if (blkdelta) -xfs_icsb_modify_counters (mp,XFS_SBS_FDBLOCKS , -blkdelta, rsvd); +xfs_mod_incore_sb (mp,XFS_SBS_FDBLOCKS , -blkdelta, rsvd); out:ASSERT (error ==0 );return ;
Signature · 6 lines
2.0.0 _______________________________________________ xfs mailing list [email protected] http://oss.sgi.com/mailman/listinfo/xfs
Re: [PATCH 4/5] xfs: use generic percpu counters for free block counter
Quoted 66 lines
(quoted diff) +53
-0case XFS_SBS_FDBLOCKS: if (delta > 0) { /* Putting blocks back */ + if (mp->m_resblks == mp->m_resblks_avail) { + percpu_counter_add(&mp->m_sb.sb_fdblocks, delta); + return 0; + } + + /* put blocks back into reserve pool first */ + spin_lock(&mp->m_sb_lock); + res_used = (long long) + (mp->m_resblks - mp->m_resblks_avail); + if (res_used > delta) { mp->m_resblks_avail += delta; } else { + delta -= res_used; mp->m_resblks_avail = mp->m_resblks; + percpu_counter_add(&mp->m_sb.sb_fdblocks, delta); } + spin_unlock(&mp->m_sb_lock); + return 0; + } + /* + * Taking blocks away, need to be more accurate the closer we + * are to zero. + * + * batch size is set to a maximum of 1024 blocks - if we are + * allocating of freeing extents larger than this then we aren't + * going to be hammering the counter lock so a lock per update + * is not a problem. + * + * If the counter has a value of less than 2 * max batch size, + * then make everything serialise as we are real close to + * ENOSPC. + */ +#define __BATCH 1024 + if (percpu_counter_compare(&mp->m_sb.sb_fdblocks, + 2 * __BATCH) < 0) + batch = 1; + else + batch = __BATCH; + + __percpu_counter_add(&mp->m_sb.sb_fdblocks, delta, batch); + if (percpu_counter_compare(&mp->m_sb.sb_fdblocks, + XFS_ALLOC_SET_ASIDE(mp)) >= 0) { + /* we had space! */ + return 0; } + /* + * lock up the sb for dipping into reserves before releasing + * the space that took us to ENOSPC. + */ + spin_lock(&mp->m_sb_lock); + percpu_counter_add(&mp->m_sb.sb_fdblocks, -delta); + if (!rsvd) + goto fdblocks_enospc; + + lcounter = (long long)mp->m_resblks_avail + delta; + if (lcounter >= 0) { + mp->m_resblks_avail = lcounter; + spin_unlock(&mp->m_sb_lock);
Review
Quoted 10 lines
(quoted diff) +10
-0+ return 0; + } + printk_once(KERN_WARNING + "Filesystem \"%s\": reserve blocks depleted! " + "Consider increasing reserve pool size.", + mp->m_fsname); +fdblocks_enospc: + spin_unlock(&mp->m_sb_lock); + return -ENOSPC; +
This screams for having two different helpers for removing vs adding back reserved blocks.
_______________________________________________
xfs mailing list
[email protected]
http://oss.sgi.com/mailman/listinfo/xfs
Re: [PATCH 4/5] xfs: use generic percpu counters for free block counter
Quoted 3 lines · Christoph Hellwig
This screams for having two different helpers for removing vs adding back reserved blocks.
Yup, that it does.
Cheers,
Dave.
Signature · 7 lines
Dave Chinner [email protected] _______________________________________________ xfs mailing list [email protected] http://oss.sgi.com/mailman/listinfo/xfs
Re: [PATCH 4/5] xfs: use generic percpu counters for free block counter
In reply to Dave ChinnerQuoted 200 lines · Dave Chinner
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 <[email protected]>--- fs/xfs/libxfs/xfs_sb.c | 11 +++- fs/xfs/xfs_fsops.c | 9 +-- fs/xfs/xfs_iomap.c | 2 +- fs/xfs/xfs_mount.c | 167 ++++++++++++++++++++++++------------------------- fs/xfs/xfs_super.c | 11 +++- fs/xfs/xfs_super.h | 2 +- fs/xfs/xfs_trans.c | 9 ++- 7 files changed, 109 insertions(+), 102 deletions(-)fs/xfs/libxfs/xfs_sb.c +8
-3@@ -357,11 +357,15 @@ __xfs_sb_from_disk( to->sb_rextslog = from->sb_rextslog; to->sb_inprogress = from->sb_inprogress; to->sb_imax_pct = from->sb_imax_pct; +if (percpu_counter_initialized (&to->sb_icount))percpu_counter_set (&to->sb_icount,be64_to_cpu (from->sb_icount));if (percpu_counter_initialized (&to->sb_icount))percpu_counter_set (&to->sb_ifree,be64_to_cpu (from->sb_ifree)); - to->sb_fdblocks =be64_to_cpu (from->sb_fdblocks); +if (percpu_counter_initialized (&to->sb_fdblocks)) +percpu_counter_set (&to->sb_fdblocks, +be64_to_cpu (from->sb_fdblocks)); + to->sb_frextents =be64_to_cpu (from->sb_frextents); to->sb_uquotino =be64_to_cpu (from->sb_uquotino); to->sb_gquotino =be64_to_cpu (from->sb_gquotino);@@ -496,7 +500,7 @@ xfs_sb_to_disk( to->sb_imax_pct = from->sb_imax_pct; to->sb_icount =cpu_to_be64 (percpu_counter_sum (&from->sb_icount)); to->sb_ifree =cpu_to_be64 (percpu_counter_sum (&from->sb_ifree)); - to->sb_fdblocks =cpu_to_be64 (from->sb_fdblocks); + to->sb_fdblocks =cpu_to_be64 (percpu_counter_sum (&from->sb_fdblocks)); to->sb_frextents =cpu_to_be64 (from->sb_frextents); to->sb_flags = from->sb_flags;@@ -542,6 +546,7 @@ xfs_sb_verify(/* don't need to validate icount here */ sb.sb_icount.counters =NULL ; sb.sb_ifree.counters =NULL ; + sb.sb_fdblocks.counters =NULL ;/* * Use call variant which doesn't convert quota flags from disk @@ -755,7 +760,7 @@ xfs_initialize_perag_data(spin_lock (&mp->m_sb_lock);percpu_counter_set (&sbp->sb_ifree, ifree);percpu_counter_set (&sbp->sb_icount, ialloc); - sbp->sb_fdblocks = bfree + bfreelst + btree; +percpu_counter_set (&sbp->sb_fdblocks, bfree + bfreelst + btree);spin_unlock (&mp->m_sb_lock);/* Fixup the per-cpu counters as well. */ fs/xfs/xfs_fsops.c +5
-4@@ -633,9 +633,10 @@ xfs_fs_counts(xfs_icsb_sync_counters (mp,XFS_ICSB_LAZY_COUNT ); cnt->allocino =percpu_counter_read_positive (&mp->m_sb.sb_icount); cnt->freeino =percpu_counter_read_positive (&mp->m_sb.sb_ifree); + cnt->freedata =percpu_counter_read_positive (&mp->m_sb.sb_fdblocks) - +XFS_ALLOC_SET_ASIDE (mp);spin_lock (&mp->m_sb_lock); - cnt->freedata = mp->m_sb.sb_fdblocks -XFS_ALLOC_SET_ASIDE (mp); cnt->freertx = mp->m_sb.sb_frextents;spin_unlock (&mp->m_sb_lock);return 0 ;@@ -710,7 +711,8 @@ retry: }else {__int64_t free; - free = mp->m_sb.sb_fdblocks -XFS_ALLOC_SET_ASIDE (mp); + free =percpu_counter_sum (&mp->m_sb.sb_fdblocks) - +XFS_ALLOC_SET_ASIDE (mp);if (!free) goto out;/* ENOSPC and fdblks_delta = 0 */ @@ -749,8 +751,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_mod_incore_sb (mp,XFS_SBS_FDBLOCKS , fdblks_delta,0 );if (error == -ENOSPC ) goto retry; }fs/xfs/xfs_iomap.c +1
-1@@ -461,7 +461,7 @@ xfs_iomap_prealloc_size( alloc_blocks);xfs_icsb_sync_counters (mp,XFS_ICSB_LAZY_COUNT ); - freesp = mp->m_sb.sb_fdblocks; + freesp =percpu_counter_read_positive (&mp->m_sb.sb_fdblocks);if (freesp < mp->m_low_space[XFS_LOWSP_5_PCNT ]) { shift =2 ;if (freesp < mp->m_low_space[XFS_LOWSP_4_PCNT ])fs/xfs/xfs_mount.c +17
-28@@ -1117,7 +1117,8 @@ xfs_mod_incore_sb_unlocked( {int scounter;/* short counter for 32 bit fields */ long long lcounter;/* long counter for 64 bit fields */ -long long res_used, rem; +long long res_used; +s32 batch;/* * With the in-core superblock spin lock held, switch @@ -1144,47 +1145,80 @@ xfs_mod_incore_sb_unlocked( }return 0 ;case XFS_SBS_FDBLOCKS : - lcounter = (long long ) - mp->m_sb.sb_fdblocks -XFS_ALLOC_SET_ASIDE (mp); - res_used = (long long )(mp->m_resblks - mp->m_resblks_avail);if (delta >0 ) {/* Putting blocks back */ +if (mp->m_resblks == mp->m_resblks_avail) { +percpu_counter_add (&mp->m_sb.sb_fdblocks, delta); +return 0 ; + } + +/* put blocks back into reserve pool first */ +spin_lock (&mp->m_sb_lock); + res_used = (long long ) + (mp->m_resblks - mp->m_resblks_avail); +if (res_used > delta) { mp->m_resblks_avail += delta; }else { - rem = delta - res_used; + delta -= res_used; mp->m_resblks_avail = mp->m_resblks; - lcounter += rem; - } - }else {/* Taking blocks away */ - lcounter += delta; -if (lcounter >=0 ) { - mp->m_sb.sb_fdblocks = lcounter + -XFS_ALLOC_SET_ASIDE (mp); -return 0 ; +percpu_counter_add (&mp->m_sb.sb_fdblocks, delta); } +spin_unlock (&mp->m_sb_lock); +return 0 ; -/* -* We are out of blocks, use any available reserved -* blocks if were allowed to. -*/ -if (!rsvd) -return -ENOSPC ; + } - lcounter = (long long )mp->m_resblks_avail + delta; -if (lcounter >=0 ) { - mp->m_resblks_avail = lcounter; -return 0 ; - } -printk_once (KERN_WARNING -"Filesystem \"%s\": reserve blocks depleted! " -"Consider increasing reserve pool size." , - mp->m_fsname);
fs/xfs/xfs_mount.c xfs_mod_incore_sb_unlocked( · line 1180
Quoted 10 lines
fs/xfs/xfs_mount.c +9
-1-return -ENOSPC ; +/* +* Taking blocks away, need to be more accurate the closer we +* are to zero. +* +* batch size is set to a maximum of 1024 blocks - if we are +* allocating of freeing extents larger than this then we aren't +* going to be hammering the counter lock so a lock per update +* is not a problem. +*
IIUC, the batch size determines the point at which the local cpu delta is folded back into the global counter (under lock). If we're allocating large extents, these will surpass the batch size and result in a locked update. Smaller updates are aggregated into the cpu counter and folded in at some later time.
fs/xfs/xfs_mount.c xfs_mod_incore_sb_unlocked( · line 1191
Quoted 11 lines
fs/xfs/xfs_mount.c +11
-0+* If the counter has a value of less than 2 * max batch size, +* then make everything serialise as we are real close to +* ENOSPC. +*/ +#define __BATCH 1024 +if (percpu_counter_compare (&mp->m_sb.sb_fdblocks, +2 * __BATCH) <0 ) + batch =1 ; +else + batch = __BATCH; +
The general approach seems logical. I do wonder whether blocks is the right scale as opposed to block count normalized against some fixed I/O size (to account for different block sizes).
Also, it seems like speculative preallocation could hide some of the overhead here, depending on workload of course. Had that factored into your testing?
Quoted 4 lines
fs/xfs/xfs_mount.c +4
-0+__percpu_counter_add (&mp->m_sb.sb_fdblocks, delta, batch); +if (percpu_counter_compare (&mp->m_sb.sb_fdblocks, +XFS_ALLOC_SET_ASIDE (mp)) >=0 ) { +/* we had space! */
fs/xfs/xfs_mount.c xfs_mod_incore_sb_unlocked( · line 1203
Quoted 10 lines
fs/xfs/xfs_mount.c +6
-2+return 0 ; } - mp->m_sb.sb_fdblocks = lcounter +XFS_ALLOC_SET_ASIDE (mp); -return 0 ; +/* +* lock up the sb for dipping into reserves before releasing +* the space that took us to ENOSPC. +*/ +spin_lock (&mp->m_sb_lock);
Can you elaborate on the locking here, why it's needed where it wasn't before?
Brian
Quoted 340 lines
fs/xfs/xfs_mount.c +35
-54+percpu_counter_add (&mp->m_sb.sb_fdblocks, -delta); +if (!rsvd) + goto fdblocks_enospc; + + lcounter = (long long )mp->m_resblks_avail + delta; +if (lcounter >=0 ) { + mp->m_resblks_avail = lcounter; +spin_unlock (&mp->m_sb_lock); +return 0 ; + } +printk_once (KERN_WARNING +"Filesystem \"%s\": reserve blocks depleted! " +"Consider increasing reserve pool size." , + mp->m_fsname); +fdblocks_enospc: +spin_unlock (&mp->m_sb_lock); +return -ENOSPC ; +case XFS_SBS_FREXTENTS : lcounter = (long long )mp->m_sb.sb_frextents; lcounter += delta;@@ -1286,11 +1320,14 @@ xfs_mod_incore_sb( {int status; -#ifdef HAVE_PERCPU_SB -ASSERT (field !=XFS_SBS_FDBLOCKS ); -#endif -if (field ==XFS_SBS_ICOUNT || field ==XFS_SBS_IFREE ) +switch (field) { +case XFS_SBS_ICOUNT : +case XFS_SBS_IFREE : +case XFS_SBS_FDBLOCKS :return xfs_mod_incore_sb_unlocked (mp, field, delta, rsvd); +default : +break ; + }spin_lock (&mp->m_sb_lock); status =xfs_mod_incore_sb_unlocked (mp, field, delta, rsvd);@@ -1309,7 +1346,7 @@ xfs_mod_incore_sb(* * Note that this function may not be used for the superblock values that * are tracked with the in-memory per-cpu counters - a direct call to -* xfs_icsb_modify_counters is required for these. +* xfs_mod_incore_sb is required for these. */ int xfs_mod_incore_sb_batch(@@ -1494,7 +1531,6 @@ xfs_icsb_cpu_notify(case CPU_ONLINE :case CPU_ONLINE_FROZEN :xfs_icsb_lock (mp); -xfs_icsb_balance_counter (mp,XFS_SBS_FDBLOCKS ,0 );xfs_icsb_unlock (mp);break ;case CPU_DEAD :@@ -1504,13 +1540,9 @@ xfs_icsb_cpu_notify(* re-enable the counters. */ xfs_icsb_lock (mp);spin_lock (&mp->m_sb_lock); -xfs_icsb_disable_counter (mp,XFS_SBS_FDBLOCKS ); - - mp->m_sb.sb_fdblocks += cntp->icsb_fdblocks;memset (cntp,0 ,sizeof (xfs_icsb_cnts_t)); -xfs_icsb_balance_counter_locked (mp,XFS_SBS_FDBLOCKS ,0 );spin_unlock (&mp->m_sb_lock);xfs_icsb_unlock (mp);break ;@@ -1535,9 +1567,13 @@ xfs_icsb_init_counters(if (i) goto free_icount; + i =percpu_counter_init (&mp->m_sb.sb_fdblocks,0 ,GFP_KERNEL ); +if (i) + goto free_ifree; + mp->m_sb_cnts =alloc_percpu (xfs_icsb_cnts_t);if (!mp->m_sb_cnts) - goto free_ifree; + goto free_fdblocks;for_each_online_cpu (i) { cntp = (xfs_icsb_cnts_t *)per_cpu_ptr (mp->m_sb_cnts, i);@@ -1560,6 +1596,8 @@ xfs_icsb_init_counters(return 0 ; +free_fdblocks: +percpu_counter_destroy (&mp->m_sb.sb_fdblocks); free_ifree:percpu_counter_destroy (&mp->m_sb.sb_ifree); free_icount:@@ -1577,7 +1615,6 @@ xfs_icsb_reinit_counters(* initial balance kicks us off correctly */ mp->m_icsb_counters =-1 ; -xfs_icsb_balance_counter (mp,XFS_SBS_FDBLOCKS ,0 );xfs_icsb_unlock (mp); }@@ -1592,6 +1629,7 @@ xfs_icsb_destroy_counters(percpu_counter_destroy (&mp->m_sb.sb_icount);percpu_counter_destroy (&mp->m_sb.sb_ifree); +percpu_counter_destroy (&mp->m_sb.sb_fdblocks);mutex_destroy (&mp->m_icsb_mutex); }@@ -1645,18 +1683,11 @@ xfs_icsb_count(xfs_icsb_cnts_t *cnt, int flags) { -xfs_icsb_cnts_t *cntp; -int i; - memset(cnt, 0, sizeof(xfs_icsb_cnts_t));if (!(flags &XFS_ICSB_LAZY_COUNT ))xfs_icsb_lock_all_counters (mp); -for_each_online_cpu (i) { - cntp = (xfs_icsb_cnts_t *)per_cpu_ptr (mp->m_sb_cnts, i); - cnt->icsb_fdblocks += cntp->icsb_fdblocks; - }if (!(flags &XFS_ICSB_LAZY_COUNT ))xfs_icsb_unlock_all_counters (mp);@@ -1667,7 +1698,6 @@ xfs_icsb_counter_disabled( xfs_mount_t *mp, xfs_sb_field_t field) { -ASSERT (field ==XFS_SBS_FDBLOCKS );return test_bit (field, &mp->m_icsb_counters); }@@ -1678,8 +1708,6 @@ xfs_icsb_disable_counter( {xfs_icsb_cnts_t cnt; -ASSERT (field ==XFS_SBS_FDBLOCKS ); -/* * If we are already disabled, then there is nothing to do * here. We check before locking all the counters to avoid @@ -1697,9 +1725,6 @@ xfs_icsb_disable_counter(xfs_icsb_count (mp, &cnt,XFS_ICSB_LAZY_COUNT );switch (field) { -case XFS_SBS_FDBLOCKS : - mp->m_sb.sb_fdblocks = cnt.icsb_fdblocks; -break ;default :BUG (); }@@ -1715,18 +1740,11 @@ xfs_icsb_enable_counter(uint64_t count, uint64_t resid) { -xfs_icsb_cnts_t *cntp; int i; -ASSERT (field ==XFS_SBS_FDBLOCKS ); -xfs_icsb_lock_all_counters (mp);for_each_online_cpu (i) { - cntp =per_cpu_ptr (mp->m_sb_cnts, i);switch (field) { -case XFS_SBS_FDBLOCKS : - cntp->icsb_fdblocks = count + resid; -break ;default :BUG ();break ;@@ -1745,9 +1763,6 @@ xfs_icsb_sync_counters_locked(xfs_icsb_cnts_t cnt;xfs_icsb_count (mp, &cnt, flags); - -if (!xfs_icsb_counter_disabled (mp,XFS_SBS_FDBLOCKS )) - mp->m_sb.sb_fdblocks = cnt.icsb_fdblocks; }/* @@ -1789,20 +1804,12 @@ xfs_icsb_balance_counter_locked( int min_per_cpu) {uint64_t count, resid; -int weight =num_online_cpus (); -uint64_t min = (uint64_t )min_per_cpu;/* disable counter and sync counter */ xfs_icsb_disable_counter (mp, field);/* update counters - first CPU gets residual*/ switch (field) { -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))) -return ; -break ;default :BUG (); count = resid =0 ;/* quiet, gcc */ @@ -1831,7 +1838,6 @@ xfs_icsb_modify_counters( int rsvd) {xfs_icsb_cnts_t *icsbp; -long long lcounter;/* long counter for 64 bit fields */ int ret =0 ;might_sleep ();@@ -1851,18 +1857,9 @@ again: }switch (field) { -case XFS_SBS_FDBLOCKS : -BUG_ON ((mp->m_resblks - mp->m_resblks_avail) !=0 ); - - lcounter = icsbp->icsb_fdblocks -XFS_ALLOC_SET_ASIDE (mp); - lcounter += delta; -if (unlikely (lcounter <0 )) - goto balance_counter; - icsbp->icsb_fdblocks = lcounter +XFS_ALLOC_SET_ASIDE (mp); -break ;default :BUG (); -break ; + goto balance_counter;/* be still, gcc */ }xfs_icsb_unlock_cntr (icsbp);preempt_enable ();fs/xfs/xfs_super.c +8
-3@@ -1089,6 +1089,7 @@ xfs_fs_statfs(__uint64_t fakeinos, id;__uint64_t sb_icount;__uint64_t sb_ifree; +__uint64_t sb_fdblocks;xfs_extlen_t lsize;__int64_t ffree;@@ -1100,15 +1101,20 @@ xfs_fs_statfs( statp->f_fsid.val[1 ] = (u32)(id >>32 );xfs_icsb_sync_counters (mp,XFS_ICSB_LAZY_COUNT ); + sb_icount =percpu_counter_sum (&sbp->sb_icount); sb_ifree =percpu_counter_sum (&sbp->sb_ifree); + sb_fdblocks =percpu_counter_sum (&sbp->sb_fdblocks);spin_lock (&mp->m_sb_lock); statp->f_bsize = sbp->sb_blocksize; lsize = sbp->sb_logstart ? sbp->sb_logblocks :0 ; statp->f_blocks = sbp->sb_dblocks - lsize; - statp->f_bfree = statp->f_bavail = - sbp->sb_fdblocks -XFS_ALLOC_SET_ASIDE (mp); +spin_unlock (&mp->m_sb_lock); + + statp->f_bfree = sb_fdblocks -XFS_ALLOC_SET_ASIDE (mp); + statp->f_bavail = statp->f_bfree; + fakeinos = statp->f_bfree << sbp->sb_inopblog; statp->f_files =MIN (sb_icount + fakeinos, (__uint64_t )XFS_MAXINUMBER );@@ -1121,7 +1127,6 @@ xfs_fs_statfs( ffree = statp->f_files - (sb_icount - sb_ifree); statp->f_ffree =max_t (__int64_t, ffree,0 ); -spin_unlock (&mp->m_sb_lock);if ((ip->i_d.di_flags &XFS_DIFLAG_PROJINHERIT ) && ((mp->m_qflags & (XFS_PQUOTA_ACCT|XFS_PQUOTA_ENFD))) ==fs/xfs/xfs_super.h +1
-1@@ -99,8 +99,8 @@ struct xfs_sb {struct percpu_counter sb_icount;/* allocated inodes */ struct percpu_counter sb_ifree;/* free inodes */ +struct percpu_counter sb_fdblocks;/* free data blocks */ -__uint64_t sb_fdblocks;/* free data blocks */ __uint64_t sb_frextents;/* free realtime extents */ xfs_ino_t sb_uquotino;/* user quota inode */ xfs_ino_t sb_gquotino;/* group quota inode */ fs/xfs/xfs_trans.c +4
-5@@ -184,7 +184,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_mod_incore_sb (tp->t_mountp,XFS_SBS_FDBLOCKS , -((int64_t )blocks), rsvd);if (error !=0 ) {current_restore_flags_nested (&tp->t_pflags,PF_FSTRANS );@@ -268,7 +268,7 @@ undo_log: undo_blocks:if (blocks >0 ) { -xfs_icsb_modify_counters (tp->t_mountp,XFS_SBS_FDBLOCKS , +xfs_mod_incore_sb (tp->t_mountp,XFS_SBS_FDBLOCKS , (int64_t )blocks, rsvd); tp->t_blk_res =0 ; }@@ -547,8 +547,7 @@ 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_mod_incore_sb (mp,XFS_SBS_FDBLOCKS , blkdelta, rsvd);if (error) goto out; }@@ -635,7 +634,7 @@ out_undo_icount:xfs_mod_incore_sb (mp,XFS_SBS_ICOUNT , -idelta, rsvd); out_undo_fdblocks:if (blkdelta) -xfs_icsb_modify_counters (mp,XFS_SBS_FDBLOCKS , -blkdelta, rsvd); +xfs_mod_incore_sb (mp,XFS_SBS_FDBLOCKS , -blkdelta, rsvd); out:ASSERT (error ==0 );return ;Signature · 6 lines
2.0.0 _______________________________________________ xfs mailing list [email protected] http://oss.sgi.com/mailman/listinfo/xfs
_______________________________________________
xfs mailing list
[email protected]
http://oss.sgi.com/mailman/listinfo/xfs
Re: [PATCH 4/5] xfs: use generic percpu counters for free block counter
Quoted 16 lines · Brian Foster
fs/xfs/xfs_mount.c xfs_mod_incore_sb_unlocked( · line 1180
Quoted 9 lines · Dave Chinner
fs/xfs/xfs_mount.c +9
-0+/* +* Taking blocks away, need to be more accurate the closer we +* are to zero. +* +* batch size is set to a maximum of 1024 blocks - if we are +* allocating of freeing extents larger than this then we aren't +* going to be hammering the counter lock so a lock per update +* is not a problem. +* IIUC, the batch size determines the point at which the local cpu delta is folded back into the global counter (under lock). If we're allocating large extents, these will surpass the batch size and result in a locked update. Smaller updates are aggregated into the cpu counter and folded in at some later time.
Right.
Quoted 7 lines
Quoted 7 lines
fs/xfs/xfs_mount.c +7
-0+* If the counter has a value of less than 2 * max batch size, +* then make everything serialise as we are real close to +* ENOSPC. +*/ +#define __BATCH 1024 +if (percpu_counter_compare (&mp->m_sb.sb_fdblocks, +2 * __BATCH) <0 )
Quoted 8 lines
fs/xfs/xfs_mount.c xfs_mod_incore_sb_unlocked( · line 1191
Quoted 4 lines
fs/xfs/xfs_mount.c +4
-0+ batch =1 ; + else + batch = __BATCH; +The general approach seems logical. I do wonder whether blocks is the right scale as opposed to block count normalized against some fixed I/O size (to account for different block sizes).
We allocate in blocks, so the IO size is really irrelevant. The scalability issue at hand is page-by-page space reservation during delayed allocation, so really the block size makes less difference to performance than the page size....
Quoted 3 lines
Also, it seems like speculative preallocation could hide some of the overhead here, depending on workload of course. Had that factored into your testing?
Yes, somewhat, though I shuld do some testing using 4k direct IO and buffered IO with allocsize set appropriately.
Quoted 8 lines
Quoted 8 lines
fs/xfs/xfs_mount.c +5
-0+__percpu_counter_add (&mp->m_sb.sb_fdblocks, delta, batch); +if (percpu_counter_compare (&mp->m_sb.sb_fdblocks, +XFS_ALLOC_SET_ASIDE (mp)) >=0 ) { +/* we had space! */ +return 0 ; }
Quoted 10 lines
fs/xfs/xfs_mount.c xfs_mod_incore_sb_unlocked( · line 1203
Quoted 7 lines
fs/xfs/xfs_mount.c +5
-2- mp->m_sb.sb_fdblocks = lcounter +XFS_ALLOC_SET_ASIDE (mp); -return 0 ; +/* +* lock up the sb for dipping into reserves before releasing +* the space that took us to ENOSPC. +*/ +spin_lock (&mp->m_sb_lock);Can you elaborate on the locking here, why it's needed where it wasn't before?
The lock protects the reserved pool. And it was used before as the only time we called into this function was with the m_sb_lock held. this is a bit of a hack because we now call into the function without the lock held....
Cheers,
Dave.
Signature · 7 lines
Dave Chinner [email protected] _______________________________________________ xfs mailing list [email protected] http://oss.sgi.com/mailman/listinfo/xfs
PATCH 5/5 xfs: Remove icsb infrastructure
In reply to Dave ChinnerFrom: Dave Chinner <[email protected]>
Now that the in-cor superblock infrastructure has been replaced with generic per-cpu counters, we don't need it anymore. Nuke it from orbit so we are sure that it won't haunt us again...
--- fs/xfs/libxfs/xfs_bmap.c | 16 +- fs/xfs/libxfs/xfs_sb.c | 10 +- fs/xfs/xfs_fsops.c | 2 - fs/xfs/xfs_iomap.c | 1 - fs/xfs/xfs_linux.h | 9 - fs/xfs/xfs_log_recover.c | 3 - fs/xfs/xfs_mount.c | 509 ----------------------------------------------- fs/xfs/xfs_mount.h | 64 +----- fs/xfs/xfs_super.c | 76 +++++-- 9 files changed, 67 insertions(+), 623 deletions(-)
fs/xfs/libxfs/xfs_bmap.c +8 -8
@@ -2212,7 +2212,7 @@ 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, + error =xfs_mod_incore_sb (bma->ip->i_mount,XFS_SBS_FDBLOCKS , -((int64_t )diff),0 );ASSERT (!error);
@@ -2265,7 +2265,7 @@ 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_mod_incore_sb (bma->ip->i_mount,XFS_SBS_FDBLOCKS , (int64_t )(da_old - temp),0 ); }
@@ -2944,7 +2944,7 @@ xfs_bmap_add_extent_hole_delay( }if (oldlen != newlen) {ASSERT (oldlen > newlen); -xfs_icsb_modify_counters (ip->i_mount,XFS_SBS_FDBLOCKS , +xfs_mod_incore_sb (ip->i_mount,XFS_SBS_FDBLOCKS , (int64_t )(oldlen - newlen),0 );/* * Nothing to do for disk quota accounting here.
@@ -4163,14 +4163,14 @@ 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 , + error =xfs_mod_incore_sb (mp,XFS_SBS_FDBLOCKS , -((int64_t )alen),0 ); }if (error) goto out_unreserve_quota; - error =xfs_icsb_modify_counters (mp,XFS_SBS_FDBLOCKS , + error =xfs_mod_incore_sb (mp,XFS_SBS_FDBLOCKS , -((int64_t )indlen),0 );if (error) goto out_unreserve_blocks;
@@ -4200,7 +4200,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_incore_sb (mp,XFS_SBS_FDBLOCKS , alen,0 ); out_unreserve_quota:if (XFS_IS_QUOTA_ON (mp)) xfs_trans_unreserve_quota_nblks(NULL, ip, (long)alen, 0, rt ?
@@ -5013,7 +5013,7 @@ xfs_bmap_del_extent(*/ ASSERT (da_old >= da_new);if (da_old > da_new) { -xfs_icsb_modify_counters (mp,XFS_SBS_FDBLOCKS , +xfs_mod_incore_sb (mp,XFS_SBS_FDBLOCKS , (int64_t )(da_old - da_new),0 ); } done:
@@ -5290,7 +5290,7 @@ xfs_bunmapi( ip, -((long )del.br_blockcount),0 , XFS_QMOPT_RES_RTBLKS); }else { -xfs_icsb_modify_counters (mp,XFS_SBS_FDBLOCKS , +xfs_mod_incore_sb (mp,XFS_SBS_FDBLOCKS , (int64_t )del.br_blockcount,0 ); (void)xfs_trans_reserve_quota_nblks(NULL, ip, -((long)del.br_blockcount), 0,
fs/xfs/libxfs/xfs_sb.c +2 -8
@@ -754,17 +754,11 @@ xfs_initialize_perag_data( btree += pag->pagf_btreeblks;xfs_perag_put (pag); } -/* -* Overwrite incore superblock counters with just-read data -*/ -spin_lock (&mp->m_sb_lock); + +/* Overwrite incore superblock counters with just-read data */ percpu_counter_set (&sbp->sb_ifree, ifree);percpu_counter_set (&sbp->sb_icount, ialloc);percpu_counter_set (&sbp->sb_fdblocks, bfree + bfreelst + btree); -spin_unlock (&mp->m_sb_lock); - -/* Fixup the per-cpu counters as well. */ -xfs_icsb_reinit_counters (mp);return 0 ; }
fs/xfs/xfs_fsops.c +0 -2
@@ -630,7 +630,6 @@ xfs_fs_counts( xfs_mount_t *mp, xfs_fsop_counts_t *cnt) { -xfs_icsb_sync_counters (mp,XFS_ICSB_LAZY_COUNT ); cnt->allocino =percpu_counter_read_positive (&mp->m_sb.sb_icount); cnt->freeino =percpu_counter_read_positive (&mp->m_sb.sb_ifree); cnt->freedata = percpu_counter_read_positive(&mp->m_sb.sb_fdblocks) -
@@ -694,7 +693,6 @@ xfs_reserve_blocks(*/ retry:spin_lock (&mp->m_sb_lock); -xfs_icsb_sync_counters_locked (mp,0 );/* * If our previous reservation was larger than the current value,
fs/xfs/xfs_iomap.c +0 -1
@@ -460,7 +460,6 @@ xfs_iomap_prealloc_size( alloc_blocks =XFS_FILEOFF_MIN (roundup_pow_of_two (MAXEXTLEN ), alloc_blocks); -xfs_icsb_sync_counters (mp,XFS_ICSB_LAZY_COUNT ); freesp =percpu_counter_read_positive (&mp->m_sb.sb_fdblocks);if (freesp < mp->m_low_space[XFS_LOWSP_5_PCNT ]) { shift =2 ;
fs/xfs/xfs_linux.h +0 -9
@@ -116,15 +116,6 @@ typedef __uint64_t __psunsigned_t;#undef XFS_NATIVE_HOST#endif -/* -* 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/xfs_log_recover.c +0 -3
@@ -4465,9 +4465,6 @@ xlog_do_recover(ASSERT (xfs_sb_good_version (sbp));xfs_buf_relse (bp); -/* We've re-read the superblock so re-initialize per-cpu counters */ -xfs_icsb_reinit_counters (log->l_mp); -xlog_recover_check_summary (log);/* Normal transactions can now occur */
fs/xfs/xfs_mount.c +0 -509
530 lines not on this page · raw message
fs/xfs/xfs_mount.h +2 -62
82 lines not on this page · raw message
fs/xfs/xfs_super.c +55 -21
112 lines not on this page · raw message
Signature · 6 lines
2.0.0 _______________________________________________ xfs mailing list [email protected] http://oss.sgi.com/mailman/listinfo/xfs
Re: [PATCH 5/5] xfs: Remove icsb infrastructure
Quoted 19 lines · Dave Chinner
From: Dave Chinner <[email protected]>
Now that the in-cor superblock infrastructure has been replaced with generic per-cpu counters, we don't need it anymore. Nuke it from orbit so we are sure that it won't haunt us again...
Signed-off-by Dave Chinner <[email protected]>--- fs/xfs/libxfs/xfs_bmap.c | 16 +- fs/xfs/libxfs/xfs_sb.c | 10 +- fs/xfs/xfs_fsops.c | 2 - fs/xfs/xfs_iomap.c | 1 - fs/xfs/xfs_linux.h | 9 - fs/xfs/xfs_log_recover.c | 3 - fs/xfs/xfs_mount.c | 509 ----------------------------------------------- fs/xfs/xfs_mount.h | 64 +----- fs/xfs/xfs_super.c | 76 +++++-- 9 files changed, 67 insertions(+), 623 deletions(-)
...
fs/xfs/xfs_super.c xfs_finish_flags( · line 1399
Quoted 9 lines
fs/xfs/xfs_super.c +9
-0+static int +xfs_init_percpu_counters ( +struct xfs_mount *mp) +{ +int error; + + error =percpu_counter_init (&mp->m_sb.sb_icount,0 ,GFP_KERNEL ); +if (error) +return ENOMEM ;
-ENOMEM
Brian
Quoted 79 lines
fs/xfs/xfs_super.c +46
-2+ + error =percpu_counter_init (&mp->m_sb.sb_ifree,0 ,GFP_KERNEL ); +if (error) + goto free_icount; + + error =percpu_counter_init (&mp->m_sb.sb_fdblocks,0 ,GFP_KERNEL ); +if (error) + goto free_ifree; + +return 0 ; + +free_ifree: +percpu_counter_destroy (&mp->m_sb.sb_ifree); +free_icount: +percpu_counter_destroy (&mp->m_sb.sb_icount); +return -ENOMEM ; +} + +static void +xfs_destroy_percpu_counters ( +struct xfs_mount *mp) +{ +percpu_counter_destroy (&mp->m_sb.sb_icount); +percpu_counter_destroy (&mp->m_sb.sb_ifree); +percpu_counter_destroy (&mp->m_sb.sb_fdblocks); +} + STATIC int xfs_fs_fill_super( struct super_block *sb,@@ -1455,7 +1472,7 @@ xfs_fs_fill_super(if (error) goto out_close_devices; - error =xfs_icsb_init_counters (mp); + error =xfs_init_percpu_counters (mp);if (error) goto out_destroy_workqueues;@@ -1513,7 +1530,7 @@ xfs_fs_fill_super( out_free_sb:xfs_freesb (mp); out_destroy_counters: -xfs_icsb_destroy_counters (mp); +xfs_destroy_percpu_counters (mp); out_destroy_workqueues:xfs_destroy_mount_workqueues (mp); out_close_devices:@@ -1530,6 +1547,23 @@ out_destroy_workqueues: goto out_free_sb; } +STATIC void +xfs_fs_put_super ( +struct super_block *sb) +{ +struct xfs_mount *mp =XFS_M (sb); + +xfs_filestream_unmount (mp); +xfs_unmountfs (mp); + +xfs_freesb (mp); +xfs_destroy_percpu_counters (mp); +xfs_destroy_mount_workqueues (mp); +xfs_close_devices (mp); +xfs_free_fsname (mp); +kfree (mp); +} + STATIC struct dentry * xfs_fs_mount( struct file_system_type *fs_type,Signature · 6 lines
2.0.0 _______________________________________________ xfs mailing list [email protected] http://oss.sgi.com/mailman/listinfo/xfs
_______________________________________________
xfs mailing list
[email protected]
http://oss.sgi.com/mailman/listinfo/xfs
FYI, I think we should just get rid of the horrible xfs_mod_incore_sb(_batch) interface as part of this. The patch below applies on top of your series.
fs/xfs/libxfs/xfs_bmap.c +18 -27
@@ -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_mod_incore_sb (bma->ip->i_mount, -XFS_SBS_FDBLOCKS , - -((int64_t )diff),0 ); + error =xfs_sb_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_mod_incore_sb (bma->ip->i_mount, -XFS_SBS_FDBLOCKS , - (int64_t )(da_old - temp),0 ); +xfs_sb_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_mod_incore_sb (ip->i_mount,XFS_SBS_FDBLOCKS , - (int64_t )(oldlen - newlen),0 ); +xfs_sb_mod_fdblocks (ip->i_mount, (int64_t )(oldlen - newlen), + false);/* * Nothing to do for disk quota accounting here. */
@@ -4159,19 +4157,15 @@ xfs_bmapi_reserve_delalloc( indlen = (xfs_extlen_t )xfs_bmap_worst_indlen (ip, alen);ASSERT (indlen >0 ); -if (rt) { - error =xfs_mod_incore_sb (mp,XFS_SBS_FREXTENTS , - -((int64_t )extsz),0 ); - }else { - error =xfs_mod_incore_sb (mp,XFS_SBS_FDBLOCKS , - -((int64_t )alen),0 ); - } +if (rt) + error =xfs_sb_mod_frextents (mp, -((int64_t )extsz)); +else + error =xfs_sb_mod_fdblocks (mp, -((int64_t )alen), false);if (error) goto out_unreserve_quota; - error =xfs_mod_incore_sb (mp,XFS_SBS_FDBLOCKS , - -((int64_t )indlen),0 ); + error =xfs_sb_mod_fdblocks (mp, -((int64_t )indlen), false);if (error) goto out_unreserve_blocks;
@@ -4198,9 +4192,9 @@ xfs_bmapi_reserve_delalloc( out_unreserve_blocks:if (rt) -xfs_mod_incore_sb (mp,XFS_SBS_FREXTENTS , extsz,0 ); +xfs_sb_mod_frextents (mp, extsz);else -xfs_mod_incore_sb (mp,XFS_SBS_FDBLOCKS , alen,0 ); +xfs_sb_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 +5006,8 @@ xfs_bmap_del_extent(* Nothing to do for disk quota accounting here. */ ASSERT (da_old >= da_new); -if (da_old > da_new) { -xfs_mod_incore_sb (mp,XFS_SBS_FDBLOCKS , - (int64_t )(da_old - da_new),0 ); - } +if (da_old > da_new) +xfs_sb_mod_fdblocks (mp, (int64_t )(da_old - da_new), false); done: *logflagsp = flags;return error;
@@ -5284,14 +5276,13 @@ xfs_bunmapi( rtexts =XFS_FSB_TO_B (mp, del.br_blockcount);do_div (rtexts, mp->m_sb.sb_rextsize); -xfs_mod_incore_sb (mp,XFS_SBS_FREXTENTS , - (int64_t )rtexts,0 ); +xfs_sb_mod_frextents (mp, (int64_t )rtexts); (void )xfs_trans_reserve_quota_nblks (NULL , ip, -((long )del.br_blockcount),0 ,XFS_QMOPT_RES_RTBLKS ); }else { -xfs_mod_incore_sb (mp,XFS_SBS_FDBLOCKS , - (int64_t )del.br_blockcount,0 ); +xfs_sb_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 );
fs/xfs/libxfs/xfs_format.h +0 -63
69 lines not on this page · raw message
fs/xfs/xfs_fsops.c +1 -1
@@ -749,7 +749,7 @@ out:* the extra reserve blocks from the reserve..... */ int error; - error =xfs_mod_incore_sb (mp,XFS_SBS_FDBLOCKS , fdblks_delta,0 ); + error =xfs_sb_mod_fdblocks (mp, fdblks_delta, false);if (error == -ENOSPC ) goto retry; }
fs/xfs/xfs_mount.c +99 -256
391 lines not on this page · raw message
fs/xfs/xfs_mount.h +5 -12
@@ -249,15 +249,6 @@ xfs_daddr_to_agbno(struct xfs_mount *mp, xfs_daddr_t d) }/* -* This structure is for use by the xfs_mod_incore_sb_batch() routine. -* xfs_growfs can specify a few fields which are more than int limit -*/ -typedef struct xfs_mod_sb { -xfs_sb_field_t msb_field;/* Field to modify, see below */ -int64_t msb_delta;/* Change to make to specified field */ -}xfs_mod_sb_t ; - -/* * Per-ag incore structure, copies of information in agf and agi, to improve the * performance of allocation group selection. */
@@ -313,9 +304,6 @@ extern int xfs_initialize_perag(xfs_mount_t *mp, xfs_agnumber_t agcount, xfs_agnumber_t *maxagi);extern void xfs_unmountfs (xfs_mount_t *); -extern int xfs_mod_incore_sb (xfs_mount_t *,xfs_sb_field_t ,int64_t ,int ); -extern int xfs_mod_incore_sb_batch (xfs_mount_t *,xfs_mod_sb_t *, -uint ,int );extern int xfs_mount_log_sb (xfs_mount_t *);extern struct xfs_buf *xfs_getsb (xfs_mount_t *,int );extern int xfs_readsb (xfs_mount_t *,int );
@@ -327,6 +315,11 @@ extern int xfs_dev_is_read_only(struct xfs_mount *, char *);extern void xfs_set_low_space_thresholds (struct xfs_mount *); +extern int xfs_sb_mod_fdblocks (struct xfs_mount *,int64_t ,bool ); +extern int xfs_sb_mod_frextents (struct xfs_mount *,int64_t ); +extern int xfs_sb_mod_icount (struct xfs_mount *,int64_t ); +extern int xfs_sb_mod_ifree (struct xfs_mount *,int64_t ); +#endif /* __KERNEL__ */ #endif /* __XFS_MOUNT_H__ */
fs/xfs/xfs_trans.c +133 -81
295 lines not on this page · raw message
_______________________________________________
xfs mailing list
[email protected]
http://oss.sgi.com/mailman/listinfo/xfs
Quoted 3 lines · Christoph Hellwig
FYI, I think we should just get rid of the horrible
xfs_mod_incore_sb(_batch)interface as part of this. The patch below applies on top of your series.
I like it - getting rid of those field bitmasks altogether is a great result.
It probably needs to be split up into several patches, though. I can do that over the next few days and add it to the patchset if you want. The icsb changes are 3.21 material, anyway, so there's no real hurry on this....
Cheers,
Dave.
Signature · 7 lines
Dave Chinner [email protected] _______________________________________________ xfs mailing list [email protected] http://oss.sgi.com/mailman/listinfo/xfs
Quoted 4 lines · Dave Chinner
It probably needs to be split up into several patches, though. I can do that over the next few days and add it to the patchset if you want. The icsb changes are 3.21 material, anyway, so there's no real hurry on this....
Might be best if you fold the changes for the three counters that your series touch into those patches. Then I can split the remainder up into one for the real time extents as the only one called from code outside the transction subsystem, and then the final one to redo the batch changess from the transaction code.
_______________________________________________
xfs mailing list
[email protected]
http://oss.sgi.com/mailman/listinfo/xfs
Quoted 11 lines · Christoph Hellwig
Quoted 4 lines · Dave Chinner
It probably needs to be split up into several patches, though. I can do that over the next few days and add it to the patchset if you want. The icsb changes are 3.21 material, anyway, so there's no real hurry on this....
Might be best if you fold the changes for the three counters that your series touch into those patches. Then I can split the remainder up into one for the real time extents as the only one called from code outside the transction subsystem, and then the final one to redo the batch changess from the transaction code.
Sounds like a plan to me.
Cheers,
Dave.
Signature · 7 lines
Dave Chinner [email protected] _______________________________________________ xfs mailing list [email protected] http://oss.sgi.com/mailman/listinfo/xfs