reiserfs: cleanup, rename key and item accessors to more friendly names
authorJeff Mahoney <jeffm@suse.com>
Wed, 23 Apr 2014 14:00:35 +0000 (10:00 -0400)
committerJan Kara <jack@suse.cz>
Tue, 6 May 2014 20:51:44 +0000 (22:51 +0200)
This patch does a quick search and replace:
B_N_PITEM_HEAD() -> item_head()
B_N_PDELIM_KEY() -> internal_key()
B_N_PKEY() -> leaf_key()
B_N_PITEM() -> item_body()

And the item_head version:
B_I_PITEM() -> ih_item_body()
I_ENTRY_COUNT() -> ih_entry_count()

And the treepath variants:
get_ih() -> tp_item_head()
PATH_PITEM_HEAD() -> tp_item_head()
get_item() -> tp_item_body()

... which makes the code much easier on the eyes.

I've also removed a few unused macros.

Checkpatch will complain about the 80 character limit for do_balan.c.
I've addressed that in a later patchset to split up balance_leaf().

Signed-off-by: Jeff Mahoney <jeffm@suse.com>
Signed-off-by: Jan Kara <jack@suse.cz>
14 files changed:
fs/reiserfs/bitmap.c
fs/reiserfs/dir.c
fs/reiserfs/do_balan.c
fs/reiserfs/fix_node.c
fs/reiserfs/ibalance.c
fs/reiserfs/inode.c
fs/reiserfs/item_ops.c
fs/reiserfs/lbalance.c
fs/reiserfs/namei.c
fs/reiserfs/prints.c
fs/reiserfs/reiserfs.h
fs/reiserfs/stree.c
fs/reiserfs/super.c
fs/reiserfs/tail_conversion.c

index dc9a6829f7c673ffa127115f7bce3cf355638264..c3de6501a5cbfb6ebf848993479a568e54e920a0 100644 (file)
@@ -819,9 +819,9 @@ static int get_left_neighbor(reiserfs_blocknr_hint_t * hint)
        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;
 
index af677353a3f5b5d06960b47c7d1c313e02cfb5be..1fe5cdeb586290a423f8e1a94ca6a5f538a7d7ea 100644 (file)
@@ -110,17 +110,17 @@ int reiserfs_readdir_inode(struct inode *inode, struct dir_context *ctx)
                       item_num, B_NR_ITEMS(bh));
 
                /* and entry must be not more than number of entries in the item */
-               RFALSE(I_ENTRY_COUNT(ih) < entry_num,
+               RFALSE(ih_entry_count(ih) < entry_num,
                       "vs-9010: entry number is too big %d (%d)",
-                      entry_num, I_ENTRY_COUNT(ih));
+                      entry_num, ih_entry_count(ih));
 
                if (search_res == POSITION_FOUND
-                   || entry_num < I_ENTRY_COUNT(ih)) {
+                   || entry_num < ih_entry_count(ih)) {
                        /* go through all entries in the directory item beginning from the entry, that has been found */
                        struct reiserfs_de_head *deh =
                            B_I_DEH(bh, ih) + entry_num;
 
-                       for (; entry_num < I_ENTRY_COUNT(ih);
+                       for (; entry_num < ih_entry_count(ih);
                             entry_num++, deh++) {
                                int d_reclen;
                                char *d_name;
index 9a3c68cf6026ae0405ef91c07f3ec9ef02854f1a..80b2b1b37169bd0b2a9419dfaad91f587510ddfc 100644 (file)
@@ -114,7 +114,7 @@ static int balance_leaf_when_delete(struct tree_balance *tb, int flag)
        RFALSE(!tb->blknum[0] && !PATH_H_PPARENT(tb->tb_path, 0),
               "PAP-12010: tree can not be empty");
 
-       ih = B_N_PITEM_HEAD(tbS0, item_pos);
+       ih = item_head(tbS0, item_pos);
        buffer_info_init_tbS0(tb, &bi);
 
        /* Delete or truncate the item */
@@ -312,7 +312,7 @@ static int balance_leaf(struct tree_balance *tb, struct item_head *ih,      /* item h
        /* for indirect item pos_in_item is measured in unformatted node
           pointers. Recalculate to bytes */
        if (flag != M_INSERT
-           && is_indirect_le_ih(B_N_PITEM_HEAD(tbS0, item_pos)))
+           && is_indirect_le_ih(item_head(tbS0, item_pos)))
                pos_in_item *= UNFM_P_SIZE;
 
        if (tb->lnum[0] > 0) {
@@ -378,7 +378,7 @@ static int balance_leaf(struct tree_balance *tb, struct item_head *ih,      /* item h
 
                                if (item_pos == tb->lnum[0] - 1 && tb->lbytes != -1) {
                                        /* we must shift the part of the appended item */
-                                       if (is_direntry_le_ih(B_N_PITEM_HEAD(tbS0, item_pos))) {
+                                       if (is_direntry_le_ih(item_head(tbS0, item_pos))) {
 
                                                RFALSE(zeros_num,
                                                       "PAP-12090: invalid parameter in case of a directory");
@@ -391,8 +391,8 @@ static int balance_leaf(struct tree_balance *tb, struct item_head *ih,      /* item h
                                                        /* Shift lnum[0] - 1 items in whole. Shift lbytes - 1 entries from given directory item */
                                                        ret_val = leaf_shift_left(tb, tb->lnum[0], tb->lbytes-1);
                                                        if (ret_val && !item_pos) {
-                                                               pasted = B_N_PITEM_HEAD(tb->L[0], B_NR_ITEMS(tb->L[0]) - 1);
-                                                               l_pos_in_item += I_ENTRY_COUNT(pasted) - (tb->lbytes -1);
+                                                               pasted = item_head(tb->L[0], B_NR_ITEMS(tb->L[0]) - 1);
+                                                               l_pos_in_item += ih_entry_count(pasted) - (tb->lbytes -1);
                                                        }
 
                                                        /* Append given directory entry to directory item */
@@ -418,9 +418,9 @@ static int balance_leaf(struct tree_balance *tb, struct item_head *ih,      /* item h
                                        } else {
                                                /* regular object */
                                                RFALSE(tb->lbytes <= 0, "PAP-12095: there is nothing to shift to L[0]. lbytes=%d", tb->lbytes);
-                                               RFALSE(pos_in_item != ih_item_len(B_N_PITEM_HEAD(tbS0, item_pos)),
+                                               RFALSE(pos_in_item != ih_item_len(item_head(tbS0, item_pos)),
                                                       "PAP-12100: incorrect position to paste: item_len=%d, pos_in_item=%d",
-                                                      ih_item_len(B_N_PITEM_HEAD(tbS0, item_pos)),pos_in_item);
+                                                      ih_item_len(item_head(tbS0, item_pos)),pos_in_item);
 
                                                if (tb->lbytes >= pos_in_item) {
                                                        /* appended item will be in L[0] in whole */
@@ -436,12 +436,12 @@ static int balance_leaf(struct tree_balance *tb, struct item_head *ih,    /* item h
                                                               "PAP-12105: there is nothing to paste into L[0]. insert_size=%d",
                                                               tb->insert_size[0]);
                                                        ret_val = leaf_shift_left(tb, tb->lnum[0], ih_item_len
-                                                                           (B_N_PITEM_HEAD(tbS0, item_pos)));
+                                                                           (item_head(tbS0, item_pos)));
                                                        /* Append to body of item in L[0] */
                                                        buffer_info_init_left(tb, &bi);
                                                        leaf_paste_in_buffer
                                                            (&bi, n + item_pos - ret_val, ih_item_len
-                                                            (B_N_PITEM_HEAD(tb->L[0], n + item_pos - ret_val)),
+                                                            (item_head(tb->L[0], n + item_pos - ret_val)),
                                                             l_n, body,
                                                             zeros_num > l_n ? l_n : zeros_num);
                                                        /* 0-th item in S0 can be only of DIRECT type when l_n != 0 */
@@ -449,21 +449,21 @@ static int balance_leaf(struct tree_balance *tb, struct item_head *ih,    /* item h
                                                                int version;
                                                                int temp_l = l_n;
 
-                                                               RFALSE(ih_item_len(B_N_PITEM_HEAD(tbS0, 0)),
+                                                               RFALSE(ih_item_len(item_head(tbS0, 0)),
                                                                     "PAP-12106: item length must be 0");
-                                                               RFALSE(comp_short_le_keys(B_N_PKEY(tbS0, 0), B_N_PKEY
+                                                               RFALSE(comp_short_le_keys(leaf_key(tbS0, 0), leaf_key
                                                                      (tb->L[0], n + item_pos - ret_val)),
                                                                     "PAP-12107: items must be of the same file");
-                                                               if (is_indirect_le_ih(B_N_PITEM_HEAD(tb->L[0], n + item_pos - ret_val))) {
+                                                               if (is_indirect_le_ih(item_head(tb->L[0], n + item_pos - ret_val))) {
                                                                        temp_l = l_n << (tb->tb_sb-> s_blocksize_bits - UNFM_P_SHIFT);
                                                                }
                                                                /* update key of first item in S0 */
-                                                               version = ih_version(B_N_PITEM_HEAD(tbS0, 0));
-                                                               set_le_key_k_offset(version, B_N_PKEY(tbS0, 0),
-                                                                    le_key_k_offset(version,B_N_PKEY(tbS0, 0)) + temp_l);
+                                                               version = ih_version(item_head(tbS0, 0));
+                                                               set_le_key_k_offset(version, leaf_key(tbS0, 0),
+                                                                    le_key_k_offset(version,leaf_key(tbS0, 0)) + temp_l);
                                                                /* update left delimiting key */
-                                                               set_le_key_k_offset(version, B_N_PDELIM_KEY(tb->CFL[0], tb->lkey[0]),
-                                                                    le_key_k_offset(version, B_N_PDELIM_KEY(tb->CFL[0], tb->lkey[0])) + temp_l);
+                                                               set_le_key_k_offset(version, internal_key(tb->CFL[0], tb->lkey[0]),
+                                                                    le_key_k_offset(version, internal_key(tb->CFL[0], tb->lkey[0])) + temp_l);
                                                        }
 
                                                        /* Calculate new body, position in item and insert_size[0] */
@@ -474,9 +474,9 @@ static int balance_leaf(struct tree_balance *tb, struct item_head *ih,      /* item h
                                                                zeros_num -= l_n;
                                                        pos_in_item = 0;
 
-                                                       RFALSE(comp_short_le_keys(B_N_PKEY(tbS0, 0), B_N_PKEY(tb->L[0], B_NR_ITEMS(tb->L[0]) - 1))
-                                                            || !op_is_left_mergeable(B_N_PKEY(tbS0, 0), tbS0->b_size)
-                                                            || !op_is_left_mergeable(B_N_PDELIM_KEY(tb->CFL[0], tb->lkey[0]), tbS0->b_size),
+                                                       RFALSE(comp_short_le_keys(leaf_key(tbS0, 0), leaf_key(tb->L[0], B_NR_ITEMS(tb->L[0]) - 1))
+                                                            || !op_is_left_mergeable(leaf_key(tbS0, 0), tbS0->b_size)
+                                                            || !op_is_left_mergeable(internal_key(tb->CFL[0], tb->lkey[0]), tbS0->b_size),
                                                             "PAP-12120: item must be merge-able with left neighboring item");
                                                } else {        /* only part of the appended item will be in L[0] */
 
@@ -493,9 +493,9 @@ static int balance_leaf(struct tree_balance *tb, struct item_head *ih,      /* item h
 
                                        struct item_head *pasted;
 
-                                       if (!item_pos && op_is_left_mergeable(B_N_PKEY(tbS0, 0), tbS0->b_size)) {       /* if we paste into first item of S[0] and it is left mergable */
+                                       if (!item_pos && op_is_left_mergeable(leaf_key(tbS0, 0), tbS0->b_size)) {       /* if we paste into first item of S[0] and it is left mergable */
                                                /* then increment pos_in_item by the size of the last item in L[0] */
-                                               pasted = B_N_PITEM_HEAD(tb->L[0], n - 1);
+                                               pasted = item_head(tb->L[0], n - 1);
                                                if (is_direntry_le_ih(pasted))
                                                        pos_in_item += ih_entry_count(pasted);
                                                else
@@ -512,7 +512,7 @@ static int balance_leaf(struct tree_balance *tb, struct item_head *ih,      /* item h
                                                             body, zeros_num);
 
                                        /* if appended item is directory, paste entry */
-                                       pasted = B_N_PITEM_HEAD(tb->L[0], n + item_pos - ret_val);
+                                       pasted = item_head(tb->L[0], n + item_pos - ret_val);
                                        if (is_direntry_le_ih(pasted))
                                                leaf_paste_entries(&bi, n + item_pos - ret_val,
                                                                   pos_in_item, 1,
@@ -617,12 +617,12 @@ static int balance_leaf(struct tree_balance *tb, struct item_head *ih,    /* item h
 
                        if (n - tb->rnum[0] <= item_pos) {      /* pasted item or part of it falls to R[0] */
                                if (item_pos == n - tb->rnum[0] && tb->rbytes != -1) {  /* we must shift the part of the appended item */
-                                       if (is_direntry_le_ih(B_N_PITEM_HEAD(tbS0, item_pos))) {        /* we append to directory item */
+                                       if (is_direntry_le_ih(item_head(tbS0, item_pos))) {     /* we append to directory item */
                                                int entry_count;
 
                                                RFALSE(zeros_num,
                                                       "PAP-12145: invalid parameter in case of a directory");
-                                               entry_count = I_ENTRY_COUNT(B_N_PITEM_HEAD
+                                               entry_count = ih_entry_count(item_head
                                                                  (tbS0, item_pos));
                                                if (entry_count - tb->rbytes <
                                                    pos_in_item)
@@ -665,10 +665,10 @@ static int balance_leaf(struct tree_balance *tb, struct item_head *ih,    /* item h
                                                        n_shift = 0;
 
                                                RFALSE(pos_in_item != ih_item_len
-                                                      (B_N_PITEM_HEAD(tbS0, item_pos)),
+                                                      (item_head(tbS0, item_pos)),
                                                       "PAP-12155: invalid position to paste. ih_item_len=%d, pos_in_item=%d",
                                                       pos_in_item, ih_item_len
-                                                      (B_N_PITEM_HEAD(tbS0, item_pos)));
+                                                      (item_head(tbS0, item_pos)));
 
                                                leaf_shift_right(tb, tb->rnum[0], n_shift);
                                                /* Calculate number of bytes which must remain in body after appending to R[0] */
@@ -679,17 +679,17 @@ static int balance_leaf(struct tree_balance *tb, struct item_head *ih,    /* item h
                                                        int version;
                                                        unsigned long temp_rem = n_rem;
 
-                                                       version = ih_version(B_N_PITEM_HEAD(tb->R[0], 0));
-                                                       if (is_indirect_le_key(version, B_N_PKEY(tb->R[0], 0))) {
+                                                       version = ih_version(item_head(tb->R[0], 0));
+                                                       if (is_indirect_le_key(version, leaf_key(tb->R[0], 0))) {
                                                                temp_rem = n_rem << (tb->tb_sb->s_blocksize_bits - UNFM_P_SHIFT);
                                                        }
-                                                       set_le_key_k_offset(version, B_N_PKEY(tb->R[0], 0),
-                                                            le_key_k_offset(version, B_N_PKEY(tb->R[0], 0)) + temp_rem);
-                                                       set_le_key_k_offset(version, B_N_PDELIM_KEY(tb->CFR[0], tb->rkey[0]),
-                                                            le_key_k_offset(version, B_N_PDELIM_KEY(tb->CFR[0], tb->rkey[0])) + temp_rem);
+                                                       set_le_key_k_offset(version, leaf_key(tb->R[0], 0),
+                                                            le_key_k_offset(version, leaf_key(tb->R[0], 0)) + temp_rem);
+                                                       set_le_key_k_offset(version, internal_key(tb->CFR[0], tb->rkey[0]),
+                                                            le_key_k_offset(version, internal_key(tb->CFR[0], tb->rkey[0])) + temp_rem);
                                                }
-/*               k_offset (B_N_PKEY(tb->R[0],0)) += n_rem;
-                 k_offset (B_N_PDELIM_KEY(tb->CFR[0],tb->rkey[0])) += n_rem;*/
+/*               k_offset (leaf_key(tb->R[0],0)) += n_rem;
+                 k_offset (internal_key(tb->CFR[0],tb->rkey[0])) += n_rem;*/
                                                do_balance_mark_internal_dirty(tb, tb->CFR[0], 0);
 
                                                /* Append part of body into R[0] */
@@ -707,12 +707,12 @@ static int balance_leaf(struct tree_balance *tb, struct item_head *ih,    /* item h
                                                                     tb->insert_size[0] - n_rem,
                                                                     r_body, r_zeros_number);
 
-                                               if (is_indirect_le_ih(B_N_PITEM_HEAD(tb->R[0], 0))) {
+                                               if (is_indirect_le_ih(item_head(tb->R[0], 0))) {
 #if 0
                                                        RFALSE(n_rem,
                                                               "PAP-12160: paste more than one unformatted node pointer");
 #endif
-                                                       set_ih_free_space(B_N_PITEM_HEAD(tb->R[0], 0), 0);
+                                                       set_ih_free_space(item_head(tb->R[0], 0), 0);
                                                }
                                                tb->insert_size[0] = n_rem;
                                                if (!n_rem)
@@ -731,7 +731,7 @@ static int balance_leaf(struct tree_balance *tb, struct item_head *ih,      /* item h
                                        }
 
                                        /* paste new entry, if item is directory item */
-                                       pasted = B_N_PITEM_HEAD(tb->R[0], item_pos - n + tb->rnum[0]);
+                                       pasted = item_head(tb->R[0], item_pos - n + tb->rnum[0]);
                                        if (is_direntry_le_ih(pasted) && pos_in_item >= 0) {
                                                leaf_paste_entries(&bi, item_pos - n + tb->rnum[0],
                                                                   pos_in_item, 1,
@@ -784,8 +784,8 @@ static int balance_leaf(struct tree_balance *tb, struct item_head *ih,      /* item h
                        if (!tb->CFR[0])
                                reiserfs_panic(tb->tb_sb, "vs-12195",
                                               "CFR not initialized");
-                       copy_key(B_N_PDELIM_KEY(tb->CFL[0], tb->lkey[0]),
-                                B_N_PDELIM_KEY(tb->CFR[0], tb->rkey[0]));
+                       copy_key(internal_key(tb->CFL[0], tb->lkey[0]),
+                                internal_key(tb->CFR[0], tb->rkey[0]));
                        do_balance_mark_internal_dirty(tb, tb->CFL[0], 0);
                }
 
@@ -886,7 +886,7 @@ static int balance_leaf(struct tree_balance *tb, struct item_head *ih,      /* item h
 
                                        RFALSE(ih, "PAP-12210: ih must be 0");
 
-                                       aux_ih = B_N_PITEM_HEAD(tbS0, item_pos);
+                                       aux_ih = item_head(tbS0, item_pos);
                                        if (is_direntry_le_ih(aux_ih)) {
                                                /* we append to directory item */
 
@@ -922,7 +922,7 @@ static int balance_leaf(struct tree_balance *tb, struct item_head *ih,      /* item h
                                                int n_shift, n_rem, r_zeros_number;
                                                const char *r_body;
 
-                                               RFALSE(pos_in_item != ih_item_len(B_N_PITEM_HEAD(tbS0, item_pos)) || tb->insert_size[0] <= 0,
+                                               RFALSE(pos_in_item != ih_item_len(item_head(tbS0, item_pos)) || tb->insert_size[0] <= 0,
                                                       "PAP-12225: item too short or insert_size <= 0");
 
                                                /* Calculate number of bytes which must be shifted from appended item */
@@ -952,7 +952,7 @@ static int balance_leaf(struct tree_balance *tb, struct item_head *ih,      /* item h
                                                {
                                                        struct item_head *tmp;
 
-                                                       tmp = B_N_PITEM_HEAD(S_new[i], 0);
+                                                       tmp = item_head(S_new[i], 0);
                                                        if (is_indirect_le_ih
                                                            (tmp)) {
                                                                set_ih_free_space(tmp, 0);
@@ -973,7 +973,7 @@ static int balance_leaf(struct tree_balance *tb, struct item_head *ih,      /* item h
                                        struct item_head *pasted;
 
 #ifdef CONFIG_REISERFS_CHECK
-                                       struct item_head *ih_check = B_N_PITEM_HEAD(tbS0, item_pos);
+                                       struct item_head *ih_check = item_head(tbS0, item_pos);
 
                                        if (!is_direntry_le_ih(ih_check)
                                            && (pos_in_item != ih_item_len(ih_check)
@@ -1002,7 +1002,7 @@ static int balance_leaf(struct tree_balance *tb, struct item_head *ih,    /* item h
                                                             tb->insert_size[0],
                                                             body, zeros_num);
 
-                                       pasted = B_N_PITEM_HEAD(S_new[i], item_pos - n + snum[i]);
+                                       pasted = item_head(S_new[i], item_pos - n + snum[i]);
                                        if (is_direntry_le_ih(pasted)) {
                                                leaf_paste_entries(&bi,
                                                                   item_pos - n + snum[i],
@@ -1032,7 +1032,7 @@ static int balance_leaf(struct tree_balance *tb, struct item_head *ih,    /* item h
                                       (flag == M_DELETE) ? "DELETE" : ((flag == M_CUT) ? "CUT" : "UNKNOWN"), flag);
                }
 
-               memcpy(insert_key + i, B_N_PKEY(S_new[i], 0), KEY_SIZE);
+               memcpy(insert_key + i, leaf_key(S_new[i], 0), KEY_SIZE);
                insert_ptr[i] = S_new[i];
 
                RFALSE(!buffer_journaled(S_new[i])
@@ -1061,7 +1061,7 @@ static int balance_leaf(struct tree_balance *tb, struct item_head *ih,    /* item h
                case M_PASTE:{  /* append item in S[0] */
                                struct item_head *pasted;
 
-                               pasted = B_N_PITEM_HEAD(tbS0, item_pos);
+                               pasted = item_head(tbS0, item_pos);
                                /* when directory, may be new entry already pasted */
                                if (is_direntry_le_ih(pasted)) {
                                        if (pos_in_item >= 0 && pos_in_item <= ih_entry_count(pasted)) {
@@ -1246,10 +1246,10 @@ void replace_key(struct tree_balance *tb, struct buffer_head *dest, int n_dest,
 
        if (B_IS_ITEMS_LEVEL(src))
                /* source buffer contains leaf node */
-               memcpy(B_N_PDELIM_KEY(dest, n_dest), B_N_PITEM_HEAD(src, n_src),
+               memcpy(internal_key(dest, n_dest), item_head(src, n_src),
                       KEY_SIZE);
        else
-               memcpy(B_N_PDELIM_KEY(dest, n_dest), B_N_PDELIM_KEY(src, n_src),
+               memcpy(internal_key(dest, n_dest), internal_key(src, n_src),
                       KEY_SIZE);
 
        do_balance_mark_internal_dirty(tb, dest, 0);
index dc4d415303164934d21b8c0dd416adb52035f311..b6a05a7f4658351e2b1c13d883bfa484cc3bb6ef 100644 (file)
@@ -105,7 +105,7 @@ static void create_virtual_node(struct tree_balance *tb, int h)
        vn->vn_free_ptr += vn->vn_nr_item * sizeof(struct virtual_item);
 
        /* first item in the node */
-       ih = B_N_PITEM_HEAD(Sh, 0);
+       ih = item_head(Sh, 0);
 
        /* define the mergeability for 0-th item (if it is not being deleted) */
        if (op_is_left_mergeable(&(ih->ih_key), Sh->b_size)
@@ -128,7 +128,7 @@ static void create_virtual_node(struct tree_balance *tb, int h)
 
                vi->vi_item_len += ih_item_len(ih + j) + IH_SIZE;
                vi->vi_ih = ih + j;
-               vi->vi_item = B_I_PITEM(Sh, ih + j);
+               vi->vi_item = ih_item_body(Sh, ih + j);
                vi->vi_uarea = vn->vn_free_ptr;
 
                // FIXME: there is no check, that item operation did not
@@ -168,7 +168,7 @@ static void create_virtual_node(struct tree_balance *tb, int h)
        if (tb->CFR[0]) {
                struct reiserfs_key *key;
 
-               key = B_N_PDELIM_KEY(tb->CFR[0], tb->rkey[0]);
+               key = internal_key(tb->CFR[0], tb->rkey[0]);
                if (op_is_left_mergeable(key, Sh->b_size)
                    && (vn->vn_mode != M_DELETE
                        || vn->vn_affected_item_num != B_NR_ITEMS(Sh) - 1))
@@ -182,8 +182,8 @@ static void create_virtual_node(struct tree_balance *tb, int h)
                        /* we delete last item and it could be merged with right neighbor's first item */
                        if (!
                            (B_NR_ITEMS(Sh) == 1
-                            && is_direntry_le_ih(B_N_PITEM_HEAD(Sh, 0))
-                            && I_ENTRY_COUNT(B_N_PITEM_HEAD(Sh, 0)) == 1)) {
+                            && is_direntry_le_ih(item_head(Sh, 0))
+                            && ih_entry_count(item_head(Sh, 0)) == 1)) {
                                /* node contains more than 1 item, or item is not directory item, or this item contains more than 1 entry */
                                print_block(Sh, 0, -1, -1);
                                reiserfs_panic(tb->tb_sb, "vs-8045",
@@ -675,10 +675,10 @@ static int are_leaves_removable(struct tree_balance *tb, int lfree, int rfree)
                       "vs-8125: item number must be 1: it is %d",
                       B_NR_ITEMS(S0));
 
-               ih = B_N_PITEM_HEAD(S0, 0);
+               ih = item_head(S0, 0);
                if (tb->CFR[0]
                    && !comp_short_le_keys(&(ih->ih_key),
-                                          B_N_PDELIM_KEY(tb->CFR[0],
+                                          internal_key(tb->CFR[0],
                                                          tb->rkey[0])))
                        if (is_direntry_le_ih(ih)) {
                                /* Directory must be in correct state here: that is
@@ -1036,7 +1036,7 @@ static int get_far_parent(struct tree_balance *tb,
 
        /* Form key to get parent of the left/right neighbor. */
        le_key2cpu_key(&s_lr_father_key,
-                      B_N_PDELIM_KEY(*pcom_father,
+                      internal_key(*pcom_father,
                                      (c_lr_par ==
                                       LEFT_PARENTS) ? (tb->lkey[h - 1] =
                                                        position -
@@ -1175,9 +1175,9 @@ static inline int can_node_be_removed(int mode, int lfree, int sfree, int rfree,
        struct item_head *ih;
        struct reiserfs_key *r_key = NULL;
 
-       ih = B_N_PITEM_HEAD(Sh, 0);
+       ih = item_head(Sh, 0);
        if (tb->CFR[h])
-               r_key = B_N_PDELIM_KEY(tb->CFR[h], tb->rkey[h]);
+               r_key = internal_key(tb->CFR[h], tb->rkey[h]);
 
        if (lfree + rfree + sfree < MAX_CHILD_SIZE(Sh) + levbytes
            /* shifting may merge items which might save space */
index e1978fd895f559743672d5ebd029f42d32d6112b..ae26a271da353473b1aeb7b8081a5eb03d24c6e7 100644 (file)
@@ -153,7 +153,7 @@ static void internal_insert_childs(struct buffer_info *cur_bi,
        memcpy(dc, new_dc, DC_SIZE * count);
 
        /* prepare space for count items  */
-       ih = B_N_PDELIM_KEY(cur, ((to == -1) ? 0 : to));
+       ih = internal_key(cur, ((to == -1) ? 0 : to));
 
        memmove(ih + count, ih,
                (nr - to) * KEY_SIZE + (nr + 1 + count) * DC_SIZE);
@@ -233,7 +233,7 @@ static void internal_delete_pointers_items(struct buffer_info *cur_bi,
        dc = B_N_CHILD(cur, first_p);
 
        memmove(dc, dc + del_num, (nr + 1 - first_p - del_num) * DC_SIZE);
-       key = B_N_PDELIM_KEY(cur, first_i);
+       key = internal_key(cur, first_i);
        memmove(key, key + del_num,
                (nr - first_i - del_num) * KEY_SIZE + (nr + 1 -
                                                       del_num) * DC_SIZE);
@@ -330,13 +330,13 @@ static void internal_copy_pointers_items(struct buffer_info *dest_bi,
        memcpy(dc, B_N_CHILD(src, src_order), DC_SIZE * cpy_num);
 
        /* prepare space for cpy_num - 1 item headers */
-       key = B_N_PDELIM_KEY(dest, dest_order);
+       key = internal_key(dest, dest_order);
        memmove(key + cpy_num - 1, key,
                KEY_SIZE * (nr_dest - dest_order) + DC_SIZE * (nr_dest +
                                                               cpy_num));
 
        /* insert headers */
-       memcpy(key, B_N_PDELIM_KEY(src, src_order), KEY_SIZE * (cpy_num - 1));
+       memcpy(key, internal_key(src, src_order), KEY_SIZE * (cpy_num - 1));
 
        /* sizes, item number */
        set_blkh_nr_item(blkh, blkh_nr_item(blkh) + (cpy_num - 1));
@@ -429,12 +429,12 @@ static void internal_insert_key(struct buffer_info *dest_bi, int dest_position_b
        nr = blkh_nr_item(blkh);
 
        /* prepare space for inserting key */
-       key = B_N_PDELIM_KEY(dest, dest_position_before);
+       key = internal_key(dest, dest_position_before);
        memmove(key + 1, key,
                (nr - dest_position_before) * KEY_SIZE + (nr + 1) * DC_SIZE);
 
        /* insert key */
-       memcpy(key, B_N_PDELIM_KEY(src, src_position), KEY_SIZE);
+       memcpy(key, internal_key(src, src_position), KEY_SIZE);
 
        /* Change dirt, free space, item number fields. */
 
@@ -717,7 +717,7 @@ static void replace_lkey(struct tree_balance *tb, int h, struct item_head *key)
        if (B_NR_ITEMS(PATH_H_PBUFFER(tb->tb_path, h)) == 0)
                return;
 
-       memcpy(B_N_PDELIM_KEY(tb->CFL[h], tb->lkey[h]), key, KEY_SIZE);
+       memcpy(internal_key(tb->CFL[h], tb->lkey[h]), key, KEY_SIZE);
 
        do_balance_mark_internal_dirty(tb, tb->CFL[h], 0);
 }
@@ -732,7 +732,7 @@ static void replace_rkey(struct tree_balance *tb, int h, struct item_head *key)
               "R[h] can not be empty if it exists (item number=%d)",
               B_NR_ITEMS(tb->R[h]));
 
-       memcpy(B_N_PDELIM_KEY(tb->CFR[h], tb->rkey[h]), key, KEY_SIZE);
+       memcpy(internal_key(tb->CFR[h], tb->rkey[h]), key, KEY_SIZE);
 
        do_balance_mark_internal_dirty(tb, tb->CFR[h], 0);
 }
@@ -997,7 +997,7 @@ int balance_internal(struct tree_balance *tb,       /* tree_balance structure
                        /* new items don't fall into S_new */
                        /*  store the delimiting key for the next level */
                        /* new_insert_key = (n - snum)'th key in S[h] */
-                       memcpy(&new_insert_key, B_N_PDELIM_KEY(tbSh, n - snum),
+                       memcpy(&new_insert_key, internal_key(tbSh, n - snum),
                               KEY_SIZE);
                        /* last parameter is del_par */
                        internal_move_pointers_items(&dest_bi, &src_bi,
@@ -1008,7 +1008,7 @@ int balance_internal(struct tree_balance *tb,     /* tree_balance structure
                        /*  store the delimiting key for the next level */
                        /* new_insert_key = (n + insert_item - snum)'th key in S[h] */
                        memcpy(&new_insert_key,
-                              B_N_PDELIM_KEY(tbSh, n + insert_num - snum),
+                              internal_key(tbSh, n + insert_num - snum),
                               KEY_SIZE);
                        /* last parameter is del_par */
                        internal_move_pointers_items(&dest_bi, &src_bi,
index bc8b8009897df3886bee8ed953d55fd36ec6f812..b8d3ffb1f722ab32f94c4859d03ead761b7432b9 100644 (file)
@@ -295,9 +295,9 @@ static int _get_block_create_0(struct inode *inode, sector_t block,
        }
        //
        bh = get_last_bh(&path);
-       ih = get_ih(&path);
+       ih = tp_item_head(&path);
        if (is_indirect_le_ih(ih)) {
-               __le32 *ind_item = (__le32 *) B_I_PITEM(bh, ih);
+               __le32 *ind_item = (__le32 *) ih_item_body(bh, ih);
 
                /* FIXME: here we could cache indirect item or part of it in
                   the inode to avoid search_by_key in case of subsequent
@@ -383,7 +383,7 @@ static int _get_block_create_0(struct inode *inode, sector_t block,
                } else {
                        chars = ih_item_len(ih) - path.pos_in_item;
                }
-               memcpy(p, B_I_PITEM(bh, ih) + path.pos_in_item, chars);
+               memcpy(p, ih_item_body(bh, ih) + path.pos_in_item, chars);
 
                if (done)
                        break;
@@ -404,7 +404,7 @@ static int _get_block_create_0(struct inode *inode, sector_t block,
                        // i/o error most likely
                        break;
                bh = get_last_bh(&path);
-               ih = get_ih(&path);
+               ih = tp_item_head(&path);
        } while (1);
 
        flush_dcache_page(bh_result->b_page);
@@ -684,8 +684,8 @@ int reiserfs_get_block(struct inode *inode, sector_t block,
        }
 
        bh = get_last_bh(&path);
-       ih = get_ih(&path);
-       item = get_item(&path);
+       ih = tp_item_head(&path);
+       item = tp_item_body(&path);
        pos_in_item = path.pos_in_item;
 
        fs_gen = get_generation(inode->i_sb);
@@ -1031,8 +1031,8 @@ int reiserfs_get_block(struct inode *inode, sector_t block,
                        goto failure;
                }
                bh = get_last_bh(&path);
-               ih = get_ih(&path);
-               item = get_item(&path);
+               ih = tp_item_head(&path);
+               item = tp_item_body(&path);
                pos_in_item = path.pos_in_item;
        } while (1);
 
@@ -1133,7 +1133,7 @@ static void init_inode(struct inode *inode, struct treepath *path)
        //int version = ITEM_VERSION_1;
 
        bh = PATH_PLAST_BUFFER(path);
-       ih = PATH_PITEM_HEAD(path);
+       ih = tp_item_head(path);
 
        copy_key(INODE_PKEY(inode), &(ih->ih_key));
 
@@ -1147,7 +1147,7 @@ static void init_inode(struct inode *inode, struct treepath *path)
 
        if (stat_data_v1(ih)) {
                struct stat_data_v1 *sd =
-                   (struct stat_data_v1 *)B_I_PITEM(bh, ih);
+                   (struct stat_data_v1 *)ih_item_body(bh, ih);
                unsigned long blocks;
 
                set_inode_item_key_version(inode, KEY_FORMAT_3_5);
@@ -1195,7 +1195,7 @@ static void init_inode(struct inode *inode, struct treepath *path)
        } else {
                // new stat data found, but object may have old items
                // (directories and symlinks)
-               struct stat_data *sd = (struct stat_data *)B_I_PITEM(bh, ih);
+               struct stat_data *sd = (struct stat_data *)ih_item_body(bh, ih);
 
                inode->i_mode = sd_v2_mode(sd);
                set_nlink(inode, sd_v2_nlink(sd));
@@ -1307,7 +1307,7 @@ static void update_stat_data(struct treepath *path, struct inode *inode,
        struct item_head *ih;
 
        bh = PATH_PLAST_BUFFER(path);
-       ih = PATH_PITEM_HEAD(path);
+       ih = tp_item_head(path);
 
        if (!is_statdata_le_ih(ih))
                reiserfs_panic(inode->i_sb, "vs-13065", "key %k, found item %h",
@@ -1315,9 +1315,9 @@ static void update_stat_data(struct treepath *path, struct inode *inode,
 
        if (stat_data_v1(ih)) {
                // path points to old stat data
-               inode2sd_v1(B_I_PITEM(bh, ih), inode, size);
+               inode2sd_v1(ih_item_body(bh, ih), inode, size);
        } else {
-               inode2sd(B_I_PITEM(bh, ih), inode, size);
+               inode2sd(ih_item_body(bh, ih), inode, size);
        }
 
        return;
@@ -1368,7 +1368,7 @@ void reiserfs_update_sd_size(struct reiserfs_transaction_handle *th,
                 ** search if the stat data item has moved
                 */
                bh = get_last_bh(&path);
-               ih = get_ih(&path);
+               ih = tp_item_head(&path);
                copy_item_head(&tmp_ih, ih);
                fs_gen = get_generation(inode->i_sb);
                reiserfs_prepare_for_journal(inode->i_sb, bh, 1);
@@ -2232,8 +2232,8 @@ static int map_block_for_writepage(struct inode *inode,
        }
 
        bh = get_last_bh(&path);
-       ih = get_ih(&path);
-       item = get_item(&path);
+       ih = tp_item_head(&path);
+       item = tp_item_body(&path);
        pos_in_item = path.pos_in_item;
 
        /* we've found an unformatted node */
@@ -2281,7 +2281,7 @@ static int map_block_for_writepage(struct inode *inode,
                        goto research;
                }
 
-               memcpy(B_I_PITEM(bh, ih) + pos_in_item, p + bytes_copied,
+               memcpy(ih_item_body(bh, ih) + pos_in_item, p + bytes_copied,
                       copy_size);
 
                journal_mark_dirty(&th, inode->i_sb, bh);
index ee382ef3d3006d36e460d2c6a9aa349f3078a1ff..c9f13652738651520c7483833be6afedf534a6ba 100644 (file)
@@ -396,7 +396,7 @@ static void direntry_print_item(struct item_head *ih, char *item)
 
        deh = (struct reiserfs_de_head *)item;
 
-       for (i = 0; i < I_ENTRY_COUNT(ih); i++, deh++) {
+       for (i = 0; i < ih_entry_count(ih); i++, deh++) {
                namelen =
                    (i ? (deh_location(deh - 1)) : ih_item_len(ih)) -
                    deh_location(deh);
@@ -430,7 +430,7 @@ static void direntry_check_item(struct item_head *ih, char *item)
 
        // FIXME: type something here!
        deh = (struct reiserfs_de_head *)item;
-       for (i = 0; i < I_ENTRY_COUNT(ih); i++, deh++) {
+       for (i = 0; i < ih_entry_count(ih); i++, deh++) {
                ;
        }
 }
index 79e5a8b4c22697984a99fd259b10b1ff26c5935b..b46399d98f846644fa2be4bb3ba4e3a8a8dbd1c1 100644 (file)
@@ -35,7 +35,7 @@ static void leaf_copy_dir_entries(struct buffer_info *dest_bi,
        int copy_records_len;   /* length of all records in item to be copied */
        char *records;
 
-       ih = B_N_PITEM_HEAD(source, item_num);
+       ih = item_head(source, item_num);
 
        RFALSE(!is_direntry_le_ih(ih), "vs-10000: item must be directory item");
 
@@ -64,7 +64,7 @@ static void leaf_copy_dir_entries(struct buffer_info *dest_bi,
            (last_first == FIRST_TO_LAST && le_ih_k_offset(ih) == DOT_OFFSET) ||
            (last_first == LAST_TO_FIRST
             && comp_short_le_keys /*COMP_SHORT_KEYS */ (&ih->ih_key,
-                                                        B_N_PKEY(dest,
+                                                        leaf_key(dest,
                                                                  item_num_in_dest))))
        {
                /* create new item in dest */
@@ -80,7 +80,7 @@ static void leaf_copy_dir_entries(struct buffer_info *dest_bi,
 
                if (last_first == LAST_TO_FIRST) {
                        /* form key by the following way */
-                       if (from < I_ENTRY_COUNT(ih)) {
+                       if (from < ih_entry_count(ih)) {
                                set_le_ih_k_offset(&new_ih,
                                                   deh_offset(&(deh[from])));
                                /*memcpy (&new_ih.ih_key.k_offset, &deh[from].deh_offset, SHORT_KEY_SIZE); */
@@ -113,7 +113,7 @@ static void leaf_copy_dir_entries(struct buffer_info *dest_bi,
 
        leaf_paste_entries(dest_bi, item_num_in_dest,
                           (last_first ==
-                           FIRST_TO_LAST) ? I_ENTRY_COUNT(B_N_PITEM_HEAD(dest,
+                           FIRST_TO_LAST) ? ih_entry_count(item_head(dest,
                                                                          item_num_in_dest))
                           : 0, copy_count, deh + from, records,
                           DEH_SIZE * copy_count + copy_records_len);
@@ -138,8 +138,8 @@ static int leaf_copy_boundary_item(struct buffer_info *dest_bi,
                /* if ( DEST is empty or first item of SOURCE and last item of DEST are the items of different objects
                   or of different types ) then there is no need to treat this item differently from the other items
                   that we copy, so we return */
-               ih = B_N_PITEM_HEAD(src, 0);
-               dih = B_N_PITEM_HEAD(dest, dest_nr_item - 1);
+               ih = item_head(src, 0);
+               dih = item_head(dest, dest_nr_item - 1);
                if (!dest_nr_item
                    || (!op_is_left_mergeable(&(ih->ih_key), src->b_size)))
                        /* there is nothing to merge */
@@ -180,7 +180,7 @@ static int leaf_copy_boundary_item(struct buffer_info *dest_bi,
                   item of dest buffer. Both are of the same file */
                leaf_paste_in_buffer(dest_bi,
                                     dest_nr_item - 1, ih_item_len(dih),
-                                    bytes_or_entries, B_I_PITEM(src, ih), 0);
+                                    bytes_or_entries, ih_item_body(src, ih), 0);
 
                if (is_indirect_le_ih(dih)) {
                        RFALSE(get_ih_free_space(dih),
@@ -199,8 +199,8 @@ static int leaf_copy_boundary_item(struct buffer_info *dest_bi,
           are the items of different object or of different types )
         */
        src_nr_item = B_NR_ITEMS(src);
-       ih = B_N_PITEM_HEAD(src, src_nr_item - 1);
-       dih = B_N_PITEM_HEAD(dest, 0);
+       ih = item_head(src, src_nr_item - 1);
+       dih = item_head(dest, 0);
 
        if (!dest_nr_item || !op_is_left_mergeable(&(dih->ih_key), src->b_size))
                return 0;
@@ -270,7 +270,7 @@ static int leaf_copy_boundary_item(struct buffer_info *dest_bi,
        }
 
        leaf_paste_in_buffer(dest_bi, 0, 0, bytes_or_entries,
-                            B_I_PITEM(src,
+                            ih_item_body(src,
                                       ih) + ih_item_len(ih) - bytes_or_entries,
                             0);
        return 1;
@@ -315,7 +315,7 @@ static void leaf_copy_items_entirely(struct buffer_info *dest_bi,
        dest_before = (last_first == LAST_TO_FIRST) ? 0 : nr;
 
        /* location of head of first new item */
-       ih = B_N_PITEM_HEAD(dest, dest_before);
+       ih = item_head(dest, dest_before);
 
        RFALSE(blkh_free_space(blkh) < cpy_num * IH_SIZE,
               "vs-10140: not enough free space for headers %d (needed %d)",
@@ -325,7 +325,7 @@ static void leaf_copy_items_entirely(struct buffer_info *dest_bi,
        memmove(ih + cpy_num, ih, (nr - dest_before) * IH_SIZE);
 
        /* copy item headers */
-       memcpy(ih, B_N_PITEM_HEAD(src, first), cpy_num * IH_SIZE);
+       memcpy(ih, item_head(src, first), cpy_num * IH_SIZE);
 
        free_space -= (IH_SIZE * cpy_num);
        set_blkh_free_space(blkh, free_space);
@@ -352,7 +352,8 @@ static void leaf_copy_items_entirely(struct buffer_info *dest_bi,
 
        /* copy items */
        memcpy(dest->b_data + last_inserted_loc,
-              B_N_PITEM(src, (first + cpy_num - 1)), j - last_inserted_loc);
+              item_body(src, (first + cpy_num - 1)),
+              j - last_inserted_loc);
 
        /* sizes, item number */
        set_blkh_nr_item(blkh, nr + cpy_num);
@@ -390,7 +391,7 @@ static void leaf_item_bottle(struct buffer_info *dest_bi,
 
        if (last_first == FIRST_TO_LAST) {
                /* if ( if item in position item_num in buffer SOURCE is directory item ) */
-               ih = B_N_PITEM_HEAD(src, item_num);
+               ih = item_head(src, item_num);
                if (is_direntry_le_ih(ih))
                        leaf_copy_dir_entries(dest_bi, src, FIRST_TO_LAST,
                                              item_num, 0, cpy_bytes);
@@ -415,15 +416,15 @@ static void leaf_item_bottle(struct buffer_info *dest_bi,
                               "vs-10190: bad mergeability of item %h", ih);
                        n_ih.ih_version = ih->ih_version;       /* JDM Endian safe, both le */
                        leaf_insert_into_buf(dest_bi, B_NR_ITEMS(dest), &n_ih,
-                                            B_N_PITEM(src, item_num), 0);
+                                            item_body(src, item_num), 0);
                }
        } else {
                /*  if ( if item in position item_num in buffer SOURCE is directory item ) */
-               ih = B_N_PITEM_HEAD(src, item_num);
+               ih = item_head(src, item_num);
                if (is_direntry_le_ih(ih))
                        leaf_copy_dir_entries(dest_bi, src, LAST_TO_FIRST,
                                              item_num,
-                                             I_ENTRY_COUNT(ih) - cpy_bytes,
+                                             ih_entry_count(ih) - cpy_bytes,
                                              cpy_bytes);
                else {
                        struct item_head n_ih;
@@ -461,9 +462,8 @@ static void leaf_item_bottle(struct buffer_info *dest_bi,
                        n_ih.ih_version = ih->ih_version;       /* JDM Endian safe, both le */
 
                        leaf_insert_into_buf(dest_bi, 0, &n_ih,
-                                            B_N_PITEM(src,
-                                                      item_num) +
-                                            ih_item_len(ih) - cpy_bytes, 0);
+                                            item_body(src, item_num) +
+                                               ih_item_len(ih) - cpy_bytes, 0);
                }
        }
 }
@@ -691,10 +691,10 @@ int leaf_shift_left(struct tree_balance *tb, int shift_num, int shift_bytes)
                        replace_key(tb, tb->CFL[0], tb->lkey[0], S0, 0);
 
                        RFALSE((shift_bytes != -1 &&
-                               !(is_direntry_le_ih(B_N_PITEM_HEAD(S0, 0))
-                                 && !I_ENTRY_COUNT(B_N_PITEM_HEAD(S0, 0)))) &&
+                               !(is_direntry_le_ih(item_head(S0, 0))
+                                 && !ih_entry_count(item_head(S0, 0)))) &&
                               (!op_is_left_mergeable
-                               (B_N_PKEY(S0, 0), S0->b_size)),
+                               (leaf_key(S0, 0), S0->b_size)),
                               "vs-10280: item must be mergeable");
                }
        }
@@ -776,7 +776,7 @@ void leaf_delete_items(struct buffer_info *cur_bi, int last_first,
                        leaf_delete_items_entirely(cur_bi, first + 1,
                                                   del_num - 1);
 
-                       ih = B_N_PITEM_HEAD(bh, B_NR_ITEMS(bh) - 1);
+                       ih = item_head(bh, B_NR_ITEMS(bh) - 1);
                        if (is_direntry_le_ih(ih))
                                /* the last item is directory  */
                                /* len = numbers of directory entries in this item */
@@ -820,7 +820,7 @@ void leaf_insert_into_buf(struct buffer_info *bi, int before,
               zeros_number, ih_item_len(inserted_item_ih));
 
        /* get item new item must be inserted before */
-       ih = B_N_PITEM_HEAD(bh, before);
+       ih = item_head(bh, before);
 
        /* prepare space for the body of new item */
        last_loc = nr ? ih_location(&(ih[nr - before - 1])) : bh->b_size;
@@ -902,7 +902,7 @@ void leaf_paste_in_buffer(struct buffer_info *bi, int affected_item_num,
 #endif                         /* CONFIG_REISERFS_CHECK */
 
        /* item to be appended */
-       ih = B_N_PITEM_HEAD(bh, affected_item_num);
+       ih = item_head(bh, affected_item_num);
 
        last_loc = ih_location(&(ih[nr - affected_item_num - 1]));
        unmoved_loc = affected_item_num ? ih_location(ih - 1) : bh->b_size;
@@ -974,9 +974,9 @@ static int leaf_cut_entries(struct buffer_head *bh,
        /* make sure, that item is directory and there are enough entries to
           remove */
        RFALSE(!is_direntry_le_ih(ih), "10180: item is not directory item");
-       RFALSE(I_ENTRY_COUNT(ih) < from + del_count,
+       RFALSE(ih_entry_count(ih) < from + del_count,
               "10185: item contains not enough entries: entry_count = %d, from = %d, to delete = %d",
-              I_ENTRY_COUNT(ih), from, del_count);
+              ih_entry_count(ih), from, del_count);
 
        if (del_count == 0)
                return 0;
@@ -996,7 +996,7 @@ static int leaf_cut_entries(struct buffer_head *bh,
        prev_record = item + prev_record_offset;
 
        /* adjust locations of remaining entries */
-       for (i = I_ENTRY_COUNT(ih) - 1; i > from + del_count - 1; i--)
+       for (i = ih_entry_count(ih) - 1; i > from + del_count - 1; i--)
                put_deh_location(&(deh[i]),
                                 deh_location(&deh[i]) -
                                 (DEH_SIZE * del_count));
@@ -1043,7 +1043,7 @@ void leaf_cut_from_buffer(struct buffer_info *bi, int cut_item_num,
        nr = blkh_nr_item(blkh);
 
        /* item head of truncated item */
-       ih = B_N_PITEM_HEAD(bh, cut_item_num);
+       ih = item_head(bh, cut_item_num);
 
        if (is_direntry_le_ih(ih)) {
                /* first cut entry () */
@@ -1156,7 +1156,7 @@ static void leaf_delete_items_entirely(struct buffer_info *bi,
                return;
        }
 
-       ih = B_N_PITEM_HEAD(bh, first);
+       ih = item_head(bh, first);
 
        /* location of unmovable item */
        j = (first == 0) ? bh->b_size : ih_location(ih - 1);
@@ -1213,13 +1213,13 @@ void leaf_paste_entries(struct buffer_info *bi,
        if (new_entry_count == 0)
                return;
 
-       ih = B_N_PITEM_HEAD(bh, item_num);
+       ih = item_head(bh, item_num);
 
        /* make sure, that item is directory, and there are enough records in it */
        RFALSE(!is_direntry_le_ih(ih), "10225: item is not directory item");
-       RFALSE(I_ENTRY_COUNT(ih) < before,
+       RFALSE(ih_entry_count(ih) < before,
               "10230: there are no entry we paste entries before. entry_count = %d, before = %d",
-              I_ENTRY_COUNT(ih), before);
+              ih_entry_count(ih), before);
 
        /* first byte of dest item */
        item = bh->b_data + ih_location(ih);
@@ -1234,7 +1234,7 @@ void leaf_paste_entries(struct buffer_info *bi,
             : (ih_item_len(ih) - paste_size));
 
        /* adjust locations of records that will be AFTER new records */
-       for (i = I_ENTRY_COUNT(ih) - 1; i >= before; i--)
+       for (i = ih_entry_count(ih) - 1; i >= before; i--)
                put_deh_location(&(deh[i]),
                                 deh_location(&(deh[i])) +
                                 (DEH_SIZE * new_entry_count));
@@ -1244,7 +1244,7 @@ void leaf_paste_entries(struct buffer_info *bi,
                put_deh_location(&(deh[i]),
                                 deh_location(&(deh[i])) + paste_size);
 
-       old_entry_num = I_ENTRY_COUNT(ih);
+       old_entry_num = ih_entry_count(ih);
        put_ih_entry_count(ih, ih_entry_count(ih) + new_entry_count);
 
        /* prepare space for pasted records */
@@ -1285,10 +1285,10 @@ void leaf_paste_entries(struct buffer_info *bi,
                int prev, next;
                /* check record locations */
                deh = B_I_DEH(bh, ih);
-               for (i = 0; i < I_ENTRY_COUNT(ih); i++) {
+               for (i = 0; i < ih_entry_count(ih); i++) {
                        next =
                            (i <
-                            I_ENTRY_COUNT(ih) -
+                            ih_entry_count(ih) -
                             1) ? deh_location(&(deh[i + 1])) : 0;
                        prev = (i != 0) ? deh_location(&(deh[i - 1])) : 0;
 
index e825f8b63e6b7433c125e040117de525a2d0cf31..1ce8fbea47492b299ecc6d3c53db0ee897762af7 100644 (file)
@@ -31,7 +31,7 @@ static int bin_search_in_dir_item(struct reiserfs_dir_entry *de, loff_t off)
        int rbound, lbound, j;
 
        lbound = 0;
-       rbound = I_ENTRY_COUNT(ih) - 1;
+       rbound = ih_entry_count(ih) - 1;
 
        for (j = (rbound + lbound) / 2; lbound <= rbound;
             j = (rbound + lbound) / 2) {
@@ -57,7 +57,7 @@ static inline void set_de_item_location(struct reiserfs_dir_entry *de,
                                        struct treepath *path)
 {
        de->de_bh = get_last_bh(path);
-       de->de_ih = get_ih(path);
+       de->de_ih = tp_item_head(path);
        de->de_deh = B_I_DEH(de->de_bh, de->de_ih);
        de->de_item_num = PATH_LAST_POSITION(path);
 }
@@ -71,7 +71,7 @@ inline void set_de_name_and_namelen(struct reiserfs_dir_entry *de)
 
        de->de_entrylen = entry_length(de->de_bh, de->de_ih, de->de_entry_num);
        de->de_namelen = de->de_entrylen - (de_with_sd(deh) ? SD_SIZE : 0);
-       de->de_name = B_I_PITEM(de->de_bh, de->de_ih) + deh_location(deh);
+       de->de_name = ih_item_body(de->de_bh, de->de_ih) + deh_location(deh);
        if (de->de_name[de->de_namelen - 1] == 0)
                de->de_namelen = strlen(de->de_name);
 }
@@ -220,7 +220,7 @@ static int linear_search_in_dir_item(struct cpu_key *key,
 
        i = de->de_entry_num;
 
-       if (i == I_ENTRY_COUNT(de->de_ih) ||
+       if (i == ih_entry_count(de->de_ih) ||
            GET_HASH_VALUE(deh_offset(deh + i)) !=
            GET_HASH_VALUE(cpu_key_k_offset(key))) {
                i--;
@@ -1331,7 +1331,7 @@ static int reiserfs_rename(struct inode *old_dir, struct dentry *old_dentry,
                        return -EIO;
                }
 
-               copy_item_head(&old_entry_ih, get_ih(&old_entry_path));
+               copy_item_head(&old_entry_ih, tp_item_head(&old_entry_path));
 
                reiserfs_prepare_for_journal(old_inode->i_sb, old_de.de_bh, 1);
 
@@ -1351,7 +1351,7 @@ static int reiserfs_rename(struct inode *old_dir, struct dentry *old_dentry,
                        return -EIO;
                }
 
-               copy_item_head(&new_entry_ih, get_ih(&new_entry_path));
+               copy_item_head(&new_entry_ih, tp_item_head(&new_entry_path));
 
                reiserfs_prepare_for_journal(old_inode->i_sb, new_de.de_bh, 1);
 
@@ -1369,7 +1369,7 @@ static int reiserfs_rename(struct inode *old_dir, struct dentry *old_dentry,
                                return -EIO;
                        }
                        copy_item_head(&dot_dot_ih,
-                                      get_ih(&dot_dot_entry_path));
+                                      tp_item_head(&dot_dot_entry_path));
                        // node containing ".." gets into transaction
                        reiserfs_prepare_for_journal(old_inode->i_sb,
                                                     dot_dot_de.de_bh, 1);
index 54944d5a4a6e170fb55f507e9373456226eb23db..41f788148d448a347994b107bce82c2d23a32f65 100644 (file)
@@ -439,7 +439,7 @@ static int print_internal(struct buffer_head *bh, int first, int last)
        dc = B_N_CHILD(bh, from);
        reiserfs_printk("PTR %d: %y ", from, dc);
 
-       for (i = from, key = B_N_PDELIM_KEY(bh, from), dc++; i < to;
+       for (i = from, key = internal_key(bh, from), dc++; i < to;
             i++, key++, dc++) {
                reiserfs_printk("KEY %d: %k PTR %d: %y ", i, key, i + 1, dc);
                if (i && i % 4 == 0)
@@ -463,7 +463,7 @@ static int print_leaf(struct buffer_head *bh, int print_mode, int first,
        check_leaf(bh);
 
        blkh = B_BLK_HEAD(bh);
-       ih = B_N_PITEM_HEAD(bh, 0);
+       ih = item_head(bh, 0);
        nr = blkh_nr_item(blkh);
 
        printk
@@ -496,7 +496,7 @@ static int print_leaf(struct buffer_head *bh, int print_mode, int first,
                    ("-------------------------------------------------------------------------------\n");
                reiserfs_printk("|%2d| %h |\n", i, ih);
                if (print_mode & PRINT_LEAF_ITEMS)
-                       op_print_item(ih, B_I_PITEM(bh, ih));
+                       op_print_item(ih, ih_item_body(bh, ih));
        }
 
        printk
@@ -744,8 +744,8 @@ void check_leaf(struct buffer_head *bh)
        if (!bh)
                return;
        check_leaf_block_head(bh);
-       for (i = 0, ih = B_N_PITEM_HEAD(bh, 0); i < B_NR_ITEMS(bh); i++, ih++)
-               op_check_item(ih, B_I_PITEM(bh, ih));
+       for (i = 0, ih = item_head(bh, 0); i < B_NR_ITEMS(bh); i++, ih++)
+               op_check_item(ih, ih_item_body(bh, ih));
 }
 
 void check_internal(struct buffer_head *bh)
index 3f56746f0237912b704f4251be11e59aed182fa8..35bfde10ca0f691a3df472e26eae39cf0b0ab02a 100644 (file)
@@ -1277,9 +1277,11 @@ static inline loff_t le_ih_k_offset(const struct item_head *ih)
 
 static inline loff_t le_key_k_type(int version, const struct reiserfs_key *key)
 {
-       return (version == KEY_FORMAT_3_5) ?
-           uniqueness2type(le32_to_cpu(key->u.k_offset_v1.k_uniqueness)) :
-           offset_v2_k_type(&(key->u.k_offset_v2));
+       if (version == KEY_FORMAT_3_5) {
+               loff_t val = le32_to_cpu(key->u.k_offset_v1.k_uniqueness);
+               return uniqueness2type(val);
+       } else
+               return offset_v2_k_type(&(key->u.k_offset_v2));
 }
 
 static inline loff_t le_ih_k_type(const struct item_head *ih)
@@ -1290,8 +1292,22 @@ static inline loff_t le_ih_k_type(const struct item_head *ih)
 static inline void set_le_key_k_offset(int version, struct reiserfs_key *key,
                                       loff_t offset)
 {
-       (version == KEY_FORMAT_3_5) ? (void)(key->u.k_offset_v1.k_offset = cpu_to_le32(offset)) :       /* jdm check */
-           (void)(set_offset_v2_k_offset(&(key->u.k_offset_v2), offset));
+       if (version == KEY_FORMAT_3_5)
+               key->u.k_offset_v1.k_offset = cpu_to_le32(offset);
+       else
+               set_offset_v2_k_offset(&key->u.k_offset_v2, offset);
+}
+
+static inline void add_le_key_k_offset(int version, struct reiserfs_key *key,
+                                      loff_t offset)
+{
+       set_le_key_k_offset(version, key,
+                           le_key_k_offset(version, key) + offset);
+}
+
+static inline void add_le_ih_k_offset(struct item_head *ih, loff_t offset)
+{
+       add_le_key_k_offset(ih_version(ih), &(ih->ih_key), offset);
 }
 
 static inline void set_le_ih_k_offset(struct item_head *ih, loff_t offset)
@@ -1302,10 +1318,11 @@ static inline void set_le_ih_k_offset(struct item_head *ih, loff_t offset)
 static inline void set_le_key_k_type(int version, struct reiserfs_key *key,
                                     int type)
 {
-       (version == KEY_FORMAT_3_5) ?
-           (void)(key->u.k_offset_v1.k_uniqueness =
-                  cpu_to_le32(type2uniqueness(type)))
-           : (void)(set_offset_v2_k_type(&(key->u.k_offset_v2), type));
+       if (version == KEY_FORMAT_3_5) {
+               type = type2uniqueness(type);
+               key->u.k_offset_v1.k_uniqueness = cpu_to_le32(type);
+       } else
+              set_offset_v2_k_type(&key->u.k_offset_v2, type);
 }
 
 static inline void set_le_ih_k_type(struct item_head *ih, int type)
@@ -1723,39 +1740,6 @@ extern void make_empty_dir_item_v1(char *body, __le32 dirid, __le32 objid,
 extern void make_empty_dir_item(char *body, __le32 dirid, __le32 objid,
                                __le32 par_dirid, __le32 par_objid);
 
-/* array of the entry headers */
- /* get item body */
-#define B_I_PITEM(bh,ih) ( (bh)->b_data + ih_location(ih) )
-#define B_I_DEH(bh,ih) ((struct reiserfs_de_head *)(B_I_PITEM(bh,ih)))
-
-/* length of the directory entry in directory item. This define
-   calculates length of i-th directory entry using directory entry
-   locations from dir entry head. When it calculates length of 0-th
-   directory entry, it uses length of whole item in place of entry
-   location of the non-existent following entry in the calculation.
-   See picture above.*/
-/*
-#define I_DEH_N_ENTRY_LENGTH(ih,deh,i) \
-((i) ? (deh_location((deh)-1) - deh_location((deh))) : (ih_item_len((ih)) - deh_location((deh))))
-*/
-static inline int entry_length(const struct buffer_head *bh,
-                              const struct item_head *ih, int pos_in_item)
-{
-       struct reiserfs_de_head *deh;
-
-       deh = B_I_DEH(bh, ih) + pos_in_item;
-       if (pos_in_item)
-               return deh_location(deh - 1) - deh_location(deh);
-
-       return ih_item_len(ih) - deh_location(deh);
-}
-
-/* number of entries in the directory item, depends on ENTRY_COUNT being at the start of directory dynamic data. */
-#define I_ENTRY_COUNT(ih) (ih_entry_count((ih)))
-
-/* name by bh, ih and entry_num */
-#define B_I_E_NAME(bh,ih,entry_num) ((char *)(bh->b_data + ih_location(ih) + deh_location(B_I_DEH(bh,ih)+(entry_num))))
-
 // two entries per block (at least)
 #define REISERFS_MAX_NAME(block_size) 255
 
@@ -1783,7 +1767,8 @@ struct reiserfs_dir_entry {
 /* these defines are useful when a particular member of a reiserfs_dir_entry is needed */
 
 /* pointer to file name, stored in entry */
-#define B_I_DEH_ENTRY_FILE_NAME(bh,ih,deh) (B_I_PITEM (bh, ih) + deh_location(deh))
+#define B_I_DEH_ENTRY_FILE_NAME(bh, ih, deh) \
+                               (ih_item_body(bh, ih) + deh_location(deh))
 
 /* length of name */
 #define I_DEH_N_ENTRY_FILE_NAME_LENGTH(ih,deh,entry_num) \
@@ -1918,8 +1903,6 @@ struct treepath var = {.path_length = ILLEGAL_PATH_ELEMENT_OFFSET, .reada = 0,}
                                   dumping paths... -Hans */
 #define PATH_LAST_POSITION(path) (PATH_OFFSET_POSITION((path), (path)->path_length))
 
-#define PATH_PITEM_HEAD(path)    B_N_PITEM_HEAD(PATH_PLAST_BUFFER(path), PATH_LAST_POSITION(path))
-
 /* in do_balance leaf has h == 0 in contrast with path structure,
    where root has level == 0. That is why we need these defines */
 #define PATH_H_PBUFFER(path, h) PATH_OFFSET_PBUFFER (path, path->path_length - (h))    /* tb->S[h] */
@@ -1929,13 +1912,89 @@ struct treepath var = {.path_length = ILLEGAL_PATH_ELEMENT_OFFSET, .reada = 0,}
 
 #define PATH_H_PATH_OFFSET(path, n_h) ((path)->path_length - (n_h))
 
+static inline void *reiserfs_node_data(const struct buffer_head *bh)
+{
+       return bh->b_data + sizeof(struct block_head);
+}
+
+/* get key from internal node */
+static inline struct reiserfs_key *internal_key(struct buffer_head *bh,
+                                               int item_num)
+{
+       struct reiserfs_key *key = reiserfs_node_data(bh);
+
+       return &key[item_num];
+}
+
+/* get the item header from leaf node */
+static inline struct item_head *item_head(const struct buffer_head *bh,
+                                         int item_num)
+{
+       struct item_head *ih = reiserfs_node_data(bh);
+
+       return &ih[item_num];
+}
+
+/* get the key from leaf node */
+static inline struct reiserfs_key *leaf_key(const struct buffer_head *bh,
+                                           int item_num)
+{
+       return &item_head(bh, item_num)->ih_key;
+}
+
+static inline void *ih_item_body(const struct buffer_head *bh,
+                                const struct item_head *ih)
+{
+       return bh->b_data + ih_location(ih);
+}
+
+/* get item body from leaf node */
+static inline void *item_body(const struct buffer_head *bh, int item_num)
+{
+       return ih_item_body(bh, item_head(bh, item_num));
+}
+
+static inline struct item_head *tp_item_head(const struct treepath *path)
+{
+       return item_head(PATH_PLAST_BUFFER(path), PATH_LAST_POSITION(path));
+}
+
+static inline void *tp_item_body(const struct treepath *path)
+{
+       return item_body(PATH_PLAST_BUFFER(path), PATH_LAST_POSITION(path));
+}
+
 #define get_last_bh(path) PATH_PLAST_BUFFER(path)
-#define get_ih(path) PATH_PITEM_HEAD(path)
 #define get_item_pos(path) PATH_LAST_POSITION(path)
-#define get_item(path) ((void *)B_N_PITEM(PATH_PLAST_BUFFER(path), PATH_LAST_POSITION (path)))
 #define item_moved(ih,path) comp_items(ih, path)
 #define path_changed(ih,path) comp_items (ih, path)
 
+/* array of the entry headers */
+ /* get item body */
+#define B_I_DEH(bh, ih) ((struct reiserfs_de_head *)(ih_item_body(bh, ih)))
+
+/* length of the directory entry in directory item. This define
+   calculates length of i-th directory entry using directory entry
+   locations from dir entry head. When it calculates length of 0-th
+   directory entry, it uses length of whole item in place of entry
+   location of the non-existent following entry in the calculation.
+   See picture above.*/
+/*
+#define I_DEH_N_ENTRY_LENGTH(ih,deh,i) \
+((i) ? (deh_location((deh)-1) - deh_location((deh))) : (ih_item_len((ih)) - deh_location((deh))))
+*/
+static inline int entry_length(const struct buffer_head *bh,
+                              const struct item_head *ih, int pos_in_item)
+{
+       struct reiserfs_de_head *deh;
+
+       deh = B_I_DEH(bh, ih) + pos_in_item;
+       if (pos_in_item)
+               return deh_location(deh - 1) - deh_location(deh);
+
+       return ih_item_len(ih) - deh_location(deh);
+}
+
 /***************************************************************************/
 /*                       MISC                                              */
 /***************************************************************************/
@@ -2226,22 +2285,6 @@ extern struct item_operations *item_ops[TYPE_ANY + 1];
 
 /* number of bytes contained by the direct item or the unformatted nodes the indirect item points to */
 
-/* get the item header */
-#define B_N_PITEM_HEAD(bh,item_num) ( (struct item_head * )((bh)->b_data + BLKH_SIZE) + (item_num) )
-
-/* get key */
-#define B_N_PDELIM_KEY(bh,item_num) ( (struct reiserfs_key * )((bh)->b_data + BLKH_SIZE) + (item_num) )
-
-/* get the key */
-#define B_N_PKEY(bh,item_num) ( &(B_N_PITEM_HEAD(bh,item_num)->ih_key) )
-
-/* get item body */
-#define B_N_PITEM(bh,item_num) ( (bh)->b_data + ih_location(B_N_PITEM_HEAD((bh),(item_num))))
-
-/* get the stat data by the buffer header and the item order */
-#define B_N_STAT_DATA(bh,nr) \
-( (struct stat_data *)((bh)->b_data + ih_location(B_N_PITEM_HEAD((bh),(nr))) ) )
-
     /* following defines use reiserfs buffer header and item header */
 
 /* get stat-data */
@@ -2253,8 +2296,10 @@ extern struct item_operations *item_ops[TYPE_ANY + 1];
 /* indirect items consist of entries which contain blocknrs, pos
    indicates which entry, and B_I_POS_UNFM_POINTER resolves to the
    blocknr contained by the entry pos points to */
-#define B_I_POS_UNFM_POINTER(bh,ih,pos) le32_to_cpu(*(((unp_t *)B_I_PITEM(bh,ih)) + (pos)))
-#define PUT_B_I_POS_UNFM_POINTER(bh,ih,pos, val) do {*(((unp_t *)B_I_PITEM(bh,ih)) + (pos)) = cpu_to_le32(val); } while (0)
+#define B_I_POS_UNFM_POINTER(bh, ih, pos)                              \
+       le32_to_cpu(*(((unp_t *)ih_item_body(bh, ih)) + (pos)))
+#define PUT_B_I_POS_UNFM_POINTER(bh, ih, pos, val)                     \
+       (*(((unp_t *)ih_item_body(bh, ih)) + (pos)) = cpu_to_le32(val))
 
 struct reiserfs_iget_args {
        __u32 objectid;
index b14706a05d520d4b960681cc6dd8d5e6231e32d2..40b3e77c8ff3bdc3a1ab4f8bbba738b8292049c1 100644 (file)
@@ -272,7 +272,7 @@ static inline const struct reiserfs_key *get_lkey(const struct treepath *chk_pat
                        return &MAX_KEY;
                /* Return delimiting key if position in the parent is not equal to zero. */
                if (position)
-                       return B_N_PDELIM_KEY(parent, position - 1);
+                       return internal_key(parent, position - 1);
        }
        /* Return MIN_KEY if we are in the root of the buffer tree. */
        if (PATH_OFFSET_PBUFFER(chk_path, FIRST_PATH_ELEMENT_OFFSET)->
@@ -315,7 +315,7 @@ inline const struct reiserfs_key *get_rkey(const struct treepath *chk_path,
                        return &MIN_KEY;
                /* Return delimiting key if position in the parent is not the last one. */
                if (position != B_NR_ITEMS(parent))
-                       return B_N_PDELIM_KEY(parent, position);
+                       return internal_key(parent, position);
        }
        /* Return MAX_KEY if we are in the root of the buffer tree. */
        if (PATH_OFFSET_PBUFFER(chk_path, FIRST_PATH_ELEMENT_OFFSET)->
@@ -732,7 +732,7 @@ int search_by_key(struct super_block *sb, const struct cpu_key *key,        /* Key to s
                       "vs-5152: tree level (%d) is less than stop level (%d)",
                       node_level, stop_level);
 
-               retval = bin_search(key, B_N_PITEM_HEAD(bh, 0),
+               retval = bin_search(key, item_head(bh, 0),
                                      B_NR_ITEMS(bh),
                                      (node_level ==
                                       DISK_LEAF_NODE_LEVEL) ? IH_SIZE :
@@ -779,7 +779,7 @@ int search_by_key(struct super_block *sb, const struct cpu_key *key,        /* Key to s
                                /*
                                 * check to make sure we're in the same object
                                 */
-                               le_key = B_N_PDELIM_KEY(bh, pos);
+                               le_key = internal_key(bh, pos);
                                if (le32_to_cpu(le_key->k_objectid) !=
                                    key->on_disk_key.k_objectid) {
                                        break;
@@ -830,7 +830,7 @@ int search_for_position_by_key(struct super_block *sb,      /* Pointer to the super b
        if (retval == ITEM_FOUND) {
 
                RFALSE(!ih_item_len
-                      (B_N_PITEM_HEAD
+                      (item_head
                        (PATH_PLAST_BUFFER(search_path),
                         PATH_LAST_POSITION(search_path))),
                       "PAP-5165: item length equals zero");
@@ -844,7 +844,7 @@ int search_for_position_by_key(struct super_block *sb,      /* Pointer to the super b
 
        /* Item is not found. Set path to the previous item. */
        p_le_ih =
-           B_N_PITEM_HEAD(PATH_PLAST_BUFFER(search_path),
+           item_head(PATH_PLAST_BUFFER(search_path),
                           --PATH_LAST_POSITION(search_path));
        blk_size = sb->s_blocksize;
 
@@ -892,7 +892,7 @@ int comp_items(const struct item_head *stored_ih, const struct treepath *path)
                return 1;
 
        /* we need only to know, whether it is the same item */
-       ih = get_ih(path);
+       ih = tp_item_head(path);
        return memcmp(stored_ih, ih, IH_SIZE);
 }
 
@@ -987,7 +987,7 @@ static char prepare_for_delete_or_cut(struct reiserfs_transaction_handle *th, st
     )
 {
        struct super_block *sb = inode->i_sb;
-       struct item_head *p_le_ih = PATH_PITEM_HEAD(path);
+       struct item_head *p_le_ih = tp_item_head(path);
        struct buffer_head *bh = PATH_PLAST_BUFFER(path);
 
        BUG_ON(!th->t_trans_id);
@@ -1033,7 +1033,7 @@ static char prepare_for_delete_or_cut(struct reiserfs_transaction_handle *th, st
                need_re_search = 0;
                *cut_size = 0;
                bh = PATH_PLAST_BUFFER(path);
-               copy_item_head(&s_ih, PATH_PITEM_HEAD(path));
+               copy_item_head(&s_ih, tp_item_head(path));
                pos = I_UNFM_NUM(&s_ih);
 
                while (le_ih_k_offset (&s_ih) + (pos - 1) * blk_size > new_file_length) {
@@ -1047,7 +1047,7 @@ static char prepare_for_delete_or_cut(struct reiserfs_transaction_handle *th, st
                        reiserfs_transaction_free_space(th) < JOURNAL_FOR_FREE_BLOCK_AND_UPDATE_SD)
                        break;
 
-                   unfm = (__le32 *)B_I_PITEM(bh, &s_ih) + pos - 1;
+                   unfm = (__le32 *)ih_item_body(bh, &s_ih) + pos - 1;
                    block = get_block_num(unfm, 0);
 
                    if (block != 0) {
@@ -1095,7 +1095,7 @@ static char prepare_for_delete_or_cut(struct reiserfs_transaction_handle *th, st
 static int calc_deleted_bytes_number(struct tree_balance *tb, char mode)
 {
        int del_size;
-       struct item_head *p_le_ih = PATH_PITEM_HEAD(tb->tb_path);
+       struct item_head *p_le_ih = tp_item_head(tb->tb_path);
 
        if (is_statdata_le_ih(p_le_ih))
                return 0;
@@ -1212,7 +1212,7 @@ int reiserfs_delete_item(struct reiserfs_transaction_handle *th,
 
                RFALSE(mode != M_DELETE, "PAP-5320: mode must be M_DELETE");
 
-               copy_item_head(&s_ih, PATH_PITEM_HEAD(path));
+               copy_item_head(&s_ih, tp_item_head(path));
                s_del_balance.insert_size[0] = del_size;
 
                ret_value = fix_nodes(M_DELETE, &s_del_balance, NULL, NULL);
@@ -1240,7 +1240,7 @@ int reiserfs_delete_item(struct reiserfs_transaction_handle *th,
        }
        // reiserfs_delete_item returns item length when success
        ret_value = calc_deleted_bytes_number(&s_del_balance, M_DELETE);
-       q_ih = get_ih(path);
+       q_ih = tp_item_head(path);
        quota_cut_bytes = ih_item_len(q_ih);
 
        /* hack so the quota code doesn't have to guess if the file
@@ -1284,7 +1284,7 @@ int reiserfs_delete_item(struct reiserfs_transaction_handle *th,
                data = kmap_atomic(un_bh->b_page);
                off = ((le_ih_k_offset(&s_ih) - 1) & (PAGE_CACHE_SIZE - 1));
                memcpy(data + off,
-                      B_I_PITEM(PATH_PLAST_BUFFER(path), &s_ih),
+                      ih_item_body(PATH_PLAST_BUFFER(path), &s_ih),
                       ret_value);
                kunmap_atomic(data);
        }
@@ -1362,11 +1362,11 @@ void reiserfs_delete_solid_item(struct reiserfs_transaction_handle *th,
                }
                if (!tb_init) {
                        tb_init = 1;
-                       item_len = ih_item_len(PATH_PITEM_HEAD(&path));
+                       item_len = ih_item_len(tp_item_head(&path));
                        init_tb_struct(th, &tb, th->t_super, &path,
                                       -(IH_SIZE + item_len));
                }
-               quota_cut_bytes = ih_item_len(PATH_PITEM_HEAD(&path));
+               quota_cut_bytes = ih_item_len(tp_item_head(&path));
 
                retval = fix_nodes(M_DELETE, &tb, NULL, NULL);
                if (retval == REPEAT_SEARCH) {
@@ -1521,7 +1521,7 @@ static void indirect_to_direct_roll_back(struct reiserfs_transaction_handle *th,
                        reiserfs_panic(inode->i_sb, "vs-5615",
                                       "found invalid item");
                RFALSE(path->pos_in_item !=
-                      ih_item_len(PATH_PITEM_HEAD(path)) - 1,
+                      ih_item_len(tp_item_head(path)) - 1,
                       "vs-5616: appended bytes found");
                PATH_LAST_POSITION(path)--;
 
@@ -1671,7 +1671,7 @@ int reiserfs_cut_from_item(struct reiserfs_transaction_handle *th,
        /* Calculate number of bytes that need to be cut from the item. */
        quota_cut_bytes =
            (mode ==
-            M_DELETE) ? ih_item_len(get_ih(path)) : -s_cut_balance.
+            M_DELETE) ? ih_item_len(tp_item_head(path)) : -s_cut_balance.
            insert_size[0];
        if (retval2 == -1)
                ret_value = calc_deleted_bytes_number(&s_cut_balance, mode);
@@ -1681,7 +1681,7 @@ int reiserfs_cut_from_item(struct reiserfs_transaction_handle *th,
        /* For direct items, we only change the quota when deleting the last
         ** item.
         */
-       p_le_ih = PATH_PITEM_HEAD(s_cut_balance.tb_path);
+       p_le_ih = tp_item_head(s_cut_balance.tb_path);
        if (!S_ISLNK(inode->i_mode) && is_direct_le_ih(p_le_ih)) {
                if (mode == M_DELETE &&
                    (le_ih_k_offset(p_le_ih) & (sb->s_blocksize - 1)) ==
@@ -1696,7 +1696,7 @@ int reiserfs_cut_from_item(struct reiserfs_transaction_handle *th,
 #ifdef CONFIG_REISERFS_CHECK
        if (is_inode_locked) {
                struct item_head *le_ih =
-                   PATH_PITEM_HEAD(s_cut_balance.tb_path);
+                   tp_item_head(s_cut_balance.tb_path);
                /* we are going to complete indirect2direct conversion. Make
                   sure, that we exactly remove last unformatted node pointer
                   of the item */
@@ -1819,7 +1819,7 @@ int reiserfs_do_truncate(struct reiserfs_transaction_handle *th,
        s_search_path.pos_in_item--;
 
        /* Get real file size (total length of all file items) */
-       p_le_ih = PATH_PITEM_HEAD(&s_search_path);
+       p_le_ih = tp_item_head(&s_search_path);
        if (is_statdata_le_ih(p_le_ih))
                file_size = 0;
        else {
@@ -1922,7 +1922,7 @@ int reiserfs_do_truncate(struct reiserfs_transaction_handle *th,
 static void check_research_for_paste(struct treepath *path,
                                     const struct cpu_key *key)
 {
-       struct item_head *found_ih = get_ih(path);
+       struct item_head *found_ih = tp_item_head(path);
 
        if (is_direct_le_ih(found_ih)) {
                if (le_ih_k_offset(found_ih) +
index 16927b80056214660b02a522ece424db73fe7cb9..c02b6b07508d47f960af50a1a6af190dd63ee0f1 100644 (file)
@@ -258,7 +258,7 @@ static int finish_unfinished(struct super_block *s)
                        break;
                }
                item_pos--;
-               ih = B_N_PITEM_HEAD(bh, item_pos);
+               ih = item_head(bh, item_pos);
 
                if (le32_to_cpu(ih->ih_key.k_dir_id) != MAX_KEY_OBJECTID)
                        /* there are no "save" links anymore */
@@ -271,7 +271,7 @@ static int finish_unfinished(struct super_block *s)
                        truncate = 0;
 
                /* reiserfs_iget needs k_dirid and k_objectid only */
-               item = B_I_PITEM(bh, ih);
+               item = ih_item_body(bh, ih);
                obj_key.on_disk_key.k_dir_id = le32_to_cpu(*(__le32 *) item);
                obj_key.on_disk_key.k_objectid =
                    le32_to_cpu(ih->ih_key.k_objectid);
index 5e2624d12f7025fb0e835d8bb47d4558956a9de0..fc1981d858dc35671ff60abe78515b4cf8fc20f1 100644 (file)
@@ -20,7 +20,7 @@ int direct2indirect(struct reiserfs_transaction_handle *th, struct inode *inode,
 {
        struct super_block *sb = inode->i_sb;
        struct buffer_head *up_to_date_bh;
-       struct item_head *p_le_ih = PATH_PITEM_HEAD(path);
+       struct item_head *p_le_ih = tp_item_head(path);
        unsigned long total_tail = 0;
        struct cpu_key end_key; /* Key to search for the last byte of the
                                   converted item. */
@@ -55,7 +55,7 @@ int direct2indirect(struct reiserfs_transaction_handle *th, struct inode *inode,
                return -EIO;
        }
 
-       p_le_ih = PATH_PITEM_HEAD(path);
+       p_le_ih = tp_item_head(path);
 
        unfm_ptr = cpu_to_le32(unbh->b_blocknr);
 
@@ -94,7 +94,7 @@ int direct2indirect(struct reiserfs_transaction_handle *th, struct inode *inode,
                    POSITION_FOUND)
                        reiserfs_panic(sb, "PAP-14050",
                                       "direct item (%K) not found", &end_key);
-               p_le_ih = PATH_PITEM_HEAD(path);
+               p_le_ih = tp_item_head(path);
                RFALSE(!is_direct_le_ih(p_le_ih),
                       "vs-14055: direct item expected(%K), found %h",
                       &end_key, p_le_ih);
@@ -194,7 +194,7 @@ int indirect2direct(struct reiserfs_transaction_handle *th,
        *mode = M_SKIP_BALANCING;
 
        /* store item head path points to. */
-       copy_item_head(&s_ih, PATH_PITEM_HEAD(path));
+       copy_item_head(&s_ih, tp_item_head(path));
 
        tail_len = (n_new_file_size & (block_size - 1));
        if (get_inode_sd_version(inode) == STAT_DATA_V2)
@@ -220,7 +220,7 @@ int indirect2direct(struct reiserfs_transaction_handle *th,
                        reiserfs_panic(sb, "PAP-5520",
                                       "item to be converted %K does not exist",
                                       item_key);
-               copy_item_head(&s_ih, PATH_PITEM_HEAD(path));
+               copy_item_head(&s_ih, tp_item_head(path));
 #ifdef CONFIG_REISERFS_CHECK
                pos = le_ih_k_offset(&s_ih) - 1 +
                    (ih_item_len(&s_ih) / UNFM_P_SIZE -