--- /dev/null
+Index: linux-stage/fs/ext4/balloc.c
+===================================================================
+--- linux-stage.orig/fs/ext4/balloc.c
++++ linux-stage/fs/ext4/balloc.c
+@@ -329,16 +329,16 @@ ext4_read_block_bitmap(struct super_bloc
+ 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,
+@@ -454,7 +454,7 @@ void ext4_add_groupblocks(handle_t *hand
+ 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",
+@@ -464,18 +464,18 @@ void ext4_add_groupblocks(handle_t *hand
+ 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) {
+ ext4_group_t flex_group = ext4_flex_group(sbi, block_group);
+- spin_lock(sb_bgl_lock(sbi, flex_group));
++ ext4_lock_group(sb, flex_group);
+ sbi->s_flex_groups[flex_group].free_blocks += blocks_freed;
+- spin_unlock(sb_bgl_lock(sbi, flex_group));
++ ext4_unlock_group(sb, flex_group);
+ }
+ /*
+ * request to reload the buddy with the
+Index: linux-stage/fs/ext4/ext4.h
+===================================================================
+--- linux-stage.orig/fs/ext4/ext4.h
++++ linux-stage/fs/ext4/ext4.h
+@@ -1342,33 +1342,32 @@ 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);
++ struct blockgroup_lock *bgl = &EXT4_SB(sb)->s_blockgroup_lock;
++ return &bgl->locks[group & (NR_BG_LOCKS-1)].lock;
++}
+
+- 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));
+ }
+
+ /*
+Index: linux-stage/fs/ext4/ialloc.c
+===================================================================
+--- linux-stage.orig/fs/ext4/ialloc.c
++++ linux-stage/fs/ext4/ialloc.c
+@@ -123,16 +123,16 @@ ext4_read_inode_bitmap(struct super_bloc
+ 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,
+@@ -244,8 +244,8 @@ void ext4_free_inode(handle_t *handle, s
+ goto error_return;
+
+ /* Ok, now we can actually update the inode bitmaps.. */
+- if (!ext4_clear_bit_atomic(sb_bgl_lock(sbi, block_group),
+- bit, bitmap_bh->b_data))
++ if (!ext4_clear_bit_atomic(ext4_group_lock_ptr(sb, block_group),
++ bit, bitmap_bh->b_data))
+ ext4_error(sb, "ext4_free_inode",
+ "bit already cleared for inode %lu", ino);
+ else {
+@@ -256,7 +256,7 @@ void ext4_free_inode(handle_t *handle, s
+ 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) {
+@@ -265,16 +265,16 @@ void ext4_free_inode(handle_t *handle, s
+ }
+ 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);
+
+ if (sbi->s_log_groups_per_flex) {
+ flex_group = ext4_flex_group(sbi, block_group);
+- spin_lock(sb_bgl_lock(sbi, flex_group));
++ ext4_lock_group(sb, flex_group);
+ sbi->s_flex_groups[flex_group].free_inodes++;
+- spin_unlock(sb_bgl_lock(sbi, flex_group));
++ ext4_unlock_group(sb, flex_group);
+ }
+ }
+ BUFFER_TRACE(bh2, "call ext4_journal_dirty_metadata");
+@@ -595,10 +595,10 @@ static int find_group_other(struct super
+
+ /*
+ * 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,
+@@ -609,7 +609,7 @@ static int ext4_claim_inode(struct super
+ 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;
+@@ -618,7 +618,7 @@ static int ext4_claim_inode(struct super
+ 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,
+@@ -662,7 +662,7 @@ static int ext4_claim_inode(struct super
+ }
+ 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;
+ }
+
+@@ -854,7 +854,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);
+@@ -863,7 +863,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) {
+@@ -888,9 +888,9 @@ got:
+
+ if (sbi->s_log_groups_per_flex) {
+ flex_group = ext4_flex_group(sbi, group);
+- spin_lock(sb_bgl_lock(sbi, flex_group));
++ ext4_lock_group(sb, flex_group);
+ sbi->s_flex_groups[flex_group].free_inodes--;
+- spin_unlock(sb_bgl_lock(sbi, flex_group));
++ ext4_unlock_group(sb, flex_group);
+ }
+
+ inode->i_uid = current_fsuid();
+Index: linux-stage/fs/ext4/mballoc.c
+===================================================================
+--- linux-stage.orig/fs/ext4/mballoc.c
++++ linux-stage/fs/ext4/mballoc.c
+@@ -375,24 +375,12 @@ static inline void mb_set_bit(int bit, v
+ ext4_set_bit(bit, addr);
+ }
+
+-static inline void mb_set_bit_atomic(spinlock_t *lock, int bit, void *addr)
+-{
+- addr = mb_correct_addr_and_bit(&bit, addr);
+- ext4_set_bit_atomic(lock, bit, addr);
+-}
+-
+ static inline void mb_clear_bit(int bit, void *addr)
+ {
+ addr = mb_correct_addr_and_bit(&bit, addr);
+ ext4_clear_bit(bit, addr);
+ }
+
+-static inline void mb_clear_bit_atomic(spinlock_t *lock, int bit, void *addr)
+-{
+- addr = mb_correct_addr_and_bit(&bit, addr);
+- ext4_clear_bit_atomic(lock, bit, addr);
+-}
+-
+ static inline int mb_find_next_zero_bit(void *addr, int max, int start)
+ {
+ int fix = 0, ret, tmpmax;
+@@ -805,17 +793,17 @@ static int ext4_mb_init_cache(struct pag
+ unlock_buffer(bh[i]);
+ continue;
+ }
+- spin_lock(sb_bgl_lock(EXT4_SB(sb), first_group + i));
++ ext4_lock_group(sb, first_group + i);
+ if (desc->bg_flags & cpu_to_le16(EXT4_BG_BLOCK_UNINIT)) {
+ ext4_init_block_bitmap(sb, bh[i],
+ first_group + i, desc);
+ set_bitmap_uptodate(bh[i]);
+ set_buffer_uptodate(bh[i]);
+- spin_unlock(sb_bgl_lock(EXT4_SB(sb), first_group + i));
++ ext4_unlock_group(sb, first_group + i);
+ unlock_buffer(bh[i]);
+ continue;
+ }
+- spin_unlock(sb_bgl_lock(EXT4_SB(sb), first_group + i));
++ ext4_unlock_group(sb, first_group + i);
+ if (buffer_uptodate(bh[i])) {
+ /*
+ * if not uninit if bh is uptodate,
+@@ -1087,7 +1075,7 @@ static int mb_find_order_for_block(struc
+ return 0;
+ }
+
+-static void mb_clear_bits(spinlock_t *lock, void *bm, int cur, int len)
++static void mb_clear_bits(void *bm, int cur, int len)
+ {
+ __u32 *addr;
+
+@@ -1100,15 +1088,12 @@ static void mb_clear_bits(spinlock_t *lo
+ cur += 32;
+ continue;
+ }
+- if (lock)
+- mb_clear_bit_atomic(lock, cur, bm);
+- else
+- mb_clear_bit(cur, bm);
++ mb_clear_bit(cur, bm);
+ cur++;
+ }
+ }
+
+-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)
+ {
+ __u32 *addr;
+
+@@ -1121,10 +1106,7 @@ static void mb_set_bits(spinlock_t *lock
+ cur += 32;
+ continue;
+ }
+- if (lock)
+- mb_set_bit_atomic(lock, cur, bm);
+- else
+- mb_set_bit(cur, bm);
++ mb_set_bit(cur, bm);
+ cur++;
+ }
+ }
+@@ -1339,8 +1321,7 @@ static int mb_mark_used(struct ext4_budd
+ e4b->bd_info->bb_counters[ord]++;
+ }
+
+- mb_set_bits(sb_bgl_lock(EXT4_SB(e4b->bd_sb), ex->fe_group),
+- EXT4_MB_BITMAP(e4b), ex->fe_start, len0);
++ mb_set_bits(EXT4_MB_BITMAP(e4b), ex->fe_start, len0);
+ mb_check_buddy(e4b);
+
+ return ret;
+@@ -2841,7 +2822,7 @@ int ext4_mb_init(struct super_block *sb,
+ return 0;
+ }
+
+-/* need to called with ext4 group lock (ext4_lock_group) */
++/* need to called with the ext4 group lock held */
+ static void ext4_mb_cleanup_pa(struct ext4_group_info *grp)
+ {
+ struct ext4_prealloc_space *pa;
+@@ -3240,14 +3221,17 @@ ext4_mb_mark_diskspace_used(struct ext4_
+ * Fix the bitmap and repeat the block allocation
+ * We leak some of the blocks here.
+ */
+- mb_set_bits(sb_bgl_lock(sbi, ac->ac_b_ex.fe_group),
+- bitmap_bh->b_data, ac->ac_b_ex.fe_start,
+- ac->ac_b_ex.fe_len);
++ ext4_lock_group(sb, ac->ac_b_ex.fe_group);
++ mb_set_bits(bitmap_bh->b_data, ac->ac_b_ex.fe_start,
++ ac->ac_b_ex.fe_len);
++ ext4_unlock_group(sb, ac->ac_b_ex.fe_group);
+ err = ext4_journal_dirty_metadata(handle, bitmap_bh);
+ if (!err)
+ err = -EAGAIN;
+ goto out_err;
+ }
++
++ ext4_lock_group(sb, ac->ac_b_ex.fe_group);
+ #ifdef AGGRESSIVE_CHECK
+ {
+ int i;
+@@ -3257,9 +3241,7 @@ ext4_mb_mark_diskspace_used(struct ext4_
+ }
+ }
+ #endif
+- spin_lock(sb_bgl_lock(sbi, ac->ac_b_ex.fe_group));
+- mb_set_bits(NULL, bitmap_bh->b_data,
+- ac->ac_b_ex.fe_start, ac->ac_b_ex.fe_len);
++ mb_set_bits(bitmap_bh->b_data, ac->ac_b_ex.fe_start,ac->ac_b_ex.fe_len);
+ if (gdp->bg_flags & cpu_to_le16(EXT4_BG_BLOCK_UNINIT)) {
+ gdp->bg_flags &= cpu_to_le16(~EXT4_BG_BLOCK_UNINIT);
+ ext4_free_blks_set(sb, gdp,
+@@ -3269,7 +3251,8 @@ ext4_mb_mark_diskspace_used(struct ext4_
+ len = ext4_free_blks_count(sb, gdp) - ac->ac_b_ex.fe_len;
+ ext4_free_blks_set(sb, gdp, len);
+ gdp->bg_checksum = ext4_group_desc_csum(sbi, ac->ac_b_ex.fe_group, gdp);
+- spin_unlock(sb_bgl_lock(sbi, ac->ac_b_ex.fe_group));
++
++ ext4_unlock_group(sb, ac->ac_b_ex.fe_group);
+ percpu_counter_sub(&sbi->s_freeblocks_counter, ac->ac_b_ex.fe_len);
+ /*
+ * Now reduce the dirty block count also. Should not go negative
+@@ -3284,9 +3267,9 @@ ext4_mb_mark_diskspace_used(struct ext4_
+ if (sbi->s_log_groups_per_flex) {
+ ext4_group_t flex_group = ext4_flex_group(sbi,
+ ac->ac_b_ex.fe_group);
+- spin_lock(sb_bgl_lock(sbi, flex_group));
++ ext4_lock_group(sb, flex_group);
+ sbi->s_flex_groups[flex_group].free_blocks -= ac->ac_b_ex.fe_len;
+- spin_unlock(sb_bgl_lock(sbi, flex_group));
++ ext4_unlock_group(sb, flex_group);
+ }
+
+ err = ext4_journal_dirty_metadata(handle, bitmap_bh);
+@@ -3686,7 +3669,7 @@ ext4_mb_use_preallocated(struct ext4_all
+ * the function goes through all block freed in the group
+ * but not yet committed and marks them used in in-core bitmap.
+ * buddy must be generated from this bitmap
+- * Need to be called with ext4 group lock (ext4_lock_group)
++ * Need to be called with the ext4 group lock held
+ */
+ static void ext4_mb_generate_from_freelist(struct super_block *sb, void *bitmap,
+ ext4_group_t group)
+@@ -3700,9 +3683,7 @@ static void ext4_mb_generate_from_freeli
+
+ while (n) {
+ entry = rb_entry(n, struct ext4_free_data, node);
+- mb_set_bits(sb_bgl_lock(EXT4_SB(sb), group),
+- bitmap, entry->start_blk,
+- entry->count);
++ mb_set_bits(bitmap, entry->start_blk, entry->count);
+ n = rb_next(n);
+ }
+ return;
+@@ -3744,7 +3725,7 @@ int ext4_mb_check_ondisk_bitmap(struct s
+ /*
+ * the function goes through all preallocation in this group and marks them
+ * used in in-core bitmap. buddy must be generated from this bitmap
+- * Need to be called with ext4 group lock (ext4_lock_group)
++ * Need to be called with ext4 group lock held.
+ */
+ static int ext4_mb_generate_from_pa(struct super_block *sb, void *bitmap,
+ ext4_group_t group)
+@@ -3790,8 +3771,7 @@ static int ext4_mb_generate_from_pa(stru
+ continue;
+ }
+ BUG_ON(groupnr != group);
+- mb_set_bits(sb_bgl_lock(EXT4_SB(sb), group),
+- bitmap, start, len);
++ mb_set_bits(bitmap, start, len);
+ preallocated += len;
+ count++;
+ }
+@@ -5124,36 +5104,32 @@ do_more:
+ new_entry->group = block_group;
+ new_entry->count = count;
+ new_entry->t_tid = handle->h_transaction->t_tid;
++
+ ext4_lock_group(sb, block_group);
+- mb_clear_bits(sb_bgl_lock(sbi, block_group), bitmap_bh->b_data,
+- bit, count);
++ mb_clear_bits(bitmap_bh->b_data, bit, count);
+ ext4_mb_free_metadata(handle, &e4b, new_entry);
+- ext4_unlock_group(sb, block_group);
+ } else {
+- ext4_lock_group(sb, block_group);
+ /* need to update group_info->bb_free and bitmap
+ * with group lock held. generate_buddy look at
+ * them with group lock_held
+ */
+- mb_clear_bits(sb_bgl_lock(sbi, block_group), bitmap_bh->b_data,
+- bit, count);
++ ext4_lock_group(sb, block_group);
++ mb_clear_bits(bitmap_bh->b_data, bit, count);
+ mb_free_blocks(inode, &e4b, bit, count);
+ ext4_mb_return_to_preallocation(inode, &e4b, block, count);
+- ext4_unlock_group(sb, block_group);
+ }
+
+- spin_lock(sb_bgl_lock(sbi, block_group));
+ ret = ext4_free_blks_count(sb, gdp) + count;
+ ext4_free_blks_set(sb, gdp, ret);
+ 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_add(&sbi->s_freeblocks_counter, count);
+
+ if (sbi->s_log_groups_per_flex) {
+ ext4_group_t flex_group = ext4_flex_group(sbi, block_group);
+- spin_lock(sb_bgl_lock(sbi, flex_group));
++ ext4_lock_group(sb, flex_group);
+ sbi->s_flex_groups[flex_group].free_blocks += count;
+- spin_unlock(sb_bgl_lock(sbi, flex_group));
++ ext4_unlock_group(sb, flex_group);
+ }
+
+ ext4_mb_release_desc(&e4b);
+Index: linux-stage/fs/ext4/super.c
+===================================================================
+--- linux-stage.orig/fs/ext4/super.c
++++ linux-stage/fs/ext4/super.c
+@@ -2020,18 +2020,18 @@ static int ext4_check_descriptors(struct
+ "(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);
+ }
git://git.whamcloud.com / fs / lustre-release.git / commitdiff