1 files changed, 45 insertions, 30 deletions

diff --git a/fs/reiserfs/resize.c b/fs/reiserfs/resize.c
index a4ef5cd606eb..6052d323bc9a 100644
--- a/fs/reiserfs/resize.c
+++ b/fs/reiserfs/resize.c
@@ -53,8 +53,10 @@ int reiserfs_resize(struct super_block *s, unsigned long block_count_new)
         }
         bforget(bh);
 
-        /* old disk layout detection; those partitions can be mounted, but
-         * cannot be resized */
+        /*
+         * old disk layout detection; those partitions can be mounted, but
+         * cannot be resized
+         */
         if (SB_BUFFER_WITH_SB(s)->b_blocknr * SB_BUFFER_WITH_SB(s)->b_size
             != REISERFS_DISK_OFFSET_IN_BYTES) {
                 printk
@@ -86,12 +88,14 @@ int reiserfs_resize(struct super_block *s, unsigned long block_count_new)
                             ("reiserfs_resize: unable to allocate memory for journal bitmaps\n");
                         return -ENOMEM;
                 }
-                /* the new journal bitmaps are zero filled, now we copy in the bitmap
-                 ** node pointers from the old journal bitmap structs, and then
-                 ** transfer the new data structures into the journal struct.
-                 **
-                 ** using the copy_size var below allows this code to work for
-                 ** both shrinking and expanding the FS.
+                /*
+                 * the new journal bitmaps are zero filled, now we copy i
+                 * the bitmap node pointers from the old journal bitmap
+                 * structs, and then transfer the new data structures
+                 * into the journal struct.
+                 *
+                 * using the copy_size var below allows this code to work for
+                 * both shrinking and expanding the FS.
                  */
                 copy_size = bmap_nr_new < bmap_nr ? bmap_nr_new : bmap_nr;
                 copy_size =
@@ -101,36 +105,45 @@ int reiserfs_resize(struct super_block *s, unsigned long block_count_new)
                         jb = SB_JOURNAL(s)->j_list_bitmap + i;
                         memcpy(jbitmap[i].bitmaps, jb->bitmaps, copy_size);
 
-                        /* just in case vfree schedules on us, copy the new
-                         ** pointer into the journal struct before freeing the
-                         ** old one
+                        /*
+                         * just in case vfree schedules on us, copy the new
+                         * pointer into the journal struct before freeing the
+                         * old one
                          */
                         node_tmp = jb->bitmaps;
                         jb->bitmaps = jbitmap[i].bitmaps;
                         vfree(node_tmp);
                 }
 
-                /* allocate additional bitmap blocks, reallocate array of bitmap
-                 * block pointers */
+                /*
+                 * allocate additional bitmap blocks, reallocate
+                 * array of bitmap block pointers
+                 */
                 bitmap =
                     vzalloc(sizeof(struct reiserfs_bitmap_info) * bmap_nr_new);
                 if (!bitmap) {
-                        /* Journal bitmaps are still supersized, but the memory isn't
-                         * leaked, so I guess it's ok */
+                        /*
+                         * Journal bitmaps are still supersized, but the
+                         * memory isn't leaked, so I guess it's ok
+                         */
                         printk("reiserfs_resize: unable to allocate memory.\n");
                         return -ENOMEM;
                 }
                 for (i = 0; i < bmap_nr; i++)
                         bitmap[i] = old_bitmap[i];
 
-                /* This doesn't go through the journal, but it doesn't have to.
-                 * The changes are still atomic: We're synced up when the journal
-                 * transaction begins, and the new bitmaps don't matter if the
-                 * transaction fails. */
+                /*
+                 * This doesn't go through the journal, but it doesn't have to.
+                 * The changes are still atomic: We're synced up when the
+                 * journal transaction begins, and the new bitmaps don't
+                 * matter if the transaction fails.
+                 */
                 for (i = bmap_nr; i < bmap_nr_new; i++) {
                         int depth;
-                        /* don't use read_bitmap_block since it will cache
-                         * the uninitialized bitmap */
+                        /*
+                         * don't use read_bitmap_block since it will cache
+                         * the uninitialized bitmap
+                         */
                         depth = reiserfs_write_unlock_nested(s);
                         bh = sb_bread(s, i * s->s_blocksize * 8);
                         reiserfs_write_lock_nested(s, depth);
@@ -147,7 +160,7 @@ int reiserfs_resize(struct super_block *s, unsigned long block_count_new)
                         depth = reiserfs_write_unlock_nested(s);
                         sync_dirty_buffer(bh);
                         reiserfs_write_lock_nested(s, depth);
-                        // update bitmap_info stuff
+                        /* update bitmap_info stuff */
                         bitmap[i].free_count = sb_blocksize(sb) * 8 - 1;
                         brelse(bh);
                 }
@@ -156,9 +169,11 @@ int reiserfs_resize(struct super_block *s, unsigned long block_count_new)
                 vfree(old_bitmap);
         }
 
-        /* begin transaction, if there was an error, it's fine. Yes, we have
+        /*
+         * begin transaction, if there was an error, it's fine. Yes, we have
          * incorrect bitmaps now, but none of it is ever going to touch the
-         * disk anyway. */
+         * disk anyway.
+         */
         err = journal_begin(&th, s, 10);
         if (err)
                 return err;
@@ -167,7 +182,7 @@ int reiserfs_resize(struct super_block *s, unsigned long block_count_new)
         info = SB_AP_BITMAP(s) + bmap_nr - 1;
         bh = reiserfs_read_bitmap_block(s, bmap_nr - 1);
         if (!bh) {
-                int jerr = journal_end(&th, s, 10);
+                int jerr = journal_end(&th);
                 if (jerr)
                         return jerr;
                 return -EIO;
@@ -178,14 +193,14 @@ int reiserfs_resize(struct super_block *s, unsigned long block_count_new)
                 reiserfs_clear_le_bit(i, bh->b_data);
         info->free_count += s->s_blocksize * 8 - block_r;
 
-        journal_mark_dirty(&th, s, bh);
+        journal_mark_dirty(&th, bh);
         brelse(bh);
 
         /* Correct new last bitmap block - It may not be full */
         info = SB_AP_BITMAP(s) + bmap_nr_new - 1;
         bh = reiserfs_read_bitmap_block(s, bmap_nr_new - 1);
         if (!bh) {
-                int jerr = journal_end(&th, s, 10);
+                int jerr = journal_end(&th);
                 if (jerr)
                         return jerr;
                 return -EIO;
@@ -194,7 +209,7 @@ int reiserfs_resize(struct super_block *s, unsigned long block_count_new)
         reiserfs_prepare_for_journal(s, bh, 1);
         for (i = block_r_new; i < s->s_blocksize * 8; i++)
                 reiserfs_set_le_bit(i, bh->b_data);
-        journal_mark_dirty(&th, s, bh);
+        journal_mark_dirty(&th, bh);
         brelse(bh);
 
         info->free_count -= s->s_blocksize * 8 - block_r_new;
@@ -207,8 +222,8 @@ int reiserfs_resize(struct super_block *s, unsigned long block_count_new)
         PUT_SB_BLOCK_COUNT(s, block_count_new);
         PUT_SB_BMAP_NR(s, bmap_would_wrap(bmap_nr_new) ? : bmap_nr_new);
 
-        journal_mark_dirty(&th, s, SB_BUFFER_WITH_SB(s));
+        journal_mark_dirty(&th, SB_BUFFER_WITH_SB(s));
 
         SB_JOURNAL(s)->j_must_wait = 1;
-        return journal_end(&th, s, 10);
+        return journal_end(&th);
 }