+Index: linux-2.6.18-128.1.6/fs/ext4/balloc.c
+===================================================================
+--- linux-2.6.18-128.1.6.orig/fs/ext4/balloc.c
++++ linux-2.6.18-128.1.6/fs/ext4/balloc.c
+@@ -321,15 +321,15 @@ ext4_read_block_bitmap(struct super_bloc
+ if (bh_uptodate_or_lock(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_buffer_uptodate(bh);
+ unlock_buffer(bh);
+- spin_unlock(sb_bgl_lock(EXT4_SB(sb), block_group));
++ ext4_unlock_group(sb, block_group);
+ return bh;
+ }
+- spin_unlock(sb_bgl_lock(EXT4_SB(sb), block_group));
++ ext4_unlock_group(sb, block_group);
+ if (bh_submit_read(bh) < 0) {
+ put_bh(bh);
+ ext4_error(sb, __func__,
+@@ -778,8 +778,9 @@ do_more:
+ BUFFER_TRACE(bitmap_bh, "set in b_committed_data");
+ J_ASSERT_BH(bitmap_bh,
+ bh2jh(bitmap_bh)->b_committed_data != NULL);
+- ext4_set_bit_atomic(sb_bgl_lock(sbi, block_group), bit + i,
+- bh2jh(bitmap_bh)->b_committed_data);
++ ext4_set_bit_atomic(ext4_group_lock_ptr(sb, block_group),
++ bit + i,
++ bh2jh(bitmap_bh)->b_committed_data);
+
+ /*
+ * We clear the bit in the bitmap after setting the committed
+@@ -787,7 +788,7 @@ do_more:
+ * the allocator uses.
+ */
+ 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)) {
+ jbd_unlock_bh_state(bitmap_bh);
+ ext4_error(sb, __func__,
+@@ -801,17 +802,17 @@ do_more:
+ }
+ jbd_unlock_bh_state(bitmap_bh);
+
+- spin_lock(sb_bgl_lock(sbi, block_group));
++ ext4_lock_group(sb, block_group);
+ le16_add_cpu(&desc->bg_free_blocks_count, group_freed);
+ 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, 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, block_group);
+ sbi->s_flex_groups[flex_group].free_blocks += count;
+- spin_unlock(sb_bgl_lock(sbi, flex_group));
++ ext4_unlock_group(sb, block_group);
+ }
+
+ /* We dirtied the bitmap block */
+@@ -1104,7 +1105,7 @@ repeat:
+ }
+ start = grp_goal;
+
+- if (!claim_block(sb_bgl_lock(EXT4_SB(sb), group),
++ if (!claim_block(ext4_group_lock_ptr(sb, group),
+ grp_goal, bitmap_bh)) {
+ /*
+ * The block was allocated by another thread, or it was
+@@ -1120,7 +1121,7 @@ repeat:
+ grp_goal++;
+ while (num < *count && grp_goal < end
+ && ext4_test_allocatable(grp_goal, bitmap_bh)
+- && claim_block(sb_bgl_lock(EXT4_SB(sb), group),
++ && claim_block(ext4_group_lock_ptr(sb, group),
+ grp_goal, bitmap_bh)) {
+ num++;
+ grp_goal++;
+@@ -1872,7 +1873,7 @@ allocated:
+ }
+ }
+ jbd_lock_bh_state(bitmap_bh);
+- spin_lock(sb_bgl_lock(sbi, group_no));
++ ext4_lock_group(sb, group_no);
+ if (buffer_jbd(bitmap_bh) && bh2jh(bitmap_bh)->b_committed_data) {
+ int i;
+
+@@ -1885,7 +1886,7 @@ allocated:
+ }
+ }
+ ext4_debug("found bit %d\n", grp_alloc_blk);
+- spin_unlock(sb_bgl_lock(sbi, group_no));
++ ext4_unlock_group(sb, group_no);
+ jbd_unlock_bh_state(bitmap_bh);
+ #endif
+
+@@ -1902,19 +1903,19 @@ allocated:
+ * list of some description. We don't know in advance whether
+ * the caller wants to use it as metadata or data.
+ */
+- spin_lock(sb_bgl_lock(sbi, group_no));
++ ext4_lock_group(sb, group_no);
+ if (gdp->bg_flags & cpu_to_le16(EXT4_BG_BLOCK_UNINIT))
+ gdp->bg_flags &= cpu_to_le16(~EXT4_BG_BLOCK_UNINIT);
+ le16_add_cpu(&gdp->bg_free_blocks_count, -num);
+ gdp->bg_checksum = ext4_group_desc_csum(sbi, group_no, gdp);
+- spin_unlock(sb_bgl_lock(sbi, group_no));
++ ext4_unlock_group(sb, group_no);
+ percpu_counter_sub(&sbi->s_freeblocks_counter, num);
+
+ if (sbi->s_log_groups_per_flex) {
+ ext4_group_t flex_group = ext4_flex_group(sbi, group_no);
+- spin_lock(sb_bgl_lock(sbi, flex_group));
++ ext4_lock_group(sb, flex_group);
+ sbi->s_flex_groups[flex_group].free_blocks -= num;
+- spin_unlock(sb_bgl_lock(sbi, flex_group));
++ ext4_unlock_group(sb, flex_group);
+ }
+
+ BUFFER_TRACE(gdp_bh, "journal_dirty_metadata for group descriptor");
+Index: linux-2.6.18-128.1.6/fs/ext4/ialloc.c
+===================================================================
+--- linux-2.6.18-128.1.6.orig/fs/ext4/ialloc.c
++++ linux-2.6.18-128.1.6/fs/ext4/ialloc.c
+@@ -118,15 +118,15 @@ ext4_read_inode_bitmap(struct super_bloc
+ if (bh_uptodate_or_lock(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_buffer_uptodate(bh);
+ unlock_buffer(bh);
+- spin_unlock(sb_bgl_lock(EXT4_SB(sb), block_group));
++ ext4_unlock_group(sb, block_group);
+ return bh;
+ }
+- spin_unlock(sb_bgl_lock(EXT4_SB(sb), block_group));
++ ext4_unlock_group(sb, block_group);
+ if (bh_submit_read(bh) < 0) {
+ put_bh(bh);
+ ext4_error(sb, __func__,
+@@ -221,8 +221,8 @@ void ext4_free_inode (handle_t *handle,
+ 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 {
+@@ -233,22 +233,22 @@ void ext4_free_inode (handle_t *handle,
+ if (fatal) goto error_return;
+
+ if (gdp) {
+- spin_lock(sb_bgl_lock(sbi, block_group));
++ ext4_lock_group(sb, block_group);
+ le16_add_cpu(&gdp->bg_free_inodes_count, 1);
+ if (is_directory)
+ le16_add_cpu(&gdp->bg_used_dirs_count, -1);
+ 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");
+@@ -630,7 +630,7 @@ struct inode *ext4_new_inode(handle_t *h
+ if (err)
+ goto fail;
+
+- if (ext4_set_bit_atomic(sb_bgl_lock(sbi, group),
++ if (ext4_set_bit_atomic(ext4_group_lock_ptr(sb, group),
+ ino, bitmap_bh->b_data)) {
+ printk(KERN_ERR "goal inode %lu unavailable\n", goal);
+ /* Oh well, we tried. */
+@@ -691,7 +691,7 @@ repeat_in_this_group:
+ if (err)
+ goto fail;
+
+- if (!ext4_set_bit_atomic(sb_bgl_lock(sbi, group),
++ if (!ext4_set_bit_atomic(ext4_group_lock_ptr(sb, group),
+ ino, bitmap_bh->b_data)) {
+ /* we won it */
+ BUFFER_TRACE(bitmap_bh,
+@@ -751,14 +751,14 @@ 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)) {
+ gdp->bg_flags &= cpu_to_le16(~EXT4_BG_BLOCK_UNINIT);
+ free = ext4_free_blocks_after_init(sb, group, gdp);
+ gdp->bg_free_blocks_count = cpu_to_le16(free);
+ }
+- 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) {
+@@ -771,7 +771,7 @@ got:
+ goto fail;
+ }
+
+- spin_lock(sb_bgl_lock(sbi, group));
++ ext4_lock_group(sb, group);
+ /* If we didn't allocate from within the initialized part of the inode
+ * table then we need to initialize up to this inode. */
+ if (EXT4_HAS_RO_COMPAT_FEATURE(sb, EXT4_FEATURE_RO_COMPAT_GDT_CSUM)) {
+@@ -807,7 +807,7 @@ got:
+ le16_add_cpu(&gdp->bg_used_dirs_count, 1);
+ }
+ gdp->bg_checksum = ext4_group_desc_csum(sbi, group, gdp);
+- spin_unlock(sb_bgl_lock(sbi, group));
++ ext4_unlock_group(sb, group);
+ BUFFER_TRACE(bh2, "call ext4_journal_dirty_metadata");
+ err = ext4_journal_dirty_metadata(handle, bh2);
+ if (err) goto fail;
+@@ -819,9 +819,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-2.6.18-128.1.6/fs/ext4/mballoc.c
+===================================================================
+--- linux-2.6.18-128.1.6.orig/fs/ext4/mballoc.c
++++ linux-2.6.18-128.1.6/fs/ext4/mballoc.c
+@@ -361,24 +361,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;
+@@ -789,16 +777,16 @@ static int ext4_mb_init_cache(struct pag
+ if (bh_uptodate_or_lock(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_buffer_uptodate(bh[i]);
+ unlock_buffer(bh[i]);
+- spin_unlock(sb_bgl_lock(EXT4_SB(sb), first_group + i));
++ ext4_unlock_group(sb, first_group + i);
+ continue;
+ }
+- spin_unlock(sb_bgl_lock(EXT4_SB(sb), first_group + i));
++ ext4_unlock_group(sb, first_group + i);
+ get_bh(bh[i]);
+ bh[i]->b_end_io = end_buffer_read_sync;
+ submit_bh(READ, bh[i]);
+@@ -1021,7 +1009,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;
+
+@@ -1034,12 +1022,12 @@ static void mb_clear_bits(spinlock_t *lo
+ cur += 32;
+ continue;
+ }
+- mb_clear_bit_atomic(lock, 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;
+
+@@ -1052,7 +1040,7 @@ static void mb_set_bits(spinlock_t *lock
+ cur += 32;
+ continue;
+ }
+- mb_set_bit_atomic(lock, cur, bm);
++ mb_set_bit(cur, bm);
+ cur++;
+ }
+ }
+@@ -1268,8 +1256,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;
+@@ -2651,7 +2638,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;
+@@ -3130,14 +3117,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;
+@@ -3147,10 +3137,8 @@ ext4_mb_mark_diskspace_used(struct ext4_
+ }
+ }
+ #endif
+- 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);
++ mb_set_bits(bitmap_bh->b_data, ac->ac_b_ex.fe_start,ac->ac_b_ex.fe_len);
+
+- spin_lock(sb_bgl_lock(sbi, ac->ac_b_ex.fe_group));
+ if (gdp->bg_flags & cpu_to_le16(EXT4_BG_BLOCK_UNINIT)) {
+ gdp->bg_flags &= cpu_to_le16(~EXT4_BG_BLOCK_UNINIT);
+ gdp->bg_free_blocks_count =
+@@ -3160,15 +3148,16 @@ ext4_mb_mark_diskspace_used(struct ext4_
+ }
+ le16_add_cpu(&gdp->bg_free_blocks_count, -ac->ac_b_ex.fe_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);
+
+ 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);
+@@ -3600,7 +3589,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)
+@@ -3646,8 +3635,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++;
+ }
+@@ -4901,6 +4889,13 @@ do_more:
+ if (err)
+ goto error_return;
+
++ if (ac) {
++ ac->ac_b_ex.fe_group = block_group;
++ ac->ac_b_ex.fe_start = bit;
++ ac->ac_b_ex.fe_len = count;
++ ext4_mb_store_history(ac);
++ }
++
+ err = ext4_mb_load_buddy(sb, block_group, &e4b);
+ if (err)
+ goto error_return;
+@@ -4912,42 +4907,31 @@ do_more:
+ BUG_ON(!mb_test_bit(bit + i, bitmap_bh->b_data));
+ }
+ #endif
+- 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);
+ /* We dirtied the bitmap block */
+ BUFFER_TRACE(bitmap_bh, "dirtied bitmap block");
+ err = ext4_journal_dirty_metadata(handle, bitmap_bh);
+
+- if (ac) {
+- ac->ac_b_ex.fe_group = block_group;
+- ac->ac_b_ex.fe_start = bit;
+- ac->ac_b_ex.fe_len = count;
+- ext4_mb_store_history(ac);
+- }
+-
+ if (metadata) {
+ /* blocks being freed are metadata. these blocks shouldn't
+ * be used until this transaction is committed */
+ ext4_mb_free_metadata(handle, &e4b, block_group, bit, count);
+ } else {
+- ext4_lock_group(sb, block_group);
+ 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));
+ le16_add_cpu(&gdp->bg_free_blocks_count, count);
+ 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-2.6.18-128.1.6/fs/ext4/super.c
+===================================================================
+--- linux-2.6.18-128.1.6.orig/fs/ext4/super.c
++++ linux-2.6.18-128.1.6/fs/ext4/super.c
+@@ -1934,16 +1934,18 @@ static int ext4_check_descriptors(struct
+ "(block %llu)!", 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 %lu 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))
++ if (!(sb->s_flags & MS_RDONLY)) {
++ 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);
+ }
+Index: linux-2.6.18-128.1.6/fs/ext4/ext4.h
+===================================================================
+--- linux-2.6.18-128.1.6.orig/fs/ext4/ext4.h
++++ linux-2.6.18-128.1.6/fs/ext4/ext4.h
+@@ -1303,6 +1303,33 @@ extern int ext4_get_blocks_wrap(handle_t
+ sector_t block, unsigned long max_blocks,
+ struct buffer_head *bh, int create,
+ int extend_disksize);
++
++static inline spinlock_t *ext4_group_lock_ptr(struct super_block *sb,
++ ext4_group_t group)
++{
++ struct blockgroup_lock *bgl = &EXT4_SB(sb)->s_blockgroup_lock;
++ return &bgl->locks[group & (NR_BG_LOCKS-1)].lock;
++}
++
++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)
++{
++ spin_unlock(ext4_group_lock_ptr(sb, group));
++}
++
++static inline int ext4_is_group_locked(struct super_block *sb,
++ ext4_group_t group)
++{
++ return spin_is_locked(ext4_group_lock_ptr(sb, group));
++}
++
++
++
+ #endif /* __KERNEL__ */
+
+ #endif /* _EXT4_H */
+Index: linux-2.6.18-128.1.6/fs/ext4/mballoc.h
+===================================================================
+--- linux-2.6.18-128.1.6.orig/fs/ext4/mballoc.h
++++ linux-2.6.18-128.1.6/fs/ext4/mballoc.h
+@@ -126,7 +126,6 @@ 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)))
+@@ -272,31 +271,6 @@ static void ext4_mb_put_pa(struct ext4_a
+ static int ext4_mb_init_per_dev_proc(struct super_block *sb);
+ static int ext4_mb_destroy_per_dev_proc(struct super_block *sb);
+
+-
+-static inline void ext4_lock_group(struct super_block *sb, ext4_group_t group)
+-{
+- struct ext4_group_info *grinfo = ext4_get_group_info(sb, group);
+-
+- bit_spin_lock(EXT4_GROUP_INFO_LOCKED_BIT, &(grinfo->bb_state));
+-}
+-
+-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));
+-}
+-
+-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));
+-}
+-
+ static ext4_fsblk_t ext4_grp_offs_to_block(struct super_block *sb,
+ struct ext4_free_extent *fex)
+ {
git://git.whamcloud.com / fs / lustre-release.git / commitdiff