1 files changed, 167 insertions, 92 deletions

diff --git a/fs/reiserfs/bitmap.c b/fs/reiserfs/bitmap.c
index 1bcffeab713c..dc198bc64c61 100644
--- a/fs/reiserfs/bitmap.c
+++ b/fs/reiserfs/bitmap.c
@@ -50,8 +50,10 @@ static inline void get_bit_address(struct super_block *s,
                                    unsigned int *bmap_nr,
                                    unsigned int *offset)
 {
-        /* It is in the bitmap block number equal to the block
-         * number divided by the number of bits in a block. */
+        /*
+         * It is in the bitmap block number equal to the block
+         * number divided by the number of bits in a block.
+         */
         *bmap_nr = block >> (s->s_blocksize_bits + 3);
         /* Within that bitmap block it is located at bit offset *offset. */
         *offset = block & ((s->s_blocksize << 3) - 1);
@@ -71,10 +73,12 @@ int is_reusable(struct super_block *s, b_blocknr_t block, int bit_value)
 
         get_bit_address(s, block, &bmap, &offset);
 
-        /* Old format filesystem? Unlikely, but the bitmaps are all up front so
-         * we need to account for it. */
+        /*
+         * Old format filesystem? Unlikely, but the bitmaps are all
+         * up front so we need to account for it.
+         */
         if (unlikely(test_bit(REISERFS_OLD_FORMAT,
-                              &(REISERFS_SB(s)->s_properties)))) {
+                              &REISERFS_SB(s)->s_properties))) {
                 b_blocknr_t bmap1 = REISERFS_SB(s)->s_sbh->b_blocknr + 1;
                 if (block >= bmap1 &&
                     block <= bmap1 + bmap_count) {
@@ -108,8 +112,11 @@ int is_reusable(struct super_block *s, b_blocknr_t block, int bit_value)
         return 1;
 }
 
-/* searches in journal structures for a given block number (bmap, off). If block
-   is found in reiserfs journal it suggests next free block candidate to test. */
+/*
+ * Searches in journal structures for a given block number (bmap, off).
+ * If block is found in reiserfs journal it suggests next free block
+ * candidate to test.
+ */
 static inline int is_block_in_journal(struct super_block *s, unsigned int bmap,
                                       int off, int *next)
 {
@@ -120,7 +127,7 @@ static inline int is_block_in_journal(struct super_block *s, unsigned int bmap,
                         *next = tmp;
                         PROC_INFO_INC(s, scan_bitmap.in_journal_hint);
                 } else {
-                        (*next) = off + 1;      /* inc offset to avoid looping. */
+                        (*next) = off + 1;  /* inc offset to avoid looping. */
                         PROC_INFO_INC(s, scan_bitmap.in_journal_nohint);
                 }
                 PROC_INFO_INC(s, scan_bitmap.retry);
@@ -129,8 +136,10 @@ static inline int is_block_in_journal(struct super_block *s, unsigned int bmap,
         return 0;
 }
 
-/* it searches for a window of zero bits with given minimum and maximum lengths in one bitmap
- * block; */
+/*
+ * Searches for a window of zero bits with given minimum and maximum
+ * lengths in one bitmap block
+ */
 static int scan_bitmap_block(struct reiserfs_transaction_handle *th,
                              unsigned int bmap_n, int *beg, int boundary,
                              int min, int max, int unfm)
@@ -145,10 +154,6 @@ static int scan_bitmap_block(struct reiserfs_transaction_handle *th,
         RFALSE(bmap_n >= reiserfs_bmap_count(s), "Bitmap %u is out of "
                "range (0..%u)", bmap_n, reiserfs_bmap_count(s) - 1);
         PROC_INFO_INC(s, scan_bitmap.bmap);
-/* this is unclear and lacks comments, explain how journal bitmaps
-   work here for the reader.  Convey a sense of the design here. What
-   is a window? */
-/* - I mean `a window of zero bits' as in description of this function - Zam. */
 
         if (!bi) {
                 reiserfs_error(s, "jdm-4055", "NULL bitmap info pointer "
@@ -161,18 +166,21 @@ static int scan_bitmap_block(struct reiserfs_transaction_handle *th,
                 return 0;
 
         while (1) {
-              cont:
+cont:
                 if (bi->free_count < min) {
                         brelse(bh);
-                        return 0;       // No free blocks in this bitmap
+                        return 0;       /* No free blocks in this bitmap */
                 }
 
                 /* search for a first zero bit -- beginning of a window */
                 *beg = reiserfs_find_next_zero_le_bit
                     ((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 */
+                /*
+                 * search for a zero bit fails or the rest of bitmap block
+                 * cannot contain a zero window of minimum size
+                 */
+                if (*beg + min > boundary) {
                         brelse(bh);
                         return 0;
                 }
@@ -186,49 +194,75 @@ static int scan_bitmap_block(struct reiserfs_transaction_handle *th,
                                 next = end;
                                 break;
                         }
-                        /* finding the other end of zero bit window requires looking into journal structures (in
-                         * case of searching for free blocks for unformatted nodes) */
+
+                        /*
+                         * finding the other end of zero bit window requires
+                         * looking into journal structures (in case of
+                         * searching for free blocks for unformatted nodes)
+                         */
                         if (unfm && is_block_in_journal(s, bmap_n, end, &next))
                                 break;
                 }
 
-                /* now (*beg) points to beginning of zero bits window,
-                 * (end) points to one bit after the window end */
-                if (end - *beg >= min) {        /* it seems we have found window of proper size */
+                /*
+                 * now (*beg) points to beginning of zero bits window,
+                 * (end) points to one bit after the window end
+                 */
+
+                /* found window of proper size */
+                if (end - *beg >= min) {
                         int i;
                         reiserfs_prepare_for_journal(s, bh, 1);
-                        /* try to set all blocks used checking are they still free */
+                        /*
+                         * 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. */
+                                /* Don't check in journal again. */
                                 if (reiserfs_test_and_set_le_bit
                                     (i, bh->b_data)) {
-                                        /* bit was set by another process
-                                         * while we slept in prepare_for_journal() */
+                                        /*
+                                         * bit was set by another process while
+                                         * we slept in prepare_for_journal()
+                                         */
                                         PROC_INFO_INC(s, scan_bitmap.stolen);
-                                        if (i >= *beg + min) {  /* we can continue with smaller set of allocated blocks,
-                                                                 * if length of this set is more or equal to `min' */
+
+                                        /*
+                                         * we can continue with smaller set
+                                         * of allocated blocks, if length of
+                                         * this set is more or equal to `min'
+                                         */
+                                        if (i >= *beg + min) {
                                                 end = i;
                                                 break;
                                         }
-                                        /* otherwise we clear all bit were set ... */
+
+                                        /*
+                                         * otherwise we clear all bit
+                                         * were set ...
+                                         */
                                         while (--i >= *beg)
                                                 reiserfs_clear_le_bit
                                                     (i, bh->b_data);
                                         reiserfs_restore_prepared_buffer(s, bh);
                                         *beg = org;
-                                        /* ... and search again in current block from beginning */
+
+                                        /*
+                                         * Search again in current block
+                                         * from beginning
+                                         */
                                         goto cont;
                                 }
                         }
                         bi->free_count -= (end - *beg);
-                        journal_mark_dirty(th, s, bh);
+                        journal_mark_dirty(th, bh);
                         brelse(bh);
 
                         /* free block count calculation */
                         reiserfs_prepare_for_journal(s, SB_BUFFER_WITH_SB(s),
                                                      1);
                         PUT_SB_FREE_BLOCKS(s, SB_FREE_BLOCKS(s) - (end - *beg));
-                        journal_mark_dirty(th, s, SB_BUFFER_WITH_SB(s));
+                        journal_mark_dirty(th, SB_BUFFER_WITH_SB(s));
 
                         return end - (*beg);
                 } else {
@@ -267,11 +301,13 @@ static inline int block_group_used(struct super_block *s, u32 id)
         int bm = bmap_hash_id(s, id);
         struct reiserfs_bitmap_info *info = &SB_AP_BITMAP(s)[bm];
 
-        /* If we don't have cached information on this bitmap block, we're
+        /*
+         * If we don't have cached information on this bitmap block, we're
          * going to have to load it later anyway. Loading it here allows us
          * to make a better decision. This favors long-term performance gain
          * with a better on-disk layout vs. a short term gain of skipping the
-         * read and potentially having a bad placement. */
+         * read and potentially having a bad placement.
+         */
         if (info->free_count == UINT_MAX) {
                 struct buffer_head *bh = reiserfs_read_bitmap_block(s, bm);
                 brelse(bh);
@@ -304,25 +340,26 @@ __le32 reiserfs_choose_packing(struct inode * dir)
         return packing;
 }
 
-/* Tries to find contiguous zero bit window (given size) in given region of
- * bitmap and place new blocks there. Returns number of allocated blocks. */
+/*
+ * Tries to find contiguous zero bit window (given size) in given region of
+ * bitmap and place new blocks there. Returns number of allocated blocks.
+ */
 static int scan_bitmap(struct reiserfs_transaction_handle *th,
                        b_blocknr_t * start, b_blocknr_t finish,
                        int min, int max, int unfm, sector_t file_block)
 {
         int nr_allocated = 0;
         struct super_block *s = th->t_super;
-        /* find every bm and bmap and bmap_nr in this file, and change them all to bitmap_blocknr
-         * - Hans, it is not a block number - Zam. */
-
         unsigned int bm, off;
         unsigned int end_bm, end_off;
         unsigned int off_max = s->s_blocksize << 3;
 
         BUG_ON(!th->t_trans_id);
         PROC_INFO_INC(s, scan_bitmap.call);
+
+        /* No point in looking for more free blocks */
         if (SB_FREE_BLOCKS(s) <= 0)
-                return 0;       // No point in looking for more free blocks
+                return 0;
 
         get_bit_address(s, *start, &bm, &off);
         get_bit_address(s, finish, &end_bm, &end_off);
@@ -331,7 +368,8 @@ static int scan_bitmap(struct reiserfs_transaction_handle *th,
         if (end_bm > reiserfs_bmap_count(s))
                 end_bm = reiserfs_bmap_count(s);
 
-        /* When the bitmap is more than 10% free, anyone can allocate.
+        /*
+         * When the bitmap is more than 10% free, anyone can allocate.
          * When it's less than 10% free, only files that already use the
          * bitmap are allowed. Once we pass 80% full, this restriction
          * is lifted.
@@ -369,7 +407,7 @@ static int scan_bitmap(struct reiserfs_transaction_handle *th,
         nr_allocated =
             scan_bitmap_block(th, bm, &off, end_off + 1, min, max, unfm);
 
-      ret:
+ret:
         *start = bm * off_max + off;
         return nr_allocated;
 
@@ -411,14 +449,14 @@ static void _reiserfs_free_block(struct reiserfs_transaction_handle *th,
                                "block %lu: bit already cleared", block);
         }
         apbi[nr].free_count++;
-        journal_mark_dirty(th, s, bmbh);
+        journal_mark_dirty(th, bmbh);
         brelse(bmbh);
 
         reiserfs_prepare_for_journal(s, sbh, 1);
         /* update super block */
         set_sb_free_blocks(rs, sb_free_blocks(rs) + 1);
 
-        journal_mark_dirty(th, s, sbh);
+        journal_mark_dirty(th, sbh);
         if (for_unformatted) {
                 int depth = reiserfs_write_unlock_nested(s);
                 dquot_free_block_nodirty(inode, 1);
@@ -483,7 +521,7 @@ static void __discard_prealloc(struct reiserfs_transaction_handle *th,
         if (dirty)
                 reiserfs_update_sd(th, inode);
         ei->i_prealloc_block = save;
-        list_del_init(&(ei->i_prealloc_list));
+        list_del_init(&ei->i_prealloc_list);
 }
 
 /* FIXME: It should be inline function */
@@ -529,7 +567,8 @@ int reiserfs_parse_alloc_options(struct super_block *s, char *options)
 {
         char *this_char, *value;
 
-        REISERFS_SB(s)->s_alloc_options.bits = 0;       /* clear default settings */
+        /* clear default settings */
+        REISERFS_SB(s)->s_alloc_options.bits = 0;
 
         while ((this_char = strsep(&options, ":")) != NULL) {
                 if ((value = strchr(this_char, '=')) != NULL)
@@ -731,7 +770,7 @@ static inline void new_hashed_relocation(reiserfs_blocknr_hint_t * hint)
                 hash_in = (char *)&hint->key.k_dir_id;
         } else {
                 if (!hint->inode) {
-                        //hint->search_start = hint->beg;
+                        /*hint->search_start = hint->beg;*/
                         hash_in = (char *)&hint->key.k_dir_id;
                 } else
                     if (TEST_OPTION(displace_based_on_dirid, hint->th->t_super))
@@ -785,7 +824,8 @@ static void oid_groups(reiserfs_blocknr_hint_t * hint)
 
                 dirid = le32_to_cpu(INODE_PKEY(hint->inode)->k_dir_id);
 
-                /* keep the root dir and it's first set of subdirs close to
+                /*
+                 * keep the root dir and it's first set of subdirs close to
                  * the start of the disk
                  */
                 if (dirid <= 2)
@@ -799,7 +839,8 @@ static void oid_groups(reiserfs_blocknr_hint_t * hint)
         }
 }
 
-/* returns 1 if it finds an indirect item and gets valid hint info
+/*
+ * returns 1 if it finds an indirect item and gets valid hint info
  * from it, otherwise 0
  */
 static int get_left_neighbor(reiserfs_blocknr_hint_t * hint)
@@ -811,25 +852,29 @@ static int get_left_neighbor(reiserfs_blocknr_hint_t * hint)
         __le32 *item;
         int ret = 0;
 
-        if (!hint->path)        /* reiserfs code can call this function w/o pointer to path
-                                 * structure supplied; then we rely on supplied search_start */
+        /*
+         * reiserfs code can call this function w/o pointer to path
+         * structure supplied; then we rely on supplied search_start
+         */
+        if (!hint->path)
                 return 0;
 
         path = hint->path;
         bh = get_last_bh(path);
         RFALSE(!bh, "green-4002: Illegal path specified to get_left_neighbor");
-        ih = get_ih(path);
+        ih = tp_item_head(path);
         pos_in_item = path->pos_in_item;
-        item = get_item(path);
+        item = tp_item_body(path);
 
         hint->search_start = bh->b_blocknr;
 
+        /*
+         * for indirect item: go to left and look for the first non-hole entry
+         * in the indirect item
+         */
         if (!hint->formatted_node && is_indirect_le_ih(ih)) {
-                /* for indirect item: go to left and look for the first non-hole entry
-                   in the indirect item */
                 if (pos_in_item == I_UNFM_NUM(ih))
                         pos_in_item--;
-//          pos_in_item = I_UNFM_NUM (ih) - 1;
                 while (pos_in_item >= 0) {
                         int t = get_block_num(item, pos_in_item);
                         if (t) {
@@ -845,10 +890,12 @@ static int get_left_neighbor(reiserfs_blocknr_hint_t * hint)
         return ret;
 }
 
-/* should be, if formatted node, then try to put on first part of the device
-   specified as number of percent with mount option device, else try to put
-   on last of device.  This is not to say it is good code to do so,
-   but the effect should be measured.  */
+/*
+ * should be, if formatted node, then try to put on first part of the device
+ * specified as number of percent with mount option device, else try to put
+ * on last of device.  This is not to say it is good code to do so,
+ * but the effect should be measured.
+ */
 static inline void set_border_in_hint(struct super_block *s,
                                       reiserfs_blocknr_hint_t * hint)
 {
@@ -974,21 +1021,27 @@ static void determine_search_start(reiserfs_blocknr_hint_t * hint,
                 set_border_in_hint(s, hint);
 
 #ifdef DISPLACE_NEW_PACKING_LOCALITIES
-        /* whenever we create a new directory, we displace it.  At first we will
-           hash for location, later we might look for a moderately empty place for
-           it */
+        /*
+         * whenever we create a new directory, we displace it.  At first
+         * we will hash for location, later we might look for a moderately
+         * empty place for it
+         */
         if (displacing_new_packing_localities(s)
             && hint->th->displace_new_blocks) {
                 displace_new_packing_locality(hint);
 
-                /* we do not continue determine_search_start,
-                 * if new packing locality is being displaced */
+                /*
+                 * we do not continue determine_search_start,
+                 * if new packing locality is being displaced
+                 */
                 return;
         }
 #endif
 
-        /* all persons should feel encouraged to add more special cases here and
-         * test them */
+        /*
+         * all persons should feel encouraged to add more special cases
+         * here and test them
+         */
 
         if (displacing_large_files(s) && !hint->formatted_node
             && this_blocknr_allocation_would_make_it_a_large_file(hint)) {
@@ -996,8 +1049,10 @@ static void determine_search_start(reiserfs_blocknr_hint_t * hint,
                 return;
         }
 
-        /* if none of our special cases is relevant, use the left neighbor in the
-           tree order of the new node we are allocating for */
+        /*
+         * if none of our special cases is relevant, use the left
+         * neighbor in the tree order of the new node we are allocating for
+         */
         if (hint->formatted_node && TEST_OPTION(hashed_formatted_nodes, s)) {
                 hash_formatted_node(hint);
                 return;
@@ -1005,10 +1060,13 @@ static void determine_search_start(reiserfs_blocknr_hint_t * hint,
 
         unfm_hint = get_left_neighbor(hint);
 
-        /* Mimic old block allocator behaviour, that is if VFS allowed for preallocation,
-           new blocks are displaced based on directory ID. Also, if suggested search_start
-           is less than last preallocated block, we start searching from it, assuming that
-           HDD dataflow is faster in forward direction */
+        /*
+         * Mimic old block allocator behaviour, that is if VFS allowed for
+         * preallocation, new blocks are displaced based on directory ID.
+         * Also, if suggested search_start is less than last preallocated
+         * block, we start searching from it, assuming that HDD dataflow
+         * is faster in forward direction
+         */
         if (TEST_OPTION(old_way, s)) {
                 if (!hint->formatted_node) {
                         if (!reiserfs_hashed_relocation(s))
@@ -1037,11 +1095,13 @@ static void determine_search_start(reiserfs_blocknr_hint_t * hint,
             TEST_OPTION(old_hashed_relocation, s)) {
                 old_hashed_relocation(hint);
         }
+
         /* new_hashed_relocation works with both formatted/unformatted nodes */
         if ((!unfm_hint || hint->formatted_node) &&
             TEST_OPTION(new_hashed_relocation, s)) {
                 new_hashed_relocation(hint);
         }
+
         /* dirid grouping works only on unformatted nodes */
         if (!unfm_hint && !hint->formatted_node && TEST_OPTION(dirid_groups, s)) {
                 dirid_groups(hint);
@@ -1079,8 +1139,6 @@ static int determine_prealloc_size(reiserfs_blocknr_hint_t * hint)
         return CARRY_ON;
 }
 
-/* XXX I know it could be merged with upper-level function;
-   but may be result function would be too complex. */
 static inline int allocate_without_wrapping_disk(reiserfs_blocknr_hint_t * hint,
                                                  b_blocknr_t * new_blocknrs,
                                                  b_blocknr_t start,
@@ -1108,7 +1166,10 @@ static inline int allocate_without_wrapping_disk(reiserfs_blocknr_hint_t * hint,
 
                 /* do we have something to fill prealloc. array also ? */
                 if (nr_allocated > 0) {
-                        /* it means prealloc_size was greater that 0 and we do preallocation */
+                        /*
+                         * it means prealloc_size was greater that 0 and
+                         * we do preallocation
+                         */
                         list_add(&REISERFS_I(hint->inode)->i_prealloc_list,
                                  &SB_JOURNAL(hint->th->t_super)->
                                  j_prealloc_list);
@@ -1176,7 +1237,8 @@ static inline int blocknrs_and_prealloc_arrays_from_search_start
                         start = 0;
                         finish = hint->beg;
                         break;
-                default:        /* We've tried searching everywhere, not enough space */
+                default:
+                        /* We've tried searching everywhere, not enough space */
                         /* Free the blocks */
                         if (!hint->formatted_node) {
 #ifdef REISERQUOTA_DEBUG
@@ -1261,8 +1323,11 @@ static int use_preallocated_list_if_available(reiserfs_blocknr_hint_t * hint,
         return amount_needed;
 }
 
-int reiserfs_allocate_blocknrs(reiserfs_blocknr_hint_t * hint, b_blocknr_t * new_blocknrs, int amount_needed, int reserved_by_us        /* Amount of blocks we have
-                                                                                                                                           already reserved */ )
+int reiserfs_allocate_blocknrs(reiserfs_blocknr_hint_t *hint,
+                               b_blocknr_t *new_blocknrs,
+                               int amount_needed,
+                               /* Amount of blocks we have already reserved */
+                               int reserved_by_us)
 {
         int initial_amount_needed = amount_needed;
         int ret;
@@ -1274,15 +1339,21 @@ int reiserfs_allocate_blocknrs(reiserfs_blocknr_hint_t * hint, b_blocknr_t * new
                 return NO_DISK_SPACE;
         /* should this be if !hint->inode &&  hint->preallocate? */
         /* do you mean hint->formatted_node can be removed ? - Zam */
-        /* hint->formatted_node cannot be removed because we try to access
-           inode information here, and there is often no inode assotiated with
-           metadata allocations - green */
+        /*
+         * hint->formatted_node cannot be removed because we try to access
+         * inode information here, and there is often no inode associated with
+         * metadata allocations - green
+         */
 
         if (!hint->formatted_node && hint->preallocate) {
                 amount_needed = use_preallocated_list_if_available
                     (hint, new_blocknrs, amount_needed);
-                if (amount_needed == 0) /* all blocknrs we need we got from
-                                           prealloc. list */
+
+                /*
+                 * We have all the block numbers we need from the
+                 * prealloc list
+                 */
+                if (amount_needed == 0)
                         return CARRY_ON;
                 new_blocknrs += (initial_amount_needed - amount_needed);
         }
@@ -1296,10 +1367,12 @@ int reiserfs_allocate_blocknrs(reiserfs_blocknr_hint_t * hint, b_blocknr_t * new
         ret = blocknrs_and_prealloc_arrays_from_search_start
             (hint, new_blocknrs, amount_needed);
 
-        /* we used prealloc. list to fill (partially) new_blocknrs array. If final allocation fails we
-         * need to return blocks back to prealloc. list or just free them. -- Zam (I chose second
-         * variant) */
-
+        /*
+         * We used prealloc. list to fill (partially) new_blocknrs array.
+         * If final allocation fails we need to return blocks back to
+         * prealloc. list or just free them. -- Zam (I chose second
+         * variant)
+         */
         if (ret != CARRY_ON) {
                 while (amount_needed++ < initial_amount_needed) {
                         reiserfs_free_block(hint->th, hint->inode,
@@ -1338,10 +1411,12 @@ struct buffer_head *reiserfs_read_bitmap_block(struct super_block *sb,
         struct reiserfs_bitmap_info *info = SB_AP_BITMAP(sb) + bitmap;
         struct buffer_head *bh;
 
-        /* Way old format filesystems had the bitmaps packed up front.
-         * I doubt there are any of these left, but just in case... */
+        /*
+         * Way old format filesystems had the bitmaps packed up front.
+         * I doubt there are any of these left, but just in case...
+         */
         if (unlikely(test_bit(REISERFS_OLD_FORMAT,
-                              &(REISERFS_SB(sb)->s_properties))))
+                              &REISERFS_SB(sb)->s_properties)))
                 block = REISERFS_SB(sb)->s_sbh->b_blocknr + 1 + bitmap;
         else if (bitmap == 0)
                 block = (REISERFS_DISK_OFFSET_IN_BYTES >> sb->s_blocksize_bits) + 1;