dect
/
linux-2.6
Archived
13
0
Fork 0
Code Releases Activity

reiserfs: rename p_s_sb to sb 

This patch is a simple s/p_s_sb/sb/g to the reiserfs code.  This is the
first in a series of patches to rip out some of the awful variable
naming in reiserfs.

Signed-off-by: Jeff Mahoney <jeffm@suse.com>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
This commit is contained in:
Jeff Mahoney 2009-03-30 14:02:45 -04:00 committed by Linus Torvalds
parent 0222e6571c
commit a9dd364358
5 changed files with 468 additions and 469 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

46
fs/reiserfs/fix_node.c
View File

@ -785,7 +785,7 @@ static int get_empty_nodes(struct tree_balance *p_s_tb, int n_h)
b_blocknr_t *p_n_blocknr, a_n_blocknrs[MAX_AMOUNT_NEEDED] = { 0, }; b_blocknr_t *p_n_blocknr, a_n_blocknrs[MAX_AMOUNT_NEEDED] = { 0, };
int n_counter, n_number_of_freeblk, n_amount_needed, /* number of needed empty blocks */ int n_counter, n_number_of_freeblk, n_amount_needed, /* number of needed empty blocks */
n_retval = CARRY_ON; n_retval = CARRY_ON;
struct super_block *p_s_sb = p_s_tb->tb_sb; struct super_block *sb = p_s_tb->tb_sb;
/* number_of_freeblk is the number of empty blocks which have been /* number_of_freeblk is the number of empty blocks which have been
acquired for use by the balancing algorithm minus the number of acquired for use by the balancing algorithm minus the number of
@ -830,7 +830,7 @@ static int get_empty_nodes(struct tree_balance *p_s_tb, int n_h)
RFALSE(!*p_n_blocknr, RFALSE(!*p_n_blocknr,
"PAP-8135: reiserfs_new_blocknrs failed when got new blocks"); "PAP-8135: reiserfs_new_blocknrs failed when got new blocks");
p_s_new_bh = sb_getblk(p_s_sb, *p_n_blocknr); p_s_new_bh = sb_getblk(sb, *p_n_blocknr);
RFALSE(buffer_dirty(p_s_new_bh) || RFALSE(buffer_dirty(p_s_new_bh) ||
buffer_journaled(p_s_new_bh) || buffer_journaled(p_s_new_bh) ||
buffer_journal_dirty(p_s_new_bh), buffer_journal_dirty(p_s_new_bh),
@ -899,7 +899,7 @@ static int get_rfree(struct tree_balance *tb, int h)
static int is_left_neighbor_in_cache(struct tree_balance *p_s_tb, int n_h) static int is_left_neighbor_in_cache(struct tree_balance *p_s_tb, int n_h)
{ {
struct buffer_head *p_s_father, *left; struct buffer_head *p_s_father, *left;
struct super_block *p_s_sb = p_s_tb->tb_sb; struct super_block *sb = p_s_tb->tb_sb;
b_blocknr_t n_left_neighbor_blocknr; b_blocknr_t n_left_neighbor_blocknr;
int n_left_neighbor_position; int n_left_neighbor_position;
@ -924,7 +924,7 @@ static int is_left_neighbor_in_cache(struct tree_balance *p_s_tb, int n_h)
n_left_neighbor_blocknr = n_left_neighbor_blocknr =
B_N_CHILD_NUM(p_s_tb->FL[n_h], n_left_neighbor_position); B_N_CHILD_NUM(p_s_tb->FL[n_h], n_left_neighbor_position);
/* Look for the left neighbor in the cache. */ /* Look for the left neighbor in the cache. */
if ((left = sb_find_get_block(p_s_sb, n_left_neighbor_blocknr))) { if ((left = sb_find_get_block(sb, n_left_neighbor_blocknr))) {
RFALSE(buffer_uptodate(left) && !B_IS_IN_TREE(left), RFALSE(buffer_uptodate(left) && !B_IS_IN_TREE(left),
"vs-8170: left neighbor (%b %z) is not in the tree", "vs-8170: left neighbor (%b %z) is not in the tree",
@ -1942,14 +1942,14 @@ static int get_neighbors(struct tree_balance *p_s_tb, int n_h)
int n_child_position, int n_child_position,
n_path_offset = PATH_H_PATH_OFFSET(p_s_tb->tb_path, n_h + 1); n_path_offset = PATH_H_PATH_OFFSET(p_s_tb->tb_path, n_h + 1);
unsigned long n_son_number; unsigned long n_son_number;
struct super_block *p_s_sb = p_s_tb->tb_sb; struct super_block *sb = p_s_tb->tb_sb;
struct buffer_head *p_s_bh; struct buffer_head *p_s_bh;
PROC_INFO_INC(p_s_sb, get_neighbors[n_h]); PROC_INFO_INC(sb, get_neighbors[n_h]);
if (p_s_tb->lnum[n_h]) { if (p_s_tb->lnum[n_h]) {
/* We need left neighbor to balance S[n_h]. */ /* We need left neighbor to balance S[n_h]. */
PROC_INFO_INC(p_s_sb, need_l_neighbor[n_h]); PROC_INFO_INC(sb, need_l_neighbor[n_h]);
p_s_bh = PATH_OFFSET_PBUFFER(p_s_tb->tb_path, n_path_offset); p_s_bh = PATH_OFFSET_PBUFFER(p_s_tb->tb_path, n_path_offset);
RFALSE(p_s_bh == p_s_tb->FL[n_h] && RFALSE(p_s_bh == p_s_tb->FL[n_h] &&
@ -1961,12 +1961,12 @@ static int get_neighbors(struct tree_balance *p_s_tb, int n_h)
p_s_tb->FL[n_h]) ? p_s_tb->lkey[n_h] : B_NR_ITEMS(p_s_tb-> p_s_tb->FL[n_h]) ? p_s_tb->lkey[n_h] : B_NR_ITEMS(p_s_tb->
FL[n_h]); FL[n_h]);
n_son_number = B_N_CHILD_NUM(p_s_tb->FL[n_h], n_child_position); n_son_number = B_N_CHILD_NUM(p_s_tb->FL[n_h], n_child_position);
p_s_bh = sb_bread(p_s_sb, n_son_number); p_s_bh = sb_bread(sb, n_son_number);
if (!p_s_bh) if (!p_s_bh)
return IO_ERROR; return IO_ERROR;
if (FILESYSTEM_CHANGED_TB(p_s_tb)) { if (FILESYSTEM_CHANGED_TB(p_s_tb)) {
brelse(p_s_bh); brelse(p_s_bh);
PROC_INFO_INC(p_s_sb, get_neighbors_restart[n_h]); PROC_INFO_INC(sb, get_neighbors_restart[n_h]);
return REPEAT_SEARCH; return REPEAT_SEARCH;
} }
@ -1986,7 +1986,7 @@ static int get_neighbors(struct tree_balance *p_s_tb, int n_h)
} }
if (p_s_tb->rnum[n_h]) { /* We need right neighbor to balance S[n_path_offset]. */ if (p_s_tb->rnum[n_h]) { /* We need right neighbor to balance S[n_path_offset]. */
PROC_INFO_INC(p_s_sb, need_r_neighbor[n_h]); PROC_INFO_INC(sb, need_r_neighbor[n_h]);
p_s_bh = PATH_OFFSET_PBUFFER(p_s_tb->tb_path, n_path_offset); p_s_bh = PATH_OFFSET_PBUFFER(p_s_tb->tb_path, n_path_offset);
RFALSE(p_s_bh == p_s_tb->FR[n_h] && RFALSE(p_s_bh == p_s_tb->FR[n_h] &&
@ -1998,12 +1998,12 @@ static int get_neighbors(struct tree_balance *p_s_tb, int n_h)
n_child_position = n_child_position =
(p_s_bh == p_s_tb->FR[n_h]) ? p_s_tb->rkey[n_h] + 1 : 0; (p_s_bh == p_s_tb->FR[n_h]) ? p_s_tb->rkey[n_h] + 1 : 0;
n_son_number = B_N_CHILD_NUM(p_s_tb->FR[n_h], n_child_position); n_son_number = B_N_CHILD_NUM(p_s_tb->FR[n_h], n_child_position);
p_s_bh = sb_bread(p_s_sb, n_son_number); p_s_bh = sb_bread(sb, n_son_number);
if (!p_s_bh) if (!p_s_bh)
return IO_ERROR; return IO_ERROR;
if (FILESYSTEM_CHANGED_TB(p_s_tb)) { if (FILESYSTEM_CHANGED_TB(p_s_tb)) {
brelse(p_s_bh); brelse(p_s_bh);
PROC_INFO_INC(p_s_sb, get_neighbors_restart[n_h]); PROC_INFO_INC(sb, get_neighbors_restart[n_h]);
return REPEAT_SEARCH; return REPEAT_SEARCH;
} }
brelse(p_s_tb->R[n_h]); brelse(p_s_tb->R[n_h]);
@ -2089,51 +2089,51 @@ static int get_mem_for_virtual_node(struct tree_balance *tb)
} }
#ifdef CONFIG_REISERFS_CHECK #ifdef CONFIG_REISERFS_CHECK
static void tb_buffer_sanity_check(struct super_block *p_s_sb, static void tb_buffer_sanity_check(struct super_block *sb,
struct buffer_head *p_s_bh, struct buffer_head *p_s_bh,
const char *descr, int level) const char *descr, int level)
{ {
if (p_s_bh) { if (p_s_bh) {
if (atomic_read(&(p_s_bh->b_count)) <= 0) { if (atomic_read(&(p_s_bh->b_count)) <= 0) {
reiserfs_panic(p_s_sb, "jmacd-1", "negative or zero " reiserfs_panic(sb, "jmacd-1", "negative or zero "
"reference counter for buffer %s[%d] " "reference counter for buffer %s[%d] "
"(%b)", descr, level, p_s_bh); "(%b)", descr, level, p_s_bh);
} }
if (!buffer_uptodate(p_s_bh)) { if (!buffer_uptodate(p_s_bh)) {
reiserfs_panic(p_s_sb, "jmacd-2", "buffer is not up " reiserfs_panic(sb, "jmacd-2", "buffer is not up "
"to date %s[%d] (%b)", "to date %s[%d] (%b)",
descr, level, p_s_bh); descr, level, p_s_bh);
} }
if (!B_IS_IN_TREE(p_s_bh)) { if (!B_IS_IN_TREE(p_s_bh)) {
reiserfs_panic(p_s_sb, "jmacd-3", "buffer is not " reiserfs_panic(sb, "jmacd-3", "buffer is not "
"in tree %s[%d] (%b)", "in tree %s[%d] (%b)",
descr, level, p_s_bh); descr, level, p_s_bh);
} }
if (p_s_bh->b_bdev != p_s_sb->s_bdev) { if (p_s_bh->b_bdev != sb->s_bdev) {
reiserfs_panic(p_s_sb, "jmacd-4", "buffer has wrong " reiserfs_panic(sb, "jmacd-4", "buffer has wrong "
"device %s[%d] (%b)", "device %s[%d] (%b)",
descr, level, p_s_bh); descr, level, p_s_bh);
} }
if (p_s_bh->b_size != p_s_sb->s_blocksize) { if (p_s_bh->b_size != sb->s_blocksize) {
reiserfs_panic(p_s_sb, "jmacd-5", "buffer has wrong " reiserfs_panic(sb, "jmacd-5", "buffer has wrong "
"blocksize %s[%d] (%b)", "blocksize %s[%d] (%b)",
descr, level, p_s_bh); descr, level, p_s_bh);
} }
if (p_s_bh->b_blocknr > SB_BLOCK_COUNT(p_s_sb)) { if (p_s_bh->b_blocknr > SB_BLOCK_COUNT(sb)) {
reiserfs_panic(p_s_sb, "jmacd-6", "buffer block " reiserfs_panic(sb, "jmacd-6", "buffer block "
"number too high %s[%d] (%b)", "number too high %s[%d] (%b)",
descr, level, p_s_bh); descr, level, p_s_bh);
} }
} }
} }
#else #else
static void tb_buffer_sanity_check(struct super_block *p_s_sb, static void tb_buffer_sanity_check(struct super_block *sb,
struct buffer_head *p_s_bh, struct buffer_head *p_s_bh,
const char *descr, int level) const char *descr, int level)
{; {;

735
fs/reiserfs/journal.c
View File

File diff suppressed because it is too large Load Diff

126
fs/reiserfs/stree.c
View File

@ -245,7 +245,7 @@ static const struct reiserfs_key MAX_KEY = {
static inline const struct reiserfs_key *get_lkey(const struct treepath static inline const struct reiserfs_key *get_lkey(const struct treepath
*p_s_chk_path, *p_s_chk_path,
const struct super_block const struct super_block
*p_s_sb) *sb)
{ {
int n_position, n_path_offset = p_s_chk_path->path_length; int n_position, n_path_offset = p_s_chk_path->path_length;
struct buffer_head *p_s_parent; struct buffer_head *p_s_parent;
@ -282,14 +282,14 @@ static inline const struct reiserfs_key *get_lkey(const struct treepath
} }
/* Return MIN_KEY if we are in the root of the buffer tree. */ /* Return MIN_KEY if we are in the root of the buffer tree. */
if (PATH_OFFSET_PBUFFER(p_s_chk_path, FIRST_PATH_ELEMENT_OFFSET)-> if (PATH_OFFSET_PBUFFER(p_s_chk_path, FIRST_PATH_ELEMENT_OFFSET)->
b_blocknr == SB_ROOT_BLOCK(p_s_sb)) b_blocknr == SB_ROOT_BLOCK(sb))
return &MIN_KEY; return &MIN_KEY;
return &MAX_KEY; return &MAX_KEY;
} }
/* Get delimiting key of the buffer at the path and its right neighbor. */ /* Get delimiting key of the buffer at the path and its right neighbor. */
inline const struct reiserfs_key *get_rkey(const struct treepath *p_s_chk_path, inline const struct reiserfs_key *get_rkey(const struct treepath *p_s_chk_path,
const struct super_block *p_s_sb) const struct super_block *sb)
{ {
int n_position, n_path_offset = p_s_chk_path->path_length; int n_position, n_path_offset = p_s_chk_path->path_length;
struct buffer_head *p_s_parent; struct buffer_head *p_s_parent;
@ -325,7 +325,7 @@ inline const struct reiserfs_key *get_rkey(const struct treepath *p_s_chk_path,
} }
/* Return MAX_KEY if we are in the root of the buffer tree. */ /* Return MAX_KEY if we are in the root of the buffer tree. */
if (PATH_OFFSET_PBUFFER(p_s_chk_path, FIRST_PATH_ELEMENT_OFFSET)-> if (PATH_OFFSET_PBUFFER(p_s_chk_path, FIRST_PATH_ELEMENT_OFFSET)->
b_blocknr == SB_ROOT_BLOCK(p_s_sb)) b_blocknr == SB_ROOT_BLOCK(sb))
return &MAX_KEY; return &MAX_KEY;
return &MIN_KEY; return &MIN_KEY;
} }
@ -337,7 +337,7 @@ inline const struct reiserfs_key *get_rkey(const struct treepath *p_s_chk_path,
this case get_lkey and get_rkey return a special key which is MIN_KEY or MAX_KEY. */ this case get_lkey and get_rkey return a special key which is MIN_KEY or MAX_KEY. */
static inline int key_in_buffer(struct treepath *p_s_chk_path, /* Path which should be checked. */ static inline int key_in_buffer(struct treepath *p_s_chk_path, /* Path which should be checked. */
const struct cpu_key *p_s_key, /* Key which should be checked. */ const struct cpu_key *p_s_key, /* Key which should be checked. */
struct super_block *p_s_sb /* Super block pointer. */ struct super_block *sb /* Super block pointer. */
) )
{ {
@ -348,11 +348,11 @@ static inline int key_in_buffer(struct treepath *p_s_chk_path, /* Path which sho
RFALSE(!PATH_PLAST_BUFFER(p_s_chk_path)->b_bdev, RFALSE(!PATH_PLAST_BUFFER(p_s_chk_path)->b_bdev,
"PAP-5060: device must not be NODEV"); "PAP-5060: device must not be NODEV");
if (comp_keys(get_lkey(p_s_chk_path, p_s_sb), p_s_key) == 1) if (comp_keys(get_lkey(p_s_chk_path, sb), p_s_key) == 1)
/* left delimiting key is bigger, that the key we look for */ /* left delimiting key is bigger, that the key we look for */
return 0; return 0;
// if ( comp_keys(p_s_key, get_rkey(p_s_chk_path, p_s_sb)) != -1 ) // if ( comp_keys(p_s_key, get_rkey(p_s_chk_path, sb)) != -1 )
if (comp_keys(get_rkey(p_s_chk_path, p_s_sb), p_s_key) != 1) if (comp_keys(get_rkey(p_s_chk_path, sb), p_s_key) != 1)
/* p_s_key must be less than right delimitiing key */ /* p_s_key must be less than right delimitiing key */
return 0; return 0;
return 1; return 1;
@ -546,7 +546,7 @@ static void search_by_key_reada(struct super_block *s,
/************************************************************************** /**************************************************************************
* Algorithm SearchByKey * * Algorithm SearchByKey *
* look for item in the Disk S+Tree by its key * * look for item in the Disk S+Tree by its key *
* Input: p_s_sb - super block * * Input: sb - super block *
* p_s_key - pointer to the key to search * * p_s_key - pointer to the key to search *
* Output: ITEM_FOUND, ITEM_NOT_FOUND or IO_ERROR * * Output: ITEM_FOUND, ITEM_NOT_FOUND or IO_ERROR *
* p_s_search_path - path from the root to the needed leaf * * p_s_search_path - path from the root to the needed leaf *
@ -566,7 +566,7 @@ static void search_by_key_reada(struct super_block *s,
correctness of the top of the path but need not be checked for the correctness of the top of the path but need not be checked for the
correctness of the bottom of the path */ correctness of the bottom of the path */
/* The function is NOT SCHEDULE-SAFE! */ /* The function is NOT SCHEDULE-SAFE! */
int search_by_key(struct super_block *p_s_sb, const struct cpu_key *p_s_key, /* Key to search. */ int search_by_key(struct super_block *sb, const struct cpu_key *p_s_key, /* Key to search. */
struct treepath *p_s_search_path,/* This structure was struct treepath *p_s_search_path,/* This structure was
allocated and initialized allocated and initialized
by the calling by the calling
@ -592,7 +592,7 @@ int search_by_key(struct super_block *p_s_sb, const struct cpu_key *p_s_key, /*
int n_repeat_counter = 0; int n_repeat_counter = 0;
#endif #endif
PROC_INFO_INC(p_s_sb, search_by_key); PROC_INFO_INC(sb, search_by_key);
/* As we add each node to a path we increase its count. This means that /* As we add each node to a path we increase its count. This means that
we must be careful to release all nodes in a path before we either we must be careful to release all nodes in a path before we either
@ -605,13 +605,13 @@ int search_by_key(struct super_block *p_s_sb, const struct cpu_key *p_s_key, /*
/* With each iteration of this loop we search through the items in the /* With each iteration of this loop we search through the items in the
current node, and calculate the next current node(next path element) current node, and calculate the next current node(next path element)
for the next iteration of this loop.. */ for the next iteration of this loop.. */
n_block_number = SB_ROOT_BLOCK(p_s_sb); n_block_number = SB_ROOT_BLOCK(sb);
expected_level = -1; expected_level = -1;
while (1) { while (1) {
#ifdef CONFIG_REISERFS_CHECK #ifdef CONFIG_REISERFS_CHECK
if (!(++n_repeat_counter % 50000)) if (!(++n_repeat_counter % 50000))
reiserfs_warning(p_s_sb, "PAP-5100", reiserfs_warning(sb, "PAP-5100",
"%s: there were %d iterations of " "%s: there were %d iterations of "
"while loop looking for key %K", "while loop looking for key %K",
current->comm, n_repeat_counter, current->comm, n_repeat_counter,
@ -622,14 +622,14 @@ int search_by_key(struct super_block *p_s_sb, const struct cpu_key *p_s_key, /*
p_s_last_element = p_s_last_element =
PATH_OFFSET_PELEMENT(p_s_search_path, PATH_OFFSET_PELEMENT(p_s_search_path,
++p_s_search_path->path_length); ++p_s_search_path->path_length);
fs_gen = get_generation(p_s_sb); fs_gen = get_generation(sb);
/* Read the next tree node, and set the last element in the path to /* Read the next tree node, and set the last element in the path to
have a pointer to it. */ have a pointer to it. */
if ((p_s_bh = p_s_last_element->pe_buffer = if ((p_s_bh = p_s_last_element->pe_buffer =
sb_getblk(p_s_sb, n_block_number))) { sb_getblk(sb, n_block_number))) {
if (!buffer_uptodate(p_s_bh) && reada_count > 1) { if (!buffer_uptodate(p_s_bh) && reada_count > 1) {
search_by_key_reada(p_s_sb, reada_bh, search_by_key_reada(sb, reada_bh,
reada_blocks, reada_count); reada_blocks, reada_count);
} }
ll_rw_block(READ, 1, &p_s_bh); ll_rw_block(READ, 1, &p_s_bh);
@ -644,25 +644,25 @@ int search_by_key(struct super_block *p_s_sb, const struct cpu_key *p_s_key, /*
} }
reada_count = 0; reada_count = 0;
if (expected_level == -1) if (expected_level == -1)
expected_level = SB_TREE_HEIGHT(p_s_sb); expected_level = SB_TREE_HEIGHT(sb);
expected_level--; expected_level--;
/* It is possible that schedule occurred. We must check whether the key /* It is possible that schedule occurred. We must check whether the key
to search is still in the tree rooted from the current buffer. If to search is still in the tree rooted from the current buffer. If
not then repeat search from the root. */ not then repeat search from the root. */
if (fs_changed(fs_gen, p_s_sb) && if (fs_changed(fs_gen, sb) &&
(!B_IS_IN_TREE(p_s_bh) || (!B_IS_IN_TREE(p_s_bh) ||
B_LEVEL(p_s_bh) != expected_level || B_LEVEL(p_s_bh) != expected_level ||
!key_in_buffer(p_s_search_path, p_s_key, p_s_sb))) { !key_in_buffer(p_s_search_path, p_s_key, sb))) {
PROC_INFO_INC(p_s_sb, search_by_key_fs_changed); PROC_INFO_INC(sb, search_by_key_fs_changed);
PROC_INFO_INC(p_s_sb, search_by_key_restarted); PROC_INFO_INC(sb, search_by_key_restarted);
PROC_INFO_INC(p_s_sb, PROC_INFO_INC(sb,
sbk_restarted[expected_level - 1]); sbk_restarted[expected_level - 1]);
pathrelse(p_s_search_path); pathrelse(p_s_search_path);
/* Get the root block number so that we can repeat the search /* Get the root block number so that we can repeat the search
starting from the root. */ starting from the root. */
n_block_number = SB_ROOT_BLOCK(p_s_sb); n_block_number = SB_ROOT_BLOCK(sb);
expected_level = -1; expected_level = -1;
right_neighbor_of_leaf_node = 0; right_neighbor_of_leaf_node = 0;
@ -674,12 +674,12 @@ int search_by_key(struct super_block *p_s_sb, const struct cpu_key *p_s_key, /*
equal to the MAX_KEY. Latter case is only possible in equal to the MAX_KEY. Latter case is only possible in
"finish_unfinished()" processing during mount. */ "finish_unfinished()" processing during mount. */
RFALSE(comp_keys(&MAX_KEY, p_s_key) && RFALSE(comp_keys(&MAX_KEY, p_s_key) &&
!key_in_buffer(p_s_search_path, p_s_key, p_s_sb), !key_in_buffer(p_s_search_path, p_s_key, sb),
"PAP-5130: key is not in the buffer"); "PAP-5130: key is not in the buffer");
#ifdef CONFIG_REISERFS_CHECK #ifdef CONFIG_REISERFS_CHECK
if (cur_tb) { if (cur_tb) {
print_cur_tb("5140"); print_cur_tb("5140");
reiserfs_panic(p_s_sb, "PAP-5140", reiserfs_panic(sb, "PAP-5140",
"schedule occurred in do_balance!"); "schedule occurred in do_balance!");
} }
#endif #endif
@ -687,7 +687,7 @@ int search_by_key(struct super_block *p_s_sb, const struct cpu_key *p_s_key, /*
// make sure, that the node contents look like a node of // make sure, that the node contents look like a node of
// certain level // certain level
if (!is_tree_node(p_s_bh, expected_level)) { if (!is_tree_node(p_s_bh, expected_level)) {
reiserfs_error(p_s_sb, "vs-5150", reiserfs_error(sb, "vs-5150",
"invalid format found in block %ld. " "invalid format found in block %ld. "
"Fsck?", p_s_bh->b_blocknr); "Fsck?", p_s_bh->b_blocknr);
pathrelse(p_s_search_path); pathrelse(p_s_search_path);
@ -697,7 +697,7 @@ int search_by_key(struct super_block *p_s_sb, const struct cpu_key *p_s_key, /*
/* ok, we have acquired next formatted node in the tree */ /* ok, we have acquired next formatted node in the tree */
n_node_level = B_LEVEL(p_s_bh); n_node_level = B_LEVEL(p_s_bh);
PROC_INFO_BH_STAT(p_s_sb, p_s_bh, n_node_level - 1); PROC_INFO_BH_STAT(sb, p_s_bh, n_node_level - 1);
RFALSE(n_node_level < n_stop_level, RFALSE(n_node_level < n_stop_level,
"vs-5152: tree level (%d) is less than stop level (%d)", "vs-5152: tree level (%d) is less than stop level (%d)",
@ -776,7 +776,7 @@ int search_by_key(struct super_block *p_s_sb, const struct cpu_key *p_s_key, /*
units of directory entries. */ units of directory entries. */
/* The function is NOT SCHEDULE-SAFE! */ /* The function is NOT SCHEDULE-SAFE! */
int search_for_position_by_key(struct super_block *p_s_sb, /* Pointer to the super block. */ int search_for_position_by_key(struct super_block *sb, /* Pointer to the super block. */
const struct cpu_key *p_cpu_key, /* Key to search (cpu variable) */ const struct cpu_key *p_cpu_key, /* Key to search (cpu variable) */
struct treepath *p_s_search_path /* Filled up by this function. */ struct treepath *p_s_search_path /* Filled up by this function. */
) )
@ -789,13 +789,13 @@ int search_for_position_by_key(struct super_block *p_s_sb, /* Pointer to the sup
/* If searching for directory entry. */ /* If searching for directory entry. */
if (is_direntry_cpu_key(p_cpu_key)) if (is_direntry_cpu_key(p_cpu_key))
return search_by_entry_key(p_s_sb, p_cpu_key, p_s_search_path, return search_by_entry_key(sb, p_cpu_key, p_s_search_path,
&de); &de);
/* If not searching for directory entry. */ /* If not searching for directory entry. */
/* If item is found. */ /* If item is found. */
retval = search_item(p_s_sb, p_cpu_key, p_s_search_path); retval = search_item(sb, p_cpu_key, p_s_search_path);
if (retval == IO_ERROR) if (retval == IO_ERROR)
return retval; return retval;
if (retval == ITEM_FOUND) { if (retval == ITEM_FOUND) {
@ -817,7 +817,7 @@ int search_for_position_by_key(struct super_block *p_s_sb, /* Pointer to the sup
p_le_ih = p_le_ih =
B_N_PITEM_HEAD(PATH_PLAST_BUFFER(p_s_search_path), B_N_PITEM_HEAD(PATH_PLAST_BUFFER(p_s_search_path),
--PATH_LAST_POSITION(p_s_search_path)); --PATH_LAST_POSITION(p_s_search_path));
n_blk_size = p_s_sb->s_blocksize; n_blk_size = sb->s_blocksize;
if (comp_short_keys(&(p_le_ih->ih_key), p_cpu_key)) { if (comp_short_keys(&(p_le_ih->ih_key), p_cpu_key)) {
return FILE_NOT_FOUND; return FILE_NOT_FOUND;
@ -957,7 +957,7 @@ static char prepare_for_delete_or_cut(struct reiserfs_transaction_handle *th, st
int *p_n_cut_size, unsigned long long n_new_file_length /* MAX_KEY_OFFSET in case of delete. */ int *p_n_cut_size, unsigned long long n_new_file_length /* MAX_KEY_OFFSET in case of delete. */
) )
{ {
struct super_block *p_s_sb = inode->i_sb; struct super_block *sb = inode->i_sb;
struct item_head *p_le_ih = PATH_PITEM_HEAD(p_s_path); struct item_head *p_le_ih = PATH_PITEM_HEAD(p_s_path);
struct buffer_head *p_s_bh = PATH_PLAST_BUFFER(p_s_path); struct buffer_head *p_s_bh = PATH_PLAST_BUFFER(p_s_path);
@ -986,7 +986,7 @@ static char prepare_for_delete_or_cut(struct reiserfs_transaction_handle *th, st
/* Case of an indirect item. */ /* Case of an indirect item. */
{ {
int blk_size = p_s_sb->s_blocksize; int blk_size = sb->s_blocksize;
struct item_head s_ih; struct item_head s_ih;
int need_re_search; int need_re_search;
int delete = 0; int delete = 0;
@ -1023,9 +1023,9 @@ static char prepare_for_delete_or_cut(struct reiserfs_transaction_handle *th, st
block = get_block_num(unfm, 0); block = get_block_num(unfm, 0);
if (block != 0) { if (block != 0) {
reiserfs_prepare_for_journal(p_s_sb, p_s_bh, 1); reiserfs_prepare_for_journal(sb, p_s_bh, 1);
put_block_num(unfm, 0, 0); put_block_num(unfm, 0, 0);
journal_mark_dirty (th, p_s_sb, p_s_bh); journal_mark_dirty (th, sb, p_s_bh);
reiserfs_free_block(th, inode, block, 1); reiserfs_free_block(th, inode, block, 1);
} }
@ -1049,9 +1049,9 @@ static char prepare_for_delete_or_cut(struct reiserfs_transaction_handle *th, st
/* a trick. If the buffer has been logged, this will do nothing. If /* a trick. If the buffer has been logged, this will do nothing. If
** we've broken the loop without logging it, it will restore the ** we've broken the loop without logging it, it will restore the
** buffer */ ** buffer */
reiserfs_restore_prepared_buffer(p_s_sb, p_s_bh); reiserfs_restore_prepared_buffer(sb, p_s_bh);
} while (need_re_search && } while (need_re_search &&
search_for_position_by_key(p_s_sb, p_s_item_key, p_s_path) == POSITION_FOUND); search_for_position_by_key(sb, p_s_item_key, p_s_path) == POSITION_FOUND);
pos_in_item(p_s_path) = pos * UNFM_P_SIZE; pos_in_item(p_s_path) = pos * UNFM_P_SIZE;
if (*p_n_cut_size == 0) { if (*p_n_cut_size == 0) {
@ -1090,7 +1090,7 @@ static int calc_deleted_bytes_number(struct tree_balance *p_s_tb, char c_mode)
static void init_tb_struct(struct reiserfs_transaction_handle *th, static void init_tb_struct(struct reiserfs_transaction_handle *th,
struct tree_balance *p_s_tb, struct tree_balance *p_s_tb,
struct super_block *p_s_sb, struct super_block *sb,
struct treepath *p_s_path, int n_size) struct treepath *p_s_path, int n_size)
{ {
@ -1098,7 +1098,7 @@ static void init_tb_struct(struct reiserfs_transaction_handle *th,
memset(p_s_tb, '\0', sizeof(struct tree_balance)); memset(p_s_tb, '\0', sizeof(struct tree_balance));
p_s_tb->transaction_handle = th; p_s_tb->transaction_handle = th;
p_s_tb->tb_sb = p_s_sb; p_s_tb->tb_sb = sb;
p_s_tb->tb_path = p_s_path; p_s_tb->tb_path = p_s_path;
PATH_OFFSET_PBUFFER(p_s_path, ILLEGAL_PATH_ELEMENT_OFFSET) = NULL; PATH_OFFSET_PBUFFER(p_s_path, ILLEGAL_PATH_ELEMENT_OFFSET) = NULL;
PATH_OFFSET_POSITION(p_s_path, ILLEGAL_PATH_ELEMENT_OFFSET) = 0; PATH_OFFSET_POSITION(p_s_path, ILLEGAL_PATH_ELEMENT_OFFSET) = 0;
@ -1147,7 +1147,7 @@ int reiserfs_delete_item(struct reiserfs_transaction_handle *th, struct treepath
struct inode *p_s_inode, /* inode is here just to update i_blocks and quotas */ struct inode *p_s_inode, /* inode is here just to update i_blocks and quotas */
struct buffer_head *p_s_un_bh) struct buffer_head *p_s_un_bh)
{ /* NULL or unformatted node pointer. */ { /* NULL or unformatted node pointer. */
struct super_block *p_s_sb = p_s_inode->i_sb; struct super_block *sb = p_s_inode->i_sb;
struct tree_balance s_del_balance; struct tree_balance s_del_balance;
struct item_head s_ih; struct item_head s_ih;
struct item_head *q_ih; struct item_head *q_ih;
@ -1161,7 +1161,7 @@ int reiserfs_delete_item(struct reiserfs_transaction_handle *th, struct treepath
BUG_ON(!th->t_trans_id); BUG_ON(!th->t_trans_id);
init_tb_struct(th, &s_del_balance, p_s_sb, p_s_path, init_tb_struct(th, &s_del_balance, sb, p_s_path,
0 /*size is unknown */ ); 0 /*size is unknown */ );
while (1) { while (1) {
@ -1185,15 +1185,15 @@ int reiserfs_delete_item(struct reiserfs_transaction_handle *th, struct treepath
if (n_ret_value != REPEAT_SEARCH) if (n_ret_value != REPEAT_SEARCH)
break; break;
PROC_INFO_INC(p_s_sb, delete_item_restarted); PROC_INFO_INC(sb, delete_item_restarted);
// file system changed, repeat search // file system changed, repeat search
n_ret_value = n_ret_value =
search_for_position_by_key(p_s_sb, p_s_item_key, p_s_path); search_for_position_by_key(sb, p_s_item_key, p_s_path);
if (n_ret_value == IO_ERROR) if (n_ret_value == IO_ERROR)
break; break;
if (n_ret_value == FILE_NOT_FOUND) { if (n_ret_value == FILE_NOT_FOUND) {
reiserfs_warning(p_s_sb, "vs-5340", reiserfs_warning(sb, "vs-5340",
"no items of the file %K found", "no items of the file %K found",
p_s_item_key); p_s_item_key);
break; break;
@ -1216,8 +1216,8 @@ int reiserfs_delete_item(struct reiserfs_transaction_handle *th, struct treepath
** the unfm node once ** the unfm node once
*/ */
if (!S_ISLNK(p_s_inode->i_mode) && is_direct_le_ih(q_ih)) { if (!S_ISLNK(p_s_inode->i_mode) && is_direct_le_ih(q_ih)) {
if ((le_ih_k_offset(q_ih) & (p_s_sb->s_blocksize - 1)) == 1) { if ((le_ih_k_offset(q_ih) & (sb->s_blocksize - 1)) == 1) {
quota_cut_bytes = p_s_sb->s_blocksize + UNFM_P_SIZE; quota_cut_bytes = sb->s_blocksize + UNFM_P_SIZE;
} else { } else {
quota_cut_bytes = 0; quota_cut_bytes = 0;
} }
@ -1258,7 +1258,7 @@ int reiserfs_delete_item(struct reiserfs_transaction_handle *th, struct treepath
do_balance(&s_del_balance, NULL, NULL, M_DELETE); do_balance(&s_del_balance, NULL, NULL, M_DELETE);
#ifdef REISERQUOTA_DEBUG #ifdef REISERQUOTA_DEBUG
reiserfs_debug(p_s_sb, REISERFS_DEBUG_CODE, reiserfs_debug(sb, REISERFS_DEBUG_CODE,
"reiserquota delete_item(): freeing %u, id=%u type=%c", "reiserquota delete_item(): freeing %u, id=%u type=%c",
quota_cut_bytes, p_s_inode->i_uid, head2type(&s_ih)); quota_cut_bytes, p_s_inode->i_uid, head2type(&s_ih));
#endif #endif
@ -1430,8 +1430,8 @@ static int maybe_indirect_to_direct(struct reiserfs_transaction_handle *th,
const struct cpu_key *p_s_item_key, const struct cpu_key *p_s_item_key,
loff_t n_new_file_size, char *p_c_mode) loff_t n_new_file_size, char *p_c_mode)
{ {
struct super_block *p_s_sb = p_s_inode->i_sb; struct super_block *sb = p_s_inode->i_sb;
int n_block_size = p_s_sb->s_blocksize; int n_block_size = sb->s_blocksize;
int cut_bytes; int cut_bytes;
BUG_ON(!th->t_trans_id); BUG_ON(!th->t_trans_id);
BUG_ON(n_new_file_size != p_s_inode->i_size); BUG_ON(n_new_file_size != p_s_inode->i_size);
@ -1509,7 +1509,7 @@ int reiserfs_cut_from_item(struct reiserfs_transaction_handle *th,
struct inode *p_s_inode, struct inode *p_s_inode,
struct page *page, loff_t n_new_file_size) struct page *page, loff_t n_new_file_size)
{ {
struct super_block *p_s_sb = p_s_inode->i_sb; struct super_block *sb = p_s_inode->i_sb;
/* Every function which is going to call do_balance must first /* Every function which is going to call do_balance must first
create a tree_balance structure. Then it must fill up this create a tree_balance structure. Then it must fill up this
structure by using the init_tb_struct and fix_nodes functions. structure by using the init_tb_struct and fix_nodes functions.
@ -1560,7 +1560,7 @@ int reiserfs_cut_from_item(struct reiserfs_transaction_handle *th,
/* removing of last unformatted node will change value we /* removing of last unformatted node will change value we
have to return to truncate. Save it */ have to return to truncate. Save it */
retval2 = n_ret_value; retval2 = n_ret_value;
/*retval2 = p_s_sb->s_blocksize - (n_new_file_size & (p_s_sb->s_blocksize - 1)); */ /*retval2 = sb->s_blocksize - (n_new_file_size & (sb->s_blocksize - 1)); */
/* So, we have performed the first part of the conversion: /* So, we have performed the first part of the conversion:
inserting the new direct item. Now we are removing the inserting the new direct item. Now we are removing the
@ -1569,16 +1569,16 @@ int reiserfs_cut_from_item(struct reiserfs_transaction_handle *th,
set_cpu_key_k_type(p_s_item_key, TYPE_INDIRECT); set_cpu_key_k_type(p_s_item_key, TYPE_INDIRECT);
p_s_item_key->key_length = 4; p_s_item_key->key_length = 4;
n_new_file_size -= n_new_file_size -=
(n_new_file_size & (p_s_sb->s_blocksize - 1)); (n_new_file_size & (sb->s_blocksize - 1));
tail_pos = n_new_file_size; tail_pos = n_new_file_size;
set_cpu_key_k_offset(p_s_item_key, n_new_file_size + 1); set_cpu_key_k_offset(p_s_item_key, n_new_file_size + 1);
if (search_for_position_by_key if (search_for_position_by_key
(p_s_sb, p_s_item_key, (sb, p_s_item_key,
p_s_path) == POSITION_NOT_FOUND) { p_s_path) == POSITION_NOT_FOUND) {
print_block(PATH_PLAST_BUFFER(p_s_path), 3, print_block(PATH_PLAST_BUFFER(p_s_path), 3,
PATH_LAST_POSITION(p_s_path) - 1, PATH_LAST_POSITION(p_s_path) - 1,
PATH_LAST_POSITION(p_s_path) + 1); PATH_LAST_POSITION(p_s_path) + 1);
reiserfs_panic(p_s_sb, "PAP-5580", "item to " reiserfs_panic(sb, "PAP-5580", "item to "
"convert does not exist (%K)", "convert does not exist (%K)",
p_s_item_key); p_s_item_key);
} }
@ -1595,14 +1595,14 @@ int reiserfs_cut_from_item(struct reiserfs_transaction_handle *th,
if (n_ret_value != REPEAT_SEARCH) if (n_ret_value != REPEAT_SEARCH)
break; break;
PROC_INFO_INC(p_s_sb, cut_from_item_restarted); PROC_INFO_INC(sb, cut_from_item_restarted);
n_ret_value = n_ret_value =
search_for_position_by_key(p_s_sb, p_s_item_key, p_s_path); search_for_position_by_key(sb, p_s_item_key, p_s_path);
if (n_ret_value == POSITION_FOUND) if (n_ret_value == POSITION_FOUND)
continue; continue;
reiserfs_warning(p_s_sb, "PAP-5610", "item %K not found", reiserfs_warning(sb, "PAP-5610", "item %K not found",
p_s_item_key); p_s_item_key);
unfix_nodes(&s_cut_balance); unfix_nodes(&s_cut_balance);
return (n_ret_value == IO_ERROR) ? -EIO : -ENOENT; return (n_ret_value == IO_ERROR) ? -EIO : -ENOENT;
@ -1616,7 +1616,7 @@ int reiserfs_cut_from_item(struct reiserfs_transaction_handle *th,
indirect_to_direct_roll_back(th, p_s_inode, p_s_path); indirect_to_direct_roll_back(th, p_s_inode, p_s_path);
} }
if (n_ret_value == NO_DISK_SPACE) if (n_ret_value == NO_DISK_SPACE)
reiserfs_warning(p_s_sb, "reiserfs-5092", reiserfs_warning(sb, "reiserfs-5092",
"NO_DISK_SPACE"); "NO_DISK_SPACE");
unfix_nodes(&s_cut_balance); unfix_nodes(&s_cut_balance);
return -EIO; return -EIO;
@ -1642,11 +1642,11 @@ int reiserfs_cut_from_item(struct reiserfs_transaction_handle *th,
p_le_ih = PATH_PITEM_HEAD(s_cut_balance.tb_path); p_le_ih = PATH_PITEM_HEAD(s_cut_balance.tb_path);
if (!S_ISLNK(p_s_inode->i_mode) && is_direct_le_ih(p_le_ih)) { if (!S_ISLNK(p_s_inode->i_mode) && is_direct_le_ih(p_le_ih)) {
if (c_mode == M_DELETE && if (c_mode == M_DELETE &&
(le_ih_k_offset(p_le_ih) & (p_s_sb->s_blocksize - 1)) == (le_ih_k_offset(p_le_ih) & (sb->s_blocksize - 1)) ==
1) { 1) {
// FIXME: this is to keep 3.5 happy // FIXME: this is to keep 3.5 happy
REISERFS_I(p_s_inode)->i_first_direct_byte = U32_MAX; REISERFS_I(p_s_inode)->i_first_direct_byte = U32_MAX;
quota_cut_bytes = p_s_sb->s_blocksize + UNFM_P_SIZE; quota_cut_bytes = sb->s_blocksize + UNFM_P_SIZE;
} else { } else {
quota_cut_bytes = 0; quota_cut_bytes = 0;
} }
@ -1659,18 +1659,18 @@ int reiserfs_cut_from_item(struct reiserfs_transaction_handle *th,
sure, that we exactly remove last unformatted node pointer sure, that we exactly remove last unformatted node pointer
of the item */ of the item */
if (!is_indirect_le_ih(le_ih)) if (!is_indirect_le_ih(le_ih))
reiserfs_panic(p_s_sb, "vs-5652", reiserfs_panic(sb, "vs-5652",
"item must be indirect %h", le_ih); "item must be indirect %h", le_ih);
if (c_mode == M_DELETE && ih_item_len(le_ih) != UNFM_P_SIZE) if (c_mode == M_DELETE && ih_item_len(le_ih) != UNFM_P_SIZE)
reiserfs_panic(p_s_sb, "vs-5653", "completing " reiserfs_panic(sb, "vs-5653", "completing "
"indirect2direct conversion indirect " "indirect2direct conversion indirect "
"item %h being deleted must be of " "item %h being deleted must be of "
"4 byte long", le_ih); "4 byte long", le_ih);
if (c_mode == M_CUT if (c_mode == M_CUT
&& s_cut_balance.insert_size[0] != -UNFM_P_SIZE) { && s_cut_balance.insert_size[0] != -UNFM_P_SIZE) {
reiserfs_panic(p_s_sb, "vs-5654", "can not complete " reiserfs_panic(sb, "vs-5654", "can not complete "
"indirect2direct conversion of %h " "indirect2direct conversion of %h "
"(CUT, insert_size==%d)", "(CUT, insert_size==%d)",
le_ih, s_cut_balance.insert_size[0]); le_ih, s_cut_balance.insert_size[0]);

16
fs/reiserfs/tail_conversion.c
View File

@ -175,9 +175,9 @@ int indirect2direct(struct reiserfs_transaction_handle *th, struct inode *p_s_in
loff_t n_new_file_size, /* New file size. */ loff_t n_new_file_size, /* New file size. */
char *p_c_mode) char *p_c_mode)
{ {
struct super_block *p_s_sb = p_s_inode->i_sb; struct super_block *sb = p_s_inode->i_sb;
struct item_head s_ih; struct item_head s_ih;
unsigned long n_block_size = p_s_sb->s_blocksize; unsigned long n_block_size = sb->s_blocksize;
char *tail; char *tail;
int tail_len, round_tail_len; int tail_len, round_tail_len;
loff_t pos, pos1; /* position of first byte of the tail */ loff_t pos, pos1; /* position of first byte of the tail */
@ -185,7 +185,7 @@ int indirect2direct(struct reiserfs_transaction_handle *th, struct inode *p_s_in
BUG_ON(!th->t_trans_id); BUG_ON(!th->t_trans_id);
REISERFS_SB(p_s_sb)->s_indirect2direct++; REISERFS_SB(sb)->s_indirect2direct++;
*p_c_mode = M_SKIP_BALANCING; *p_c_mode = M_SKIP_BALANCING;
@ -200,7 +200,7 @@ int indirect2direct(struct reiserfs_transaction_handle *th, struct inode *p_s_in
pos = pos =
le_ih_k_offset(&s_ih) - 1 + (ih_item_len(&s_ih) / UNFM_P_SIZE - le_ih_k_offset(&s_ih) - 1 + (ih_item_len(&s_ih) / UNFM_P_SIZE -
1) * p_s_sb->s_blocksize; 1) * sb->s_blocksize;
pos1 = pos; pos1 = pos;
// we are protected by i_mutex. The tail can not disapper, not // we are protected by i_mutex. The tail can not disapper, not
@ -211,18 +211,18 @@ int indirect2direct(struct reiserfs_transaction_handle *th, struct inode *p_s_in
if (path_changed(&s_ih, p_s_path)) { if (path_changed(&s_ih, p_s_path)) {
/* re-search indirect item */ /* re-search indirect item */
if (search_for_position_by_key(p_s_sb, p_s_item_key, p_s_path) if (search_for_position_by_key(sb, p_s_item_key, p_s_path)
== POSITION_NOT_FOUND) == POSITION_NOT_FOUND)
reiserfs_panic(p_s_sb, "PAP-5520", reiserfs_panic(sb, "PAP-5520",
"item to be converted %K does not exist", "item to be converted %K does not exist",
p_s_item_key); p_s_item_key);
copy_item_head(&s_ih, PATH_PITEM_HEAD(p_s_path)); copy_item_head(&s_ih, PATH_PITEM_HEAD(p_s_path));
#ifdef CONFIG_REISERFS_CHECK #ifdef CONFIG_REISERFS_CHECK
pos = le_ih_k_offset(&s_ih) - 1 + pos = le_ih_k_offset(&s_ih) - 1 +
(ih_item_len(&s_ih) / UNFM_P_SIZE - (ih_item_len(&s_ih) / UNFM_P_SIZE -
1) * p_s_sb->s_blocksize; 1) * sb->s_blocksize;
if (pos != pos1) if (pos != pos1)
reiserfs_panic(p_s_sb, "vs-5530", "tail position " reiserfs_panic(sb, "vs-5530", "tail position "
"changed while we were reading it"); "changed while we were reading it");
#endif #endif
} }

12
include/linux/reiserfs_fs.h
View File

@ -1769,12 +1769,12 @@ int journal_end_sync(struct reiserfs_transaction_handle *, struct super_block *,
int journal_mark_freed(struct reiserfs_transaction_handle *, int journal_mark_freed(struct reiserfs_transaction_handle *,
struct super_block *, b_blocknr_t blocknr); struct super_block *, b_blocknr_t blocknr);
int journal_transaction_should_end(struct reiserfs_transaction_handle *, int); int journal_transaction_should_end(struct reiserfs_transaction_handle *, int);
int reiserfs_in_journal(struct super_block *p_s_sb, unsigned int bmap_nr, int reiserfs_in_journal(struct super_block *sb, unsigned int bmap_nr,
int bit_nr, int searchall, b_blocknr_t *next); int bit_nr, int searchall, b_blocknr_t *next);
int journal_begin(struct reiserfs_transaction_handle *, int journal_begin(struct reiserfs_transaction_handle *,
struct super_block *p_s_sb, unsigned long); struct super_block *sb, unsigned long);
int journal_join_abort(struct reiserfs_transaction_handle *, int journal_join_abort(struct reiserfs_transaction_handle *,
struct super_block *p_s_sb, unsigned long); struct super_block *sb, unsigned long);
void reiserfs_abort_journal(struct super_block *sb, int errno); void reiserfs_abort_journal(struct super_block *sb, int errno);
void reiserfs_abort(struct super_block *sb, int errno, const char *fmt, ...); void reiserfs_abort(struct super_block *sb, int errno, const char *fmt, ...);
int reiserfs_allocate_list_bitmaps(struct super_block *s, int reiserfs_allocate_list_bitmaps(struct super_block *s,
@ -1830,11 +1830,11 @@ static inline void copy_key(struct reiserfs_key *to,
int comp_items(const struct item_head *stored_ih, const struct treepath *p_s_path); int comp_items(const struct item_head *stored_ih, const struct treepath *p_s_path);
const struct reiserfs_key *get_rkey(const struct treepath *p_s_chk_path, const struct reiserfs_key *get_rkey(const struct treepath *p_s_chk_path,
const struct super_block *p_s_sb); const struct super_block *sb);
int search_by_key(struct super_block *, const struct cpu_key *, int search_by_key(struct super_block *, const struct cpu_key *,
struct treepath *, int); struct treepath *, int);
#define search_item(s,key,path) search_by_key (s, key, path, DISK_LEAF_NODE_LEVEL) #define search_item(s,key,path) search_by_key (s, key, path, DISK_LEAF_NODE_LEVEL)
int search_for_position_by_key(struct super_block *p_s_sb, int search_for_position_by_key(struct super_block *sb,
const struct cpu_key *p_s_cpu_key, const struct cpu_key *p_s_cpu_key,
struct treepath *p_s_search_path); struct treepath *p_s_search_path);
extern void decrement_bcount(struct buffer_head *p_s_bh); extern void decrement_bcount(struct buffer_head *p_s_bh);
@ -1978,7 +1978,7 @@ int reiserfs_global_version_in_proc(char *buffer, char **start, off_t offset,
#define PROC_INFO_MAX( sb, field, value ) VOID_V #define PROC_INFO_MAX( sb, field, value ) VOID_V
#define PROC_INFO_INC( sb, field ) VOID_V #define PROC_INFO_INC( sb, field ) VOID_V
#define PROC_INFO_ADD( sb, field, val ) VOID_V #define PROC_INFO_ADD( sb, field, val ) VOID_V
#define PROC_INFO_BH_STAT( p_s_sb, p_s_bh, n_node_level ) VOID_V #define PROC_INFO_BH_STAT(sb, p_s_bh, n_node_level) VOID_V
#endif #endif
/* dir.c */ /* dir.c */