[PATCH] reiserfs: clean up bitmap block buffer head references

Similar to the SB_JOURNAL cleanup that was accepted a while ago, this patch
uses a temporary variable for buffer head references from the bitmap info
array.

This makes the code much more readable in some areas.

It also uses proper reference counting, doing a get_bh() after using the
pointer from the array and brelse()'ing it later.  This may seem silly, but a
later patch will replace the simple temporary variables with an actual read,
so the reference freeing will be used then.

Signed-off-by: Jeff Mahoney <jeffm@suse.com>
Cc: <reiserfs-dev@namesys.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>

2 files changed, 71 insertions, 49 deletions

diff --git a/fs/reiserfs/bitmap.c b/fs/reiserfs/bitmap.c
index 1022347a211..44d9410e9d6 100644
--- a/fs/reiserfs/bitmap.c
+++ b/fs/reiserfs/bitmap.c
@@ -59,6 +59,7 @@ static inline void get_bit_address(struct super_block *s,
 int is_reusable(struct super_block *s, b_blocknr_t block, int bit_value)
 {
         int bmap, offset;
+        struct buffer_head *bh;
 
         if (block == 0 || block >= SB_BLOCK_COUNT(s)) {
                 reiserfs_warning(s,
@@ -96,20 +97,21 @@ int is_reusable(struct super_block *s, b_blocknr_t block, int bit_value)
                 return 0;
         }
 
-        if ((bit_value == 0 &&
-             reiserfs_test_le_bit(offset, SB_AP_BITMAP(s)[bmap].bh->b_data)) ||
-            (bit_value == 1 &&
-             reiserfs_test_le_bit(offset, SB_AP_BITMAP(s)[bmap].bh->b_data) == 0)) {
+        bh = SB_AP_BITMAP(s)[bmap].bh;
+        get_bh(bh);
+
+        if ((bit_value == 0 && reiserfs_test_le_bit(offset, bh->b_data)) ||
+            (bit_value == 1 && reiserfs_test_le_bit(offset, bh->b_data) == 0)) {
                 reiserfs_warning(s,
                                  "vs-4040: is_reusable: corresponding bit of block %lu does not "
                                  "match required value (bmap==%d, offset==%d) test_bit==%d",
-                                 block, bmap, offset, reiserfs_test_le_bit(offset,
-                                                                   SB_AP_BITMAP
-                                                                   (s)[bmap].bh->
-                                                                   b_data));
+                                 block, bmap, offset,
+                                 reiserfs_test_le_bit(offset, bh->b_data));
 
+                brelse(bh);
                 return 0;
         }
+        brelse(bh);
 
         if (bit_value == 0 && block == SB_ROOT_BLOCK(s)) {
                 reiserfs_warning(s,
@@ -151,6 +153,7 @@ static int scan_bitmap_block(struct reiserfs_transaction_handle *th,
 {
         struct super_block *s = th->t_super;
         struct reiserfs_bitmap_info *bi = &SB_AP_BITMAP(s)[bmap_n];
+        struct buffer_head *bh;
         int end, next;
         int org = *beg;
 
@@ -169,22 +172,28 @@ static int scan_bitmap_block(struct reiserfs_transaction_handle *th,
                                  bmap_n);
                 return 0;
         }
-        if (buffer_locked(bi->bh)) {
+        bh = bi->bh;
+        get_bh(bh);
+
+        if (buffer_locked(bh)) {
                 PROC_INFO_INC(s, scan_bitmap.wait);
-                __wait_on_buffer(bi->bh);
+                __wait_on_buffer(bh);
         }
 
         while (1) {
               cont:
-                if (bi->free_count < min)
+                if (bi->free_count < min) {
+                        brelse(bh);
                         return 0;       // No free blocks in this bitmap
+                }
 
                 /* search for a first zero bit -- beggining of a window */
                 *beg = reiserfs_find_next_zero_le_bit
-                    ((unsigned long *)(bi->bh->b_data), boundary, *beg);
+                    ((unsigned long *)(bh->b_data), boundary, *beg);
 
                 if (*beg + min > boundary) {    /* search for a zero bit fails or the rest of bitmap block
                                                  * cannot contain a zero window of minimum size */
+                        brelse(bh);
                         return 0;
                 }
 
@@ -193,7 +202,7 @@ static int scan_bitmap_block(struct reiserfs_transaction_handle *th,
                 /* first zero bit found; we check next bits */
                 for (end = *beg + 1;; end++) {
                         if (end >= *beg + max || end >= boundary
-                            || reiserfs_test_le_bit(end, bi->bh->b_data)) {
+                            || reiserfs_test_le_bit(end, bh->b_data)) {
                                 next = end;
                                 break;
                         }
@@ -207,12 +216,12 @@ static int scan_bitmap_block(struct reiserfs_transaction_handle *th,
                  * (end) points to one bit after the window end */
                 if (end - *beg >= min) {        /* it seems we have found window of proper size */
                         int i;
-                        reiserfs_prepare_for_journal(s, bi->bh, 1);
+                        reiserfs_prepare_for_journal(s, bh, 1);
                         /* try to set all blocks used checking are they still free */
                         for (i = *beg; i < end; i++) {
                                 /* It seems that we should not check in journal again. */
                                 if (reiserfs_test_and_set_le_bit
-                                    (i, bi->bh->b_data)) {
+                                    (i, bh->b_data)) {
                                         /* bit was set by another process
                                          * while we slept in prepare_for_journal() */
                                         PROC_INFO_INC(s, scan_bitmap.stolen);
@@ -224,17 +233,16 @@ static int scan_bitmap_block(struct reiserfs_transaction_handle *th,
                                         /* otherwise we clear all bit were set ... */
                                         while (--i >= *beg)
                                                 reiserfs_test_and_clear_le_bit
-                                                    (i, bi->bh->b_data);
-                                        reiserfs_restore_prepared_buffer(s,
-                                                                         bi->
-                                                                         bh);
+                                                    (i, bh->b_data);
+                                        reiserfs_restore_prepared_buffer(s, bh);
                                         *beg = org;
                                         /* ... and search again in current block from beginning */
                                         goto cont;
                                 }
                         }
                         bi->free_count -= (end - *beg);
-                        journal_mark_dirty(th, s, bi->bh);
+                        journal_mark_dirty(th, s, bh);
+                        brelse(bh);
 
                         /* free block count calculation */
                         reiserfs_prepare_for_journal(s, SB_BUFFER_WITH_SB(s),
@@ -383,7 +391,7 @@ static void _reiserfs_free_block(struct reiserfs_transaction_handle *th,
 {
         struct super_block *s = th->t_super;
         struct reiserfs_super_block *rs;
-        struct buffer_head *sbh;
+        struct buffer_head *sbh, *bmbh;
         struct reiserfs_bitmap_info *apbi;
         int nr, offset;
 
@@ -404,16 +412,20 @@ static void _reiserfs_free_block(struct reiserfs_transaction_handle *th,
                 return;
         }
 
-        reiserfs_prepare_for_journal(s, apbi[nr].bh, 1);
+        bmbh = apbi[nr].bh;
+        get_bh(bmbh);
+
+        reiserfs_prepare_for_journal(s, bmbh, 1);
 
         /* clear bit for the given block in bit map */
-        if (!reiserfs_test_and_clear_le_bit(offset, apbi[nr].bh->b_data)) {
+        if (!reiserfs_test_and_clear_le_bit(offset, bmbh->b_data)) {
                 reiserfs_warning(s, "vs-4080: reiserfs_free_block: "
                                  "free_block (%s:%lu)[dev:blocknr]: bit already cleared",
                                  reiserfs_bdevname(s), block);
         }
         apbi[nr].free_count++;
-        journal_mark_dirty(th, s, apbi[nr].bh);
+        journal_mark_dirty(th, s, bmbh);
+        brelse(bmbh);
 
         reiserfs_prepare_for_journal(s, sbh, 1);
         /* update super block */
diff --git a/fs/reiserfs/resize.c b/fs/reiserfs/resize.c
index 39cc7f47f5d..958b7597899 100644
--- a/fs/reiserfs/resize.c
+++ b/fs/reiserfs/resize.c
@@ -22,6 +22,7 @@ int reiserfs_resize(struct super_block *s, unsigned long block_count_new)
         int err = 0;
         struct reiserfs_super_block *sb;
         struct reiserfs_bitmap_info *bitmap;
+        struct reiserfs_bitmap_info *info;
         struct reiserfs_bitmap_info *old_bitmap = SB_AP_BITMAP(s);
         struct buffer_head *bh;
         struct reiserfs_transaction_handle th;
@@ -127,16 +128,19 @@ int reiserfs_resize(struct super_block *s, unsigned long block_count_new)
                  * transaction begins, and the new bitmaps don't matter if the
                  * transaction fails. */
                 for (i = bmap_nr; i < bmap_nr_new; i++) {
-                        bitmap[i].bh = sb_getblk(s, i * s->s_blocksize * 8);
-                        memset(bitmap[i].bh->b_data, 0, sb_blocksize(sb));
-                        reiserfs_test_and_set_le_bit(0, bitmap[i].bh->b_data);
-
-                        set_buffer_uptodate(bitmap[i].bh);
-                        mark_buffer_dirty(bitmap[i].bh);
-                        sync_dirty_buffer(bitmap[i].bh);
+                        bh = sb_getblk(s, i * s->s_blocksize * 8);
+                        get_bh(bh);
+                        memset(bh->b_data, 0, sb_blocksize(sb));
+                        reiserfs_test_and_set_le_bit(0, bh->b_data);
+
+                        set_buffer_uptodate(bh);
+                        mark_buffer_dirty(bh);
+                        sync_dirty_buffer(bh);
                         // update bitmap_info stuff
                         bitmap[i].first_zero_hint = 1;
                         bitmap[i].free_count = sb_blocksize(sb) * 8 - 1;
+                        bitmap[i].bh = bh;
+                        brelse(bh);
                 }
                 /* free old bitmap blocks array */
                 SB_AP_BITMAP(s) = bitmap;
@@ -150,30 +154,36 @@ int reiserfs_resize(struct super_block *s, unsigned long block_count_new)
         if (err)
                 return err;
 
-        /* correct last bitmap blocks in old and new disk layout */
-        reiserfs_prepare_for_journal(s, SB_AP_BITMAP(s)[bmap_nr - 1].bh, 1);
+        /* Extend old last bitmap block - new blocks have been made available */
+        info = SB_AP_BITMAP(s) + bmap_nr - 1;
+        bh = info->bh;
+        get_bh(bh);
+
+        reiserfs_prepare_for_journal(s, bh, 1);
         for (i = block_r; i < s->s_blocksize * 8; i++)
-                reiserfs_test_and_clear_le_bit(i,
-                                               SB_AP_BITMAP(s)[bmap_nr -
-                                                               1].bh->b_data);
-        SB_AP_BITMAP(s)[bmap_nr - 1].free_count += s->s_blocksize * 8 - block_r;
-        if (!SB_AP_BITMAP(s)[bmap_nr - 1].first_zero_hint)
-                SB_AP_BITMAP(s)[bmap_nr - 1].first_zero_hint = block_r;
+                reiserfs_test_and_clear_le_bit(i, bh->b_data);
+        info->free_count += s->s_blocksize * 8 - block_r;
+        if (!info->first_zero_hint)
+                info->first_zero_hint = block_r;
+
+        journal_mark_dirty(&th, s, bh);
+        brelse(bh);
 
-        journal_mark_dirty(&th, s, SB_AP_BITMAP(s)[bmap_nr - 1].bh);
+        /* Correct new last bitmap block - It may not be full */
+        info = SB_AP_BITMAP(s) + bmap_nr_new - 1;
+        bh = info->bh;
+        get_bh(bh);
 
-        reiserfs_prepare_for_journal(s, SB_AP_BITMAP(s)[bmap_nr_new - 1].bh, 1);
+        reiserfs_prepare_for_journal(s, bh, 1);
         for (i = block_r_new; i < s->s_blocksize * 8; i++)
-                reiserfs_test_and_set_le_bit(i,
-                                             SB_AP_BITMAP(s)[bmap_nr_new -
-                                                             1].bh->b_data);
-        journal_mark_dirty(&th, s, SB_AP_BITMAP(s)[bmap_nr_new - 1].bh);
+                reiserfs_test_and_set_le_bit(i, bh->b_data);
+        journal_mark_dirty(&th, s, bh);
+        brelse(bh);
 
-        SB_AP_BITMAP(s)[bmap_nr_new - 1].free_count -=
-            s->s_blocksize * 8 - block_r_new;
+        info->free_count -= s->s_blocksize * 8 - block_r_new;
         /* Extreme case where last bitmap is the only valid block in itself. */
-        if (!SB_AP_BITMAP(s)[bmap_nr_new - 1].free_count)
-                SB_AP_BITMAP(s)[bmap_nr_new - 1].first_zero_hint = 0;
+        if (!info->free_count)
+                info->first_zero_hint = 0;
         /* update super */
         reiserfs_prepare_for_journal(s, SB_BUFFER_WITH_SB(s), 1);
         free_blocks = SB_FREE_BLOCKS(s);