Convert ext4_lock_group to use sb_bgl_lock
RFC PATCH 1/1 Convert ext4_lock_group to use sb_bgl_lock
We have sb_bgl_lock() and ext4_group_info.bb_state
bit spinlock to protech group information. The later is only used within mballoc code. Consolidate them to use sb_bgl_lock(). This makes the mballoc.c code much simpler and also avoid confusion with two locks protecting same info.
--- fs/ext4/balloc.c | 12 ++++---- fs/ext4/ext4.h | 19 +++++------- fs/ext4/ext4_sb.h | 5 --- fs/ext4/ialloc.c | 29 +++++++++---------- fs/ext4/mballoc.c | 78 ++++++++++++++++++---------------------------------- fs/ext4/super.c | 6 ++-- 6 files changed, 58 insertions(+), 91 deletions(-)
fs/ext4/balloc.c +6 -6
@@ -326,16 +326,16 @@ ext4_read_block_bitmap(struct super_block *sb, ext4_group_t block_group)unlock_buffer (bh);return bh; } -spin_lock (sb_bgl_lock (EXT4_SB (sb), block_group)); +ext4_lock_group (sb, block_group);if (desc->bg_flags &cpu_to_le16 (EXT4_BG_BLOCK_UNINIT )) {ext4_init_block_bitmap (sb, bh, block_group, desc);set_bitmap_uptodate (bh);set_buffer_uptodate (bh); -spin_unlock (sb_bgl_lock (EXT4_SB (sb), block_group)); +ext4_unlock_group (sb, block_group);unlock_buffer (bh);return bh; } -spin_unlock (sb_bgl_lock (EXT4_SB (sb), block_group)); +ext4_unlock_group (sb, block_group);if (buffer_uptodate (bh)) {/* * if not uninit if bh is uptodate,
@@ -451,7 +451,7 @@ void ext4_add_groupblocks(handle_t *handle, struct super_block *sb,down_write (&grp->alloc_sem);for (i =0 , blocks_freed =0 ; i < count; i++) {BUFFER_TRACE (bitmap_bh,"clear bit" ); -if (!ext4_clear_bit_atomic (sb_bgl_lock (sbi, block_group), +if (!ext4_clear_bit_atomic (ext4_group_lock (sb, block_group), bit + i, bitmap_bh->b_data)) { ext4_error(sb, __func__, "bit already cleared for block %llu",
@@ -461,11 +461,11 @@ void ext4_add_groupblocks(handle_t *handle, struct super_block *sb, blocks_freed++; } } -spin_lock (sb_bgl_lock (sbi, block_group)); +ext4_lock_group (sb, block_group); blk_free_count = blocks_freed +ext4_free_blks_count (sb, desc);ext4_free_blks_set (sb, desc, blk_free_count); desc->bg_checksum =ext4_group_desc_csum (sbi, block_group, desc); -spin_unlock (sb_bgl_lock (sbi, block_group)); +ext4_unlock_group (sb, block_group);percpu_counter_add (&sbi->s_freeblocks_counter, blocks_freed);if (sbi->s_log_groups_per_flex) {
fs/ext4/ext4.h +8 -11
@@ -1283,33 +1283,30 @@ struct ext4_group_info { };#define EXT4_GROUP_INFO_NEED_INIT_BIT 0 -#define EXT4_GROUP_INFO_LOCKED_BIT 1#define EXT4_MB_GRP_NEED_INIT (grp) \ (test_bit(EXT4_GROUP_INFO_NEED_INIT_BIT, &((grp)->bb_state))) -static inline void ext4_lock_group (struct super_block *sb,ext4_group_t group) +static inline spinlock_t *ext4_group_lock (struct super_block *sb,ext4_group_t group) { -struct ext4_group_info *grinfo =ext4_get_group_info (sb, group); +return bgl_lock_ptr (EXT4_SB (sb)->s_blockgroup_lock, group); +} -bit_spin_lock (EXT4_GROUP_INFO_LOCKED_BIT , &(grinfo->bb_state)); +static inline void ext4_lock_group (struct super_block *sb,ext4_group_t group) +{ +spin_lock (ext4_group_lock (sb, group)); }static inline void ext4_unlock_group (struct super_block *sb,ext4_group_t group) { -struct ext4_group_info *grinfo =ext4_get_group_info (sb, group); - -bit_spin_unlock (EXT4_GROUP_INFO_LOCKED_BIT , &(grinfo->bb_state)); +spin_unlock (ext4_group_lock (sb, group)); }static inline int ext4_is_group_locked (struct super_block *sb,ext4_group_t group) { -struct ext4_group_info *grinfo =ext4_get_group_info (sb, group); - -return bit_spin_is_locked (EXT4_GROUP_INFO_LOCKED_BIT , - &(grinfo->bb_state)); +return spin_is_locked (ext4_group_lock (sb, group)); }/*
fs/ext4/ext4_sb.h +0 -5
@@ -152,10 +152,5 @@ struct ext4_sb_info { struct flex_groups *s_flex_groups; }; -static inline spinlock_t * -sb_bgl_lock (struct ext4_sb_info *sbi,unsigned int block_group) -{ -return bgl_lock_ptr (sbi->s_blockgroup_lock, block_group); -}#endif /* _EXT4_SB */
fs/ext4/ialloc.c +14 -15
@@ -123,16 +123,16 @@ ext4_read_inode_bitmap(struct super_block *sb, ext4_group_t block_group)unlock_buffer (bh);return bh; } -spin_lock (sb_bgl_lock (EXT4_SB (sb), block_group)); +ext4_lock_group (sb, block_group);if (desc->bg_flags &cpu_to_le16 (EXT4_BG_INODE_UNINIT )) {ext4_init_inode_bitmap (sb, bh, block_group, desc);set_bitmap_uptodate (bh);set_buffer_uptodate (bh); -spin_unlock (sb_bgl_lock (EXT4_SB (sb), block_group)); +ext4_unlock_group (sb, block_group);unlock_buffer (bh);return bh; } -spin_unlock (sb_bgl_lock (EXT4_SB (sb), block_group)); +ext4_unlock_group (sb, block_group);if (buffer_uptodate (bh)) {/* * if not uninit if bh is uptodate,
@@ -247,9 +247,8 @@ void ext4_free_inode(handle_t *handle, struct inode *inode) goto error_return;/* Ok, now we can actually update the inode bitmaps.. */ -spin_lock (sb_bgl_lock (sbi, block_group)); - cleared =ext4_clear_bit (bit, bitmap_bh->b_data); -spin_unlock (sb_bgl_lock (sbi, block_group)); + cleared =ext4_clear_bit_atomic (ext4_group_lock (sb, block_group), + bit, bitmap_bh->b_data);if (!cleared)ext4_error (sb,"ext4_free_inode" ,"bit already cleared for inode %lu" , ino);
@@ -261,7 +260,7 @@ void ext4_free_inode(handle_t *handle, struct inode *inode)if (fatal) goto error_return;if (gdp) { -spin_lock (sb_bgl_lock (sbi, block_group)); +ext4_lock_group (sb, block_group); count =ext4_free_inodes_count (sb, gdp) +1 ;ext4_free_inodes_set (sb, gdp, count);if (is_directory) {
@@ -277,7 +276,7 @@ void ext4_free_inode(handle_t *handle, struct inode *inode) } gdp->bg_checksum =ext4_group_desc_csum (sbi, block_group, gdp); -spin_unlock (sb_bgl_lock (sbi, block_group)); +ext4_unlock_group (sb, block_group);percpu_counter_inc (&sbi->s_freeinodes_counter);if (is_directory)percpu_counter_dec (&sbi->s_dirs_counter);
@@ -708,10 +707,10 @@ static int find_group_other(struct super_block *sb, struct inode *parent,/* * claim the inode from the inode bitmap. If the group -* is uninit we need to take the groups's sb_bgl_lock +* is uninit we need to take the groups's ext4_group_lock * and clear the uninit flag. The inode bitmap update * and group desc uninit flag clear should be done -* after holding sb_bgl_lock so that ext4_read_inode_bitmap +* after holding ext4_group_lock so that ext4_read_inode_bitmap * doesn't race with the ext4_claim_inode */ static int ext4_claim_inode(struct super_block *sb,
@@ -722,7 +721,7 @@ static int ext4_claim_inode(struct super_block *sb,struct ext4_sb_info *sbi =EXT4_SB (sb);struct ext4_group_desc *gdp =ext4_get_group_desc (sb, group,NULL ); -spin_lock (sb_bgl_lock (sbi, group)); +ext4_lock_group (sb, group);if (ext4_set_bit (ino, inode_bitmap_bh->b_data)) {/* not a free inode */ retval =1 ;
@@ -731,7 +730,7 @@ static int ext4_claim_inode(struct super_block *sb, ino++;if ((group ==0 && ino <EXT4_FIRST_INO (sb)) || ino >EXT4_INODES_PER_GROUP (sb)) { -spin_unlock (sb_bgl_lock (sbi, group)); +ext4_unlock_group (sb, group); ext4_error(sb, __func__, "reserved inode or inode > inodes count - " "block_group = %u, inode=%lu", group,
@@ -780,7 +779,7 @@ static int ext4_claim_inode(struct super_block *sb, } gdp->bg_checksum =ext4_group_desc_csum (sbi, group, gdp); err_ret: -spin_unlock (sb_bgl_lock (sbi, group)); +ext4_unlock_group (sb, group);return retval; }
@@ -938,7 +937,7 @@ got: } free =0 ; -spin_lock (sb_bgl_lock (sbi, group)); +ext4_lock_group (sb, group);/* recheck and clear flag under lock if we still need to */ if (gdp->bg_flags &cpu_to_le16 (EXT4_BG_BLOCK_UNINIT )) { free =ext4_free_blocks_after_init (sb, group, gdp);
@@ -947,7 +946,7 @@ got: gdp->bg_checksum =ext4_group_desc_csum (sbi, group, gdp); } -spin_unlock (sb_bgl_lock (sbi, group)); +ext4_unlock_group (sb, group);/* Don't need to dirty bitmap block if we didn't change it */ if (free) {
fs/ext4/mballoc.c +27 -51
205 lines not on this page · raw message
fs/ext4/super.c +3 -3
@@ -1744,18 +1744,18 @@ static int ext4_check_descriptors(struct super_block *sb) "(block %llu)!\n", i, inode_table);return 0 ; } -spin_lock (sb_bgl_lock (sbi, i)); +ext4_lock_group (sb, i);if (!ext4_group_desc_csum_verify (sbi, i, gdp)) {printk (KERN_ERR "EXT4-fs: ext4_check_descriptors: " "Checksum for group %u failed (%u!=%u)\n" , i,le16_to_cpu (ext4_group_desc_csum (sbi, i, gdp)),le16_to_cpu (gdp->bg_checksum));if (!(sb->s_flags &MS_RDONLY )) { -spin_unlock (sb_bgl_lock (sbi, i)); +ext4_unlock_group (sb, i);return 0 ; } } -spin_unlock (sb_bgl_lock (sbi, i)); +ext4_unlock_group (sb, i);if (!flexbg_flag) first_block +=EXT4_BLOCKS_PER_GROUP (sb); }
Signature · 1 line
tg: (ce8a742..) ext4_lock_group_conversion (depends on: master)
fs/ext4/ext4.h struct ext4_group_info { · line 1298
Quoted 9 lines · Aneesh Kumar
fs/ext4/ext4.h +6
-0+static inline spinlock_t *ext4_group_lock (struct super_block *sb,ext4_group_t group) { +return bgl_lock_ptr (EXT4_SB (sb)->s_blockgroup_lock, group); +} +static inline void ext4_lock_group (struct super_block *sb,ext4_group_t group) +{ +spin_lock (ext4_group_lock (sb, group)); }
I find it a bit confusing to have both ext4_group_lock() and ext4_lock_group() as it isn't obvious without looking at the functions which one is which.
I'd rather have a function name like "ext4_group_lock_ptr()" or similar, which is pretty unambiguous.
fs/ext4/mballoc.c static void mb_clear_bits(spinlock_t *lock, void *bm, int cur, int len) · line 1087
Quoted 2 lines
fs/ext4/mballoc.c +1
-1-static void mb_set_bits (spinlock_t *lock,void *bm,int cur,int len) +static void mb_set_bits (void *bm,int cur,int len)
It also wouldn't be a terrible idea to make the mb_set_bits() function arguments match the name/order of mb_set_bit():
static inline void mb_set_bit(int bit, void *addr)
static void mb_set_bits(void *bm, int cur, int len)
They should be "bit, addr" and "bit, addr, len", to be more consistent with ext4_set_bit(). Stuff for a separate patch, however.
Cheers, Andreas
--
Andreas Dilger
Sr. Staff Engineer, Lustre Group
Sun Microsystems of Canada, Inc.
Theodore Ts'o
maintainerPATCH 1/1 ext4: Convert ext4_lock_group to use sb_bgl_lock
From: Aneesh Kumar K.V <[email protected]>
We have sb_bgl_lock() and ext4_group_info.bb_state
bit spinlock to protech group information. The later is only used within mballoc code. Consolidate them to use sb_bgl_lock(). This makes the mballoc.c code much simpler and also avoid confusion with two locks protecting same info.
---
This is what I've checked into the ext4 patch queue. It has the change suggested by Andreas to rename ext4_group_lock() to ext4_group_lock_ptr().
fs/ext4/balloc.c | 12 ++++---- fs/ext4/ext4.h | 26 ++++++----------- fs/ext4/ialloc.c | 29 +++++++++---------- fs/ext4/mballoc.c | 78 ++++++++++++++++++---------------------------------- fs/ext4/super.c | 6 ++-- 5 files changed, 59 insertions(+), 92 deletions(-)
fs/ext4/balloc.c +6 -6
@@ -326,16 +326,16 @@ ext4_read_block_bitmap(struct super_block *sb, ext4_group_t block_group)unlock_buffer (bh);return bh; } -spin_lock (sb_bgl_lock (EXT4_SB (sb), block_group)); +ext4_lock_group (sb, block_group);if (desc->bg_flags &cpu_to_le16 (EXT4_BG_BLOCK_UNINIT )) {ext4_init_block_bitmap (sb, bh, block_group, desc);set_bitmap_uptodate (bh);set_buffer_uptodate (bh); -spin_unlock (sb_bgl_lock (EXT4_SB (sb), block_group)); +ext4_unlock_group (sb, block_group);unlock_buffer (bh);return bh; } -spin_unlock (sb_bgl_lock (EXT4_SB (sb), block_group)); +ext4_unlock_group (sb, block_group);if (buffer_uptodate (bh)) {/* * if not uninit if bh is uptodate,
@@ -451,7 +451,7 @@ void ext4_add_groupblocks(handle_t *handle, struct super_block *sb,down_write (&grp->alloc_sem);for (i =0 , blocks_freed =0 ; i < count; i++) {BUFFER_TRACE (bitmap_bh,"clear bit" ); -if (!ext4_clear_bit_atomic (sb_bgl_lock (sbi, block_group), +if (!ext4_clear_bit_atomic (ext4_group_lock_ptr (sb, block_group), bit + i, bitmap_bh->b_data)) { ext4_error(sb, __func__, "bit already cleared for block %llu",
@@ -461,11 +461,11 @@ void ext4_add_groupblocks(handle_t *handle, struct super_block *sb, blocks_freed++; } } -spin_lock (sb_bgl_lock (sbi, block_group)); +ext4_lock_group (sb, block_group); blk_free_count = blocks_freed +ext4_free_blks_count (sb, desc);ext4_free_blks_set (sb, desc, blk_free_count); desc->bg_checksum =ext4_group_desc_csum (sbi, block_group, desc); -spin_unlock (sb_bgl_lock (sbi, block_group)); +ext4_unlock_group (sb, block_group);percpu_counter_add (&sbi->s_freeblocks_counter, blocks_freed);if (sbi->s_log_groups_per_flex) {
fs/ext4/ext4.h +9 -17
@@ -964,12 +964,6 @@ static inline int ext4_valid_inum(struct super_block *sb, unsigned long ino) (ino >=EXT4_FIRST_INO (sb) && ino <= le32_to_cpu(EXT4_SB(sb)->s_es->s_inodes_count)); } - -static inline spinlock_t * -sb_bgl_lock (struct ext4_sb_info *sbi,unsigned int block_group) -{ -return bgl_lock_ptr (sbi->s_blockgroup_lock, block_group); -}#else /* Assume that user mode programs are passing in an ext4fs superblock, not * a kernel struct super_block. This will allow us to call the feature-test
@@ -1569,33 +1563,31 @@ struct ext4_group_info { };#define EXT4_GROUP_INFO_NEED_INIT_BIT 0 -#define EXT4_GROUP_INFO_LOCKED_BIT 1#define EXT4_MB_GRP_NEED_INIT (grp) \ (test_bit(EXT4_GROUP_INFO_NEED_INIT_BIT, &((grp)->bb_state))) -static inline void ext4_lock_group (struct super_block *sb,ext4_group_t group) +static inline spinlock_t *ext4_group_lock_ptr (struct super_block *sb, +ext4_group_t group) { -struct ext4_group_info *grinfo =ext4_get_group_info (sb, group); +return bgl_lock_ptr (EXT4_SB (sb)->s_blockgroup_lock, group); +} -bit_spin_lock (EXT4_GROUP_INFO_LOCKED_BIT , &(grinfo->bb_state)); +static inline void ext4_lock_group (struct super_block *sb,ext4_group_t group) +{ +spin_lock (ext4_group_lock_ptr (sb, group)); }static inline void ext4_unlock_group (struct super_block *sb,ext4_group_t group) { -struct ext4_group_info *grinfo =ext4_get_group_info (sb, group); - -bit_spin_unlock (EXT4_GROUP_INFO_LOCKED_BIT , &(grinfo->bb_state)); +spin_unlock (ext4_group_lock_ptr (sb, group)); }static inline int ext4_is_group_locked (struct super_block *sb,ext4_group_t group) { -struct ext4_group_info *grinfo =ext4_get_group_info (sb, group); - -return bit_spin_is_locked (EXT4_GROUP_INFO_LOCKED_BIT , - &(grinfo->bb_state)); +return spin_is_locked (ext4_group_lock_ptr (sb, group)); }/*
fs/ext4/ialloc.c +14 -15
@@ -122,16 +122,16 @@ ext4_read_inode_bitmap(struct super_block *sb, ext4_group_t block_group)unlock_buffer (bh);return bh; } -spin_lock (sb_bgl_lock (EXT4_SB (sb), block_group)); +ext4_lock_group (sb, block_group);if (desc->bg_flags &cpu_to_le16 (EXT4_BG_INODE_UNINIT )) {ext4_init_inode_bitmap (sb, bh, block_group, desc);set_bitmap_uptodate (bh);set_buffer_uptodate (bh); -spin_unlock (sb_bgl_lock (EXT4_SB (sb), block_group)); +ext4_unlock_group (sb, block_group);unlock_buffer (bh);return bh; } -spin_unlock (sb_bgl_lock (EXT4_SB (sb), block_group)); +ext4_unlock_group (sb, block_group);if (buffer_uptodate (bh)) {/* * if not uninit if bh is uptodate,
@@ -246,9 +246,8 @@ void ext4_free_inode(handle_t *handle, struct inode *inode) goto error_return;/* Ok, now we can actually update the inode bitmaps.. */ -spin_lock (sb_bgl_lock (sbi, block_group)); - cleared =ext4_clear_bit (bit, bitmap_bh->b_data); -spin_unlock (sb_bgl_lock (sbi, block_group)); + cleared =ext4_clear_bit_atomic (ext4_group_lock_ptr (sb, block_group), + bit, bitmap_bh->b_data);if (!cleared)ext4_error (sb,"ext4_free_inode" ,"bit already cleared for inode %lu" , ino);
@@ -260,7 +259,7 @@ void ext4_free_inode(handle_t *handle, struct inode *inode)if (fatal) goto error_return;if (gdp) { -spin_lock (sb_bgl_lock (sbi, block_group)); +ext4_lock_group (sb, block_group); count =ext4_free_inodes_count (sb, gdp) +1 ;ext4_free_inodes_set (sb, gdp, count);if (is_directory) {
@@ -276,7 +275,7 @@ void ext4_free_inode(handle_t *handle, struct inode *inode) } gdp->bg_checksum =ext4_group_desc_csum (sbi, block_group, gdp); -spin_unlock (sb_bgl_lock (sbi, block_group)); +ext4_unlock_group (sb, block_group);percpu_counter_inc (&sbi->s_freeinodes_counter);if (is_directory)percpu_counter_dec (&sbi->s_dirs_counter);
@@ -707,10 +706,10 @@ static int find_group_other(struct super_block *sb, struct inode *parent,/* * claim the inode from the inode bitmap. If the group -* is uninit we need to take the groups's sb_bgl_lock +* is uninit we need to take the groups's ext4_group_lock * and clear the uninit flag. The inode bitmap update * and group desc uninit flag clear should be done -* after holding sb_bgl_lock so that ext4_read_inode_bitmap +* after holding ext4_group_lock so that ext4_read_inode_bitmap * doesn't race with the ext4_claim_inode */ static int ext4_claim_inode(struct super_block *sb,
@@ -721,7 +720,7 @@ static int ext4_claim_inode(struct super_block *sb,struct ext4_sb_info *sbi =EXT4_SB (sb);struct ext4_group_desc *gdp =ext4_get_group_desc (sb, group,NULL ); -spin_lock (sb_bgl_lock (sbi, group)); +ext4_lock_group (sb, group);if (ext4_set_bit (ino, inode_bitmap_bh->b_data)) {/* not a free inode */ retval =1 ;
@@ -730,7 +729,7 @@ static int ext4_claim_inode(struct super_block *sb, ino++;if ((group ==0 && ino <EXT4_FIRST_INO (sb)) || ino >EXT4_INODES_PER_GROUP (sb)) { -spin_unlock (sb_bgl_lock (sbi, group)); +ext4_unlock_group (sb, group); ext4_error(sb, __func__, "reserved inode or inode > inodes count - " "block_group = %u, inode=%lu", group,
@@ -779,7 +778,7 @@ static int ext4_claim_inode(struct super_block *sb, } gdp->bg_checksum =ext4_group_desc_csum (sbi, group, gdp); err_ret: -spin_unlock (sb_bgl_lock (sbi, group)); +ext4_unlock_group (sb, group);return retval; }
@@ -935,7 +934,7 @@ got: } free =0 ; -spin_lock (sb_bgl_lock (sbi, group)); +ext4_lock_group (sb, group);/* recheck and clear flag under lock if we still need to */ if (gdp->bg_flags &cpu_to_le16 (EXT4_BG_BLOCK_UNINIT )) { free =ext4_free_blocks_after_init (sb, group, gdp);
@@ -944,7 +943,7 @@ got: gdp->bg_checksum =ext4_group_desc_csum (sbi, group, gdp); } -spin_unlock (sb_bgl_lock (sbi, group)); +ext4_unlock_group (sb, group);/* Don't need to dirty bitmap block if we didn't change it */ if (free) {
fs/ext4/mballoc.c +27 -51
205 lines not on this page · raw message
fs/ext4/super.c +3 -3
@@ -1784,18 +1784,18 @@ static int ext4_check_descriptors(struct super_block *sb) "(block %llu)!\n", i, inode_table);return 0 ; } -spin_lock (sb_bgl_lock (sbi, i)); +ext4_lock_group (sb, i);if (!ext4_group_desc_csum_verify (sbi, i, gdp)) {printk (KERN_ERR "EXT4-fs: ext4_check_descriptors: " "Checksum for group %u failed (%u!=%u)\n" , i,le16_to_cpu (ext4_group_desc_csum (sbi, i, gdp)),le16_to_cpu (gdp->bg_checksum));if (!(sb->s_flags &MS_RDONLY )) { -spin_unlock (sb_bgl_lock (sbi, i)); +ext4_unlock_group (sb, i);return 0 ; } } -spin_unlock (sb_bgl_lock (sbi, i)); +ext4_unlock_group (sb, i);if (!flexbg_flag) first_block +=EXT4_BLOCKS_PER_GROUP (sb); }
Signature · 1 line
1.6.0.4
PATCH 1/1 ext4: Convert ext4_lock_group to use sb_bgl_lock
We have sb_bgl_lock() and ext4_group_info.bb_state
bit spinlock to protech group information. The later is only used within mballoc code. Consolidate them to use sb_bgl_lock(). This makes the mballoc.c code much simpler and also avoid confusion with two locks protecting same info.
---
This patch also change mb_set_bits from
static void mb_set_bits(spinlock_t *lock, void *bm, int cur, int len)
to
static void mb_set_bits(int cur, void *bm, int len)
as per Andreas suggesion.
fs/ext4/balloc.c | 12 ++++---- fs/ext4/ext4.h | 26 ++++++----------- fs/ext4/ialloc.c | 29 +++++++++---------- fs/ext4/mballoc.c | 79 +++++++++++++++++++---------------------------------- fs/ext4/super.c | 6 ++-- 5 files changed, 60 insertions(+), 92 deletions(-)
fs/ext4/balloc.c +6 -6
@@ -326,16 +326,16 @@ ext4_read_block_bitmap(struct super_block *sb, ext4_group_t block_group)unlock_buffer (bh);return bh; } -spin_lock (sb_bgl_lock (EXT4_SB (sb), block_group)); +ext4_lock_group (sb, block_group);if (desc->bg_flags &cpu_to_le16 (EXT4_BG_BLOCK_UNINIT )) {ext4_init_block_bitmap (sb, bh, block_group, desc);set_bitmap_uptodate (bh);set_buffer_uptodate (bh); -spin_unlock (sb_bgl_lock (EXT4_SB (sb), block_group)); +ext4_unlock_group (sb, block_group);unlock_buffer (bh);return bh; } -spin_unlock (sb_bgl_lock (EXT4_SB (sb), block_group)); +ext4_unlock_group (sb, block_group);if (buffer_uptodate (bh)) {/* * if not uninit if bh is uptodate,
@@ -451,7 +451,7 @@ void ext4_add_groupblocks(handle_t *handle, struct super_block *sb,down_write (&grp->alloc_sem);for (i =0 , blocks_freed =0 ; i < count; i++) {BUFFER_TRACE (bitmap_bh,"clear bit" ); -if (!ext4_clear_bit_atomic (sb_bgl_lock (sbi, block_group), +if (!ext4_clear_bit_atomic (ext4_group_lock_ptr (sb, block_group), bit + i, bitmap_bh->b_data)) { ext4_error(sb, __func__, "bit already cleared for block %llu",
@@ -461,11 +461,11 @@ void ext4_add_groupblocks(handle_t *handle, struct super_block *sb, blocks_freed++; } } -spin_lock (sb_bgl_lock (sbi, block_group)); +ext4_lock_group (sb, block_group); blk_free_count = blocks_freed +ext4_free_blks_count (sb, desc);ext4_free_blks_set (sb, desc, blk_free_count); desc->bg_checksum =ext4_group_desc_csum (sbi, block_group, desc); -spin_unlock (sb_bgl_lock (sbi, block_group)); +ext4_unlock_group (sb, block_group);percpu_counter_add (&sbi->s_freeblocks_counter, blocks_freed);if (sbi->s_log_groups_per_flex) {
fs/ext4/ext4.h +9 -17
@@ -964,12 +964,6 @@ static inline int ext4_valid_inum(struct super_block *sb, unsigned long ino) (ino >=EXT4_FIRST_INO (sb) && ino <= le32_to_cpu(EXT4_SB(sb)->s_es->s_inodes_count)); } - -static inline spinlock_t * -sb_bgl_lock (struct ext4_sb_info *sbi,unsigned int block_group) -{ -return bgl_lock_ptr (sbi->s_blockgroup_lock, block_group); -}#else /* Assume that user mode programs are passing in an ext4fs superblock, not * a kernel struct super_block. This will allow us to call the feature-test
@@ -1569,33 +1563,31 @@ struct ext4_group_info { };#define EXT4_GROUP_INFO_NEED_INIT_BIT 0 -#define EXT4_GROUP_INFO_LOCKED_BIT 1#define EXT4_MB_GRP_NEED_INIT (grp) \ (test_bit(EXT4_GROUP_INFO_NEED_INIT_BIT, &((grp)->bb_state))) -static inline void ext4_lock_group (struct super_block *sb,ext4_group_t group) +static inline spinlock_t *ext4_group_lock_ptr (struct super_block *sb, +ext4_group_t group) { -struct ext4_group_info *grinfo =ext4_get_group_info (sb, group); +return bgl_lock_ptr (EXT4_SB (sb)->s_blockgroup_lock, group); +} -bit_spin_lock (EXT4_GROUP_INFO_LOCKED_BIT , &(grinfo->bb_state)); +static inline void ext4_lock_group (struct super_block *sb,ext4_group_t group) +{ +spin_lock (ext4_group_lock_ptr (sb, group)); }static inline void ext4_unlock_group (struct super_block *sb,ext4_group_t group) { -struct ext4_group_info *grinfo =ext4_get_group_info (sb, group); - -bit_spin_unlock (EXT4_GROUP_INFO_LOCKED_BIT , &(grinfo->bb_state)); +spin_unlock (ext4_group_lock_ptr (sb, group)); }static inline int ext4_is_group_locked (struct super_block *sb,ext4_group_t group) { -struct ext4_group_info *grinfo =ext4_get_group_info (sb, group); - -return bit_spin_is_locked (EXT4_GROUP_INFO_LOCKED_BIT , - &(grinfo->bb_state)); +return spin_is_locked (ext4_group_lock_ptr (sb, group)); }/*
fs/ext4/ialloc.c +14 -15
@@ -122,16 +122,16 @@ ext4_read_inode_bitmap(struct super_block *sb, ext4_group_t block_group)unlock_buffer (bh);return bh; } -spin_lock (sb_bgl_lock (EXT4_SB (sb), block_group)); +ext4_lock_group (sb, block_group);if (desc->bg_flags &cpu_to_le16 (EXT4_BG_INODE_UNINIT )) {ext4_init_inode_bitmap (sb, bh, block_group, desc);set_bitmap_uptodate (bh);set_buffer_uptodate (bh); -spin_unlock (sb_bgl_lock (EXT4_SB (sb), block_group)); +ext4_unlock_group (sb, block_group);unlock_buffer (bh);return bh; } -spin_unlock (sb_bgl_lock (EXT4_SB (sb), block_group)); +ext4_unlock_group (sb, block_group);if (buffer_uptodate (bh)) {/* * if not uninit if bh is uptodate,
@@ -246,9 +246,8 @@ void ext4_free_inode(handle_t *handle, struct inode *inode) goto error_return;/* Ok, now we can actually update the inode bitmaps.. */ -spin_lock (sb_bgl_lock (sbi, block_group)); - cleared =ext4_clear_bit (bit, bitmap_bh->b_data); -spin_unlock (sb_bgl_lock (sbi, block_group)); + cleared =ext4_clear_bit_atomic (ext4_group_lock_ptr (sb, block_group), + bit, bitmap_bh->b_data);if (!cleared)ext4_error (sb,"ext4_free_inode" ,"bit already cleared for inode %lu" , ino);
@@ -260,7 +259,7 @@ void ext4_free_inode(handle_t *handle, struct inode *inode)if (fatal) goto error_return;if (gdp) { -spin_lock (sb_bgl_lock (sbi, block_group)); +ext4_lock_group (sb, block_group); count =ext4_free_inodes_count (sb, gdp) +1 ;ext4_free_inodes_set (sb, gdp, count);if (is_directory) {
@@ -276,7 +275,7 @@ void ext4_free_inode(handle_t *handle, struct inode *inode) } gdp->bg_checksum =ext4_group_desc_csum (sbi, block_group, gdp); -spin_unlock (sb_bgl_lock (sbi, block_group)); +ext4_unlock_group (sb, block_group);percpu_counter_inc (&sbi->s_freeinodes_counter);if (is_directory)percpu_counter_dec (&sbi->s_dirs_counter);
@@ -707,10 +706,10 @@ static int find_group_other(struct super_block *sb, struct inode *parent,/* * claim the inode from the inode bitmap. If the group -* is uninit we need to take the groups's sb_bgl_lock +* is uninit we need to take the groups's ext4_group_lock * and clear the uninit flag. The inode bitmap update * and group desc uninit flag clear should be done -* after holding sb_bgl_lock so that ext4_read_inode_bitmap +* after holding ext4_group_lock so that ext4_read_inode_bitmap * doesn't race with the ext4_claim_inode */ static int ext4_claim_inode(struct super_block *sb,
@@ -721,7 +720,7 @@ static int ext4_claim_inode(struct super_block *sb,struct ext4_sb_info *sbi =EXT4_SB (sb);struct ext4_group_desc *gdp =ext4_get_group_desc (sb, group,NULL ); -spin_lock (sb_bgl_lock (sbi, group)); +ext4_lock_group (sb, group);if (ext4_set_bit (ino, inode_bitmap_bh->b_data)) {/* not a free inode */ retval =1 ;
@@ -730,7 +729,7 @@ static int ext4_claim_inode(struct super_block *sb, ino++;if ((group ==0 && ino <EXT4_FIRST_INO (sb)) || ino >EXT4_INODES_PER_GROUP (sb)) { -spin_unlock (sb_bgl_lock (sbi, group)); +ext4_unlock_group (sb, group); ext4_error(sb, __func__, "reserved inode or inode > inodes count - " "block_group = %u, inode=%lu", group,
@@ -779,7 +778,7 @@ static int ext4_claim_inode(struct super_block *sb, } gdp->bg_checksum =ext4_group_desc_csum (sbi, group, gdp); err_ret: -spin_unlock (sb_bgl_lock (sbi, group)); +ext4_unlock_group (sb, group);return retval; }
@@ -935,7 +934,7 @@ struct inode *ext4_new_inode(handle_t *handle, struct inode *dir, int mode) } free =0 ; -spin_lock (sb_bgl_lock (sbi, group)); +ext4_lock_group (sb, group);/* recheck and clear flag under lock if we still need to */ if (gdp->bg_flags &cpu_to_le16 (EXT4_BG_BLOCK_UNINIT )) { free =ext4_free_blocks_after_init (sb, group, gdp);
@@ -944,7 +943,7 @@ struct inode *ext4_new_inode(handle_t *handle, struct inode *dir, int mode) gdp->bg_checksum =ext4_group_desc_csum (sbi, group, gdp); } -spin_unlock (sb_bgl_lock (sbi, group)); +ext4_unlock_group (sb, group);/* Don't need to dirty bitmap block if we didn't change it */ if (free) {
fs/ext4/mballoc.c +28 -51
206 lines not on this page · raw message
fs/ext4/super.c +3 -3
@@ -1784,18 +1784,18 @@ static int ext4_check_descriptors(struct super_block *sb) "(block %llu)!\n", i, inode_table);return 0 ; } -spin_lock (sb_bgl_lock (sbi, i)); +ext4_lock_group (sb, i);if (!ext4_group_desc_csum_verify (sbi, i, gdp)) {printk (KERN_ERR "EXT4-fs: ext4_check_descriptors: " "Checksum for group %u failed (%u!=%u)\n" , i,le16_to_cpu (ext4_group_desc_csum (sbi, i, gdp)),le16_to_cpu (gdp->bg_checksum));if (!(sb->s_flags &MS_RDONLY )) { -spin_unlock (sb_bgl_lock (sbi, i)); +ext4_unlock_group (sb, i);return 0 ; } } -spin_unlock (sb_bgl_lock (sbi, i)); +ext4_unlock_group (sb, i);if (!flexbg_flag) first_block +=EXT4_BLOCKS_PER_GROUP (sb); }
Signature · 1 line
1.6.3.rc4
Theodore Tso
maintainerRe: [PATCH -V2] ext4: Convert ext4_lock_group to use sb_bgl_lock
Quoted 9 lines · Aneesh Kumar K.V
This patch also change
mb_set_bitsfrom
static voidmb_set_bits(spinlock_t *lock, void *bm, int cur, int len)to
static void
mb_set_bits(int cur, void *bm, int len)as per Andreas suggesion.
Could you separate this change out as a separate patch? As Andreas' pointed out, that really should be a separate change
Thanks!!
- Ted