src/patches/suse-2.6.27.39/patches.suse/reiserfs-cleanup-path-funcs.diff

   1 From: Jeff Mahoney <jeffm@suse.com>
   2 Subject: reiserfs: cleanup path functions
   3
   4  This patch cleans up some redundancies in the reiserfs tree path code.
   5
   6  decrement_bcount() is essentially the same function as brelse(), so we use
   7  that instead.
   8
   9  decrement_counters_in_path() is exactly the same function as pathrelse(), so
  10  we kill that and use pathrelse() instead.
  11
  12  There's also a bit of cleanup that makes the code a bit more readable.
  13
  14 Signed-off-by: Jeff Mahoney <jeffm@suse.com>
  15
  16 ---
  17
  18  fs/reiserfs/fix_node.c |   58 ++++++++++++++++++++++++------------------------
  19  fs/reiserfs/stree.c    |   59 ++++++++++---------------------------------------
  20  2 files changed, 43 insertions(+), 74 deletions(-)
  21
  22 --- a/fs/reiserfs/fix_node.c
  23 +++ b/fs/reiserfs/fix_node.c
  24 @@ -753,20 +753,21 @@ static void free_buffers_in_tb(struct tr
  25  {
  26         int n_counter;
  27
  28 -       decrement_counters_in_path(p_s_tb->tb_path);
  29 +       pathrelse(p_s_tb->tb_path);
  30
  31         for (n_counter = 0; n_counter < MAX_HEIGHT; n_counter++) {
  32 -               decrement_bcount(p_s_tb->L[n_counter]);
  33 +               brelse(p_s_tb->L[n_counter]);
  34 +               brelse(p_s_tb->R[n_counter]);
  35 +               brelse(p_s_tb->FL[n_counter]);
  36 +               brelse(p_s_tb->FR[n_counter]);
  37 +               brelse(p_s_tb->CFL[n_counter]);
  38 +               brelse(p_s_tb->CFR[n_counter]);
  39 +
  40                 p_s_tb->L[n_counter] = NULL;
  41 -               decrement_bcount(p_s_tb->R[n_counter]);
  42                 p_s_tb->R[n_counter] = NULL;
  43 -               decrement_bcount(p_s_tb->FL[n_counter]);
  44                 p_s_tb->FL[n_counter] = NULL;
  45 -               decrement_bcount(p_s_tb->FR[n_counter]);
  46                 p_s_tb->FR[n_counter] = NULL;
  47 -               decrement_bcount(p_s_tb->CFL[n_counter]);
  48                 p_s_tb->CFL[n_counter] = NULL;
  49 -               decrement_bcount(p_s_tb->CFR[n_counter]);
  50                 p_s_tb->CFR[n_counter] = NULL;
  51         }
  52  }
  53 @@ -1022,7 +1023,7 @@ static int get_far_parent(struct tree_ba
  54         if (buffer_locked(*pp_s_com_father)) {
  55                 __wait_on_buffer(*pp_s_com_father);
  56                 if (FILESYSTEM_CHANGED_TB(p_s_tb)) {
  57 -                       decrement_bcount(*pp_s_com_father);
  58 +                       brelse(*pp_s_com_father);
  59                         return REPEAT_SEARCH;
  60                 }
  61         }
  62 @@ -1050,8 +1051,8 @@ static int get_far_parent(struct tree_ba
  63                 return IO_ERROR;
  64
  65         if (FILESYSTEM_CHANGED_TB(p_s_tb)) {
  66 -               decrement_counters_in_path(&s_path_to_neighbor_father);
  67 -               decrement_bcount(*pp_s_com_father);
  68 +               pathrelse(&s_path_to_neighbor_father);
  69 +               brelse(*pp_s_com_father);
  70                 return REPEAT_SEARCH;
  71         }
  72
  73 @@ -1063,7 +1064,7 @@ static int get_far_parent(struct tree_ba
  74                FIRST_PATH_ELEMENT_OFFSET, "PAP-8192: path length is too small");
  75
  76         s_path_to_neighbor_father.path_length--;
  77 -       decrement_counters_in_path(&s_path_to_neighbor_father);
  78 +       pathrelse(&s_path_to_neighbor_father);
  79         return CARRY_ON;
  80  }
  81
  82 @@ -1086,10 +1087,10 @@ static int get_parents(struct tree_balan
  83         if (n_path_offset <= FIRST_PATH_ELEMENT_OFFSET) {
  84                 /* The root can not have parents.
  85                    Release nodes which previously were obtained as parents of the current node neighbors. */
  86 -               decrement_bcount(p_s_tb->FL[n_h]);
  87 -               decrement_bcount(p_s_tb->CFL[n_h]);
  88 -               decrement_bcount(p_s_tb->FR[n_h]);
  89 -               decrement_bcount(p_s_tb->CFR[n_h]);
  90 +               brelse(p_s_tb->FL[n_h]);
  91 +               brelse(p_s_tb->CFL[n_h]);
  92 +               brelse(p_s_tb->FR[n_h]);
  93 +               brelse(p_s_tb->CFR[n_h]);
  94                 p_s_tb->FL[n_h] = p_s_tb->CFL[n_h] = p_s_tb->FR[n_h] =
  95                     p_s_tb->CFR[n_h] = NULL;
  96                 return CARRY_ON;
  97 @@ -1115,9 +1116,9 @@ static int get_parents(struct tree_balan
  98                         return n_ret_value;
  99         }
 100
 101 -       decrement_bcount(p_s_tb->FL[n_h]);
 102 +       brelse(p_s_tb->FL[n_h]);
 103         p_s_tb->FL[n_h] = p_s_curf;     /* New initialization of FL[n_h]. */
 104 -       decrement_bcount(p_s_tb->CFL[n_h]);
 105 +       brelse(p_s_tb->CFL[n_h]);
 106         p_s_tb->CFL[n_h] = p_s_curcf;   /* New initialization of CFL[n_h]. */
 107
 108         RFALSE((p_s_curf && !B_IS_IN_TREE(p_s_curf)) ||
 109 @@ -1145,10 +1146,10 @@ static int get_parents(struct tree_balan
 110                 p_s_tb->rkey[n_h] = n_position;
 111         }
 112
 113 -       decrement_bcount(p_s_tb->FR[n_h]);
 114 +       brelse(p_s_tb->FR[n_h]);
 115         p_s_tb->FR[n_h] = p_s_curf;     /* New initialization of FR[n_path_offset]. */
 116
 117 -       decrement_bcount(p_s_tb->CFR[n_h]);
 118 +       brelse(p_s_tb->CFR[n_h]);
 119         p_s_tb->CFR[n_h] = p_s_curcf;   /* New initialization of CFR[n_path_offset]. */
 120
 121         RFALSE((p_s_curf && !B_IS_IN_TREE(p_s_curf)) ||
 122 @@ -1964,7 +1965,7 @@ static int get_neighbors(struct tree_bal
 123                 if (!p_s_bh)
 124                         return IO_ERROR;
 125                 if (FILESYSTEM_CHANGED_TB(p_s_tb)) {
 126 -                       decrement_bcount(p_s_bh);
 127 +                       brelse(p_s_bh);
 128                         PROC_INFO_INC(p_s_sb, get_neighbors_restart[n_h]);
 129                         return REPEAT_SEARCH;
 130                 }
 131 @@ -1980,7 +1981,7 @@ static int get_neighbors(struct tree_bal
 132                        dc_size(B_N_CHILD(p_s_tb->FL[0], n_child_position)),
 133                        "PAP-8290: invalid child size of left neighbor");
 134
 135 -               decrement_bcount(p_s_tb->L[n_h]);
 136 +               brelse(p_s_tb->L[n_h]);
 137                 p_s_tb->L[n_h] = p_s_bh;
 138         }
 139
 140 @@ -2001,11 +2002,11 @@ static int get_neighbors(struct tree_bal
 141                 if (!p_s_bh)
 142                         return IO_ERROR;
 143                 if (FILESYSTEM_CHANGED_TB(p_s_tb)) {
 144 -                       decrement_bcount(p_s_bh);
 145 +                       brelse(p_s_bh);
 146                         PROC_INFO_INC(p_s_sb, get_neighbors_restart[n_h]);
 147                         return REPEAT_SEARCH;
 148                 }
 149 -               decrement_bcount(p_s_tb->R[n_h]);
 150 +               brelse(p_s_tb->R[n_h]);
 151                 p_s_tb->R[n_h] = p_s_bh;
 152
 153                 RFALSE(!n_h
 154 @@ -2511,16 +2512,17 @@ int fix_nodes(int n_op_mode, struct tree
 155                         }
 156
 157                         brelse(p_s_tb->L[i]);
 158 -                       p_s_tb->L[i] = NULL;
 159                         brelse(p_s_tb->R[i]);
 160 -                       p_s_tb->R[i] = NULL;
 161                         brelse(p_s_tb->FL[i]);
 162 -                       p_s_tb->FL[i] = NULL;
 163                         brelse(p_s_tb->FR[i]);
 164 -                       p_s_tb->FR[i] = NULL;
 165                         brelse(p_s_tb->CFL[i]);
 166 -                       p_s_tb->CFL[i] = NULL;
 167                         brelse(p_s_tb->CFR[i]);
 168 +
 169 +                       p_s_tb->L[i] = NULL;
 170 +                       p_s_tb->R[i] = NULL;
 171 +                       p_s_tb->FL[i] = NULL;
 172 +                       p_s_tb->FR[i] = NULL;
 173 +                       p_s_tb->CFL[i] = NULL;
 174                         p_s_tb->CFR[i] = NULL;
 175                 }
 176
 177 --- a/fs/reiserfs/stree.c
 178 +++ b/fs/reiserfs/stree.c
 179 @@ -23,7 +23,6 @@
 180   * get_rkey
 181   * key_in_buffer
 182   * decrement_bcount
 183 - * decrement_counters_in_path
 184   * reiserfs_check_path
 185   * pathrelse_and_restore
 186   * pathrelse
 187 @@ -359,36 +358,6 @@ static inline int key_in_buffer(struct t
 188         return 1;
 189  }
 190
 191 -inline void decrement_bcount(struct buffer_head *p_s_bh)
 192 -{
 193 -       if (p_s_bh) {
 194 -               if (atomic_read(&(p_s_bh->b_count))) {
 195 -                       put_bh(p_s_bh);
 196 -                       return;
 197 -               }
 198 -               reiserfs_panic(NULL, "PAP-5070",
 199 -                              "trying to free free buffer %b", p_s_bh);
 200 -       }
 201 -}
 202 -
 203 -/* Decrement b_count field of the all buffers in the path. */
 204 -void decrement_counters_in_path(struct treepath *p_s_search_path)
 205 -{
 206 -       int n_path_offset = p_s_search_path->path_length;
 207 -
 208 -       RFALSE(n_path_offset < ILLEGAL_PATH_ELEMENT_OFFSET ||
 209 -              n_path_offset > EXTENDED_MAX_HEIGHT - 1,
 210 -              "PAP-5080: invalid path offset of %d", n_path_offset);
 211 -
 212 -       while (n_path_offset > ILLEGAL_PATH_ELEMENT_OFFSET) {
 213 -               struct buffer_head *bh;
 214 -
 215 -               bh = PATH_OFFSET_PBUFFER(p_s_search_path, n_path_offset--);
 216 -               decrement_bcount(bh);
 217 -       }
 218 -       p_s_search_path->path_length = ILLEGAL_PATH_ELEMENT_OFFSET;
 219 -}
 220 -
 221  int reiserfs_check_path(struct treepath *p)
 222  {
 223         RFALSE(p->path_length != ILLEGAL_PATH_ELEMENT_OFFSET,
 224 @@ -396,12 +365,11 @@ int reiserfs_check_path(struct treepath
 225         return 0;
 226  }
 227
 228 -/* Release all buffers in the path. Restore dirty bits clean
 229 -** when preparing the buffer for the log
 230 -**
 231 -** only called from fix_nodes()
 232 -*/
 233 -void pathrelse_and_restore(struct super_block *s, struct treepath *p_s_search_path)
 234 +/* Drop the reference to each buffer in a path and restore
 235 + * dirty bits clean when preparing the buffer for the log.
 236 + * This version should only be called from fix_nodes() */
 237 +void pathrelse_and_restore(struct super_block *sb,
 238 +                          struct treepath *p_s_search_path)
 239  {
 240         int n_path_offset = p_s_search_path->path_length;
 241
 242 @@ -409,16 +377,15 @@ void pathrelse_and_restore(struct super_
 243                "clm-4000: invalid path offset");
 244
 245         while (n_path_offset > ILLEGAL_PATH_ELEMENT_OFFSET) {
 246 -               reiserfs_restore_prepared_buffer(s,
 247 -                                                PATH_OFFSET_PBUFFER
 248 -                                                (p_s_search_path,
 249 -                                                 n_path_offset));
 250 -               brelse(PATH_OFFSET_PBUFFER(p_s_search_path, n_path_offset--));
 251 +               struct buffer_head *bh;
 252 +               bh = PATH_OFFSET_PBUFFER(p_s_search_path, n_path_offset--);
 253 +               reiserfs_restore_prepared_buffer(sb, bh);
 254 +               brelse(bh);
 255         }
 256         p_s_search_path->path_length = ILLEGAL_PATH_ELEMENT_OFFSET;
 257  }
 258
 259 -/* Release all buffers in the path. */
 260 +/* Drop the reference to each buffer in a path */
 261  void pathrelse(struct treepath *p_s_search_path)
 262  {
 263         int n_path_offset = p_s_search_path->path_length;
 264 @@ -631,7 +598,7 @@ int search_by_key(struct super_block *p_
 265            we must be careful to release all nodes in a path before we either
 266            discard the path struct or re-use the path struct, as we do here. */
 267
 268 -       decrement_counters_in_path(p_s_search_path);
 269 +       pathrelse(p_s_search_path);
 270
 271         right_neighbor_of_leaf_node = 0;
 272
 273 @@ -691,7 +658,7 @@ int search_by_key(struct super_block *p_
 274                         PROC_INFO_INC(p_s_sb, search_by_key_restarted);
 275                         PROC_INFO_INC(p_s_sb,
 276                                       sbk_restarted[expected_level - 1]);
 277 -                       decrement_counters_in_path(p_s_search_path);
 278 +                       pathrelse(p_s_search_path);
 279
 280                         /* Get the root block number so that we can repeat the search
 281                            starting from the root. */
 282 @@ -1868,7 +1835,7 @@ int reiserfs_do_truncate(struct reiserfs
 283                 if (journal_transaction_should_end(th, 0) ||
 284                     reiserfs_transaction_free_space(th) <= JOURNAL_FOR_FREE_BLOCK_AND_UPDATE_SD) {
 285                         int orig_len_alloc = th->t_blocks_allocated;
 286 -                       decrement_counters_in_path(&s_search_path);
 287 +                       pathrelse(&s_search_path);
 288
 289                         if (update_timestamps) {
 290                                 p_s_inode->i_mtime = p_s_inode->i_ctime =