lgcosta/reiserfsprogs
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

reiserfsprogs: convert reiserfs_filsys_t from structure to pointer-to-structure

Browse Source 
This makes it more consistent with e2fsprogs.

Signed-off-by: Jeff Mahoney <jeffm@suse.com>
This commit is contained in:
Jeff Mahoney committed 2013-08-26 19:02:20 -04:00
1 parent 81aeadf510
commit 97fa944851
37 files changed
+393 -393
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

debugreiserfs/corruption.c
+12 -12
View File
@@ -11,7 +11,7 @@ extern struct reiserfs_fsstat g_stat_info;
int do_one_ih_corrupt(struct item_head *ih, unsigned int nr_bytes);
int do_one_ih_random_corrupt(struct item_head *ih);
void do_one_corruption_in_one_block(reiserfs_filsys_t *fs,
void do_one_corruption_in_one_block(reiserfs_filsys_t fs,
struct buffer_head *bh,
char *corruption_command);
int corrupt_block_header(struct block_head *blkh, unsigned int offset,
@@ -93,7 +93,7 @@ static void edit_journal_params(struct journal_params *jp)
}
/* this allows to edit all super block fields */
static void edit_super_block(reiserfs_filsys_t *fs)
static void edit_super_block(reiserfs_filsys_t fs)
{
char *str;
size_t n;
@@ -236,7 +236,7 @@ static void corrupt_clobber_hash(char *name, struct item_head *ih,
start from offset
*/
void do_corrupt_one_block(reiserfs_filsys_t *fs, char *fline)
void do_corrupt_one_block(reiserfs_filsys_t fs, char *fline)
{
struct buffer_head *bh;
char *line = NULL;
@@ -341,7 +341,7 @@ void do_corrupt_one_block(reiserfs_filsys_t *fs, char *fline)
return;
}
void do_one_corruption_in_one_block(reiserfs_filsys_t *fs,
void do_one_corruption_in_one_block(reiserfs_filsys_t fs,
struct buffer_head *bh,
char *corruption_command)
{
@@ -766,7 +766,7 @@ static void do_one_blkh_random_corrupt(struct buffer_head *bh)
}
void do_leaves_corruption(reiserfs_filsys_t *fs, unsigned long nr_leaves_cr)
void do_leaves_corruption(reiserfs_filsys_t fs, unsigned long nr_leaves_cr)
{
struct buffer_head *bh;
unsigned long nr_leaves = 0;
@@ -853,7 +853,7 @@ void do_one_block_random_corrupt(struct buffer_head *bh)
}
void do_bitmap_corruption(reiserfs_filsys_t *fs)
void do_bitmap_corruption(reiserfs_filsys_t fs)
{
unsigned long first = fs->fs_super_bh->b_blocknr + 1;
@@ -889,7 +889,7 @@ void do_bitmap_corruption(reiserfs_filsys_t *fs)
}
/* corrupt the random number of item headers in random number of leaves */
static void do_ih_random_corrupt(reiserfs_filsys_t *fs,
static void do_ih_random_corrupt(reiserfs_filsys_t fs,
unsigned long nr_leaves_cr)
{
unsigned int nr_ih_cr;
@@ -1003,7 +1003,7 @@ static void do_one_item_random_corrupt(struct buffer_head *bh,
}
/* corrupt the random number of directory items in random number of leaves */
static void do_dir_random_corrupt(reiserfs_filsys_t *fs,
static void do_dir_random_corrupt(reiserfs_filsys_t fs,
unsigned long nr_leaves_cr)
{
unsigned int nr_ih_cr;
@@ -1089,7 +1089,7 @@ static void do_dir_random_corrupt(reiserfs_filsys_t *fs,
}
/* corrupt the random number of stat data items in random number of leaves */
static void do_sd_random_corrupt(reiserfs_filsys_t *fs,
static void do_sd_random_corrupt(reiserfs_filsys_t fs,
unsigned long nr_leaves_cr)
{
unsigned int nr_ih_cr;
@@ -1175,7 +1175,7 @@ static void do_sd_random_corrupt(reiserfs_filsys_t *fs,
}
/* corrupt the random number of indierct items in random number of leaves */
static void do_ind_random_corrupt(reiserfs_filsys_t *fs,
static void do_ind_random_corrupt(reiserfs_filsys_t fs,
unsigned long nr_leaves_cr)
{
unsigned int nr_ih_cr;
@@ -1273,7 +1273,7 @@ static void do_ind_random_corrupt(reiserfs_filsys_t *fs,
corrupted
*/
static void what_to_corrupt(reiserfs_filsys_t *fs, char *corruption_command)
static void what_to_corrupt(reiserfs_filsys_t fs, char *corruption_command)
{
unsigned long nr_leaves_cr;
char code;
@@ -1339,7 +1339,7 @@ static void what_to_corrupt(reiserfs_filsys_t *fs, char *corruption_command)
}
}
void do_fs_random_corrupt(reiserfs_filsys_t *fs)
void do_fs_random_corrupt(reiserfs_filsys_t fs)
{
char *line = NULL;
size_t n = 0;
debugreiserfs/debugreiserfs.c
+12 -12
View File
@@ -5,7 +5,7 @@
#include "debugreiserfs.h"
reiserfs_filsys_t *fs;
reiserfs_filsys_t fs;
#define print_usage_and_exit() {\
fprintf (stderr, "Usage: %s [options] device\n\n\
@@ -67,7 +67,7 @@ struct reiserfs_fsstat {
} g_stat_info;
#endif
static void print_disk_tree(reiserfs_filsys_t *fs, unsigned long block_nr)
static void print_disk_tree(reiserfs_filsys_t fs, unsigned long block_nr)
{
struct buffer_head *bh;
int i, j, count;
@@ -132,7 +132,7 @@ static void print_disk_tree(reiserfs_filsys_t *fs, unsigned long block_nr)
level++;
}
static void print_disk_blocks(reiserfs_filsys_t *fs)
static void print_disk_blocks(reiserfs_filsys_t fs)
{
int type;
unsigned long done = 0, total;
@@ -171,8 +171,8 @@ static void print_disk_blocks(reiserfs_filsys_t *fs)
fprintf(stderr, "\n");
}
void pack_one_block(reiserfs_filsys_t *fs, unsigned long block);
static void print_one_block(reiserfs_filsys_t *fs, unsigned long block)
void pack_one_block(reiserfs_filsys_t fs, unsigned long block);
static void print_one_block(reiserfs_filsys_t fs, unsigned long block)
{
struct buffer_head *bh;
@@ -427,9 +427,9 @@ static char *parse_options(struct debugreiserfs_data *data,
return argv[optind];
}
void pack_partition(reiserfs_filsys_t *fs);
void pack_partition(reiserfs_filsys_t fs);
static void do_pack(reiserfs_filsys_t *fs)
static void do_pack(reiserfs_filsys_t fs)
{
if (certain_block(fs))
pack_one_block(fs, certain_block(fs));
@@ -452,7 +452,7 @@ static int comp (const void * vp1, const void * vp2)
}
*/
static void init_bitmap(reiserfs_filsys_t *fs)
static void init_bitmap(reiserfs_filsys_t fs)
{
FILE *fp;
unsigned long block_count;
@@ -508,7 +508,7 @@ static void init_bitmap(reiserfs_filsys_t *fs)
}
/* FIXME: statistics does not work */
static void do_dump_tree(reiserfs_filsys_t *fs)
static void do_dump_tree(reiserfs_filsys_t fs)
{
if (certain_block(fs)) {
print_one_block(fs, certain_block(fs));
@@ -565,7 +565,7 @@ static void do_dump_tree(reiserfs_filsys_t *fs)
}
}
static void callback_badblock_print(reiserfs_filsys_t *fs,
static void callback_badblock_print(reiserfs_filsys_t fs,
struct reiserfs_path *badblock_path,
void *data)
{
@@ -610,7 +610,7 @@ static int str2int(char *str, int *res)
return 1;
}
static void do_corrupt_blocks(reiserfs_filsys_t *fs)
static void do_corrupt_blocks(reiserfs_filsys_t fs)
{
char *line;
FILE *fd;
@@ -647,7 +647,7 @@ static void do_corrupt_blocks(reiserfs_filsys_t *fs)
return;
}
static void debugreiserfs_zero_reiserfs(reiserfs_filsys_t *fs)
static void debugreiserfs_zero_reiserfs(reiserfs_filsys_t fs)
{
unsigned long done, total, i;
struct buffer_head *bh;
debugreiserfs/debugreiserfs.h
+10 -10
View File
@@ -17,7 +17,7 @@
#include <string.h>
#include <errno.h>
extern reiserfs_filsys_t *fs;
extern reiserfs_filsys_t fs;
/*
* modes
@@ -238,27 +238,27 @@ struct debugreiserfs_data {
#define be_quiet(fs) (data(fs)->options & BE_QUIET)
/* stat.c */
void do_stat(reiserfs_filsys_t *fs);
void do_stat(reiserfs_filsys_t fs);
/* corruption.c */
void do_corrupt_one_block(reiserfs_filsys_t *fs, char *fline);
void do_leaves_corruption(reiserfs_filsys_t *fs, unsigned long nr_leaves_cr);
void do_bitmap_corruption(reiserfs_filsys_t *fs);
void do_fs_random_corrupt(reiserfs_filsys_t *fs);
void do_corrupt_one_block(reiserfs_filsys_t fs, char *fline);
void do_leaves_corruption(reiserfs_filsys_t fs, unsigned long nr_leaves_cr);
void do_bitmap_corruption(reiserfs_filsys_t fs);
void do_fs_random_corrupt(reiserfs_filsys_t fs);
/* recover.c */
void do_recover(reiserfs_filsys_t *fs);
void do_recover(reiserfs_filsys_t fs);
/* scan.c */
void do_scan(reiserfs_filsys_t *fs);
void do_scan(reiserfs_filsys_t fs);
/* journal.c */
void scan_journal(reiserfs_filsys_t *fs);
void scan_journal(reiserfs_filsys_t fs);
/* unpack.c */
extern int do_unpack(char *host, char *j_filename, char *filename, int verbose);
void print_map(reiserfs_filsys_t *fs);
void print_map(reiserfs_filsys_t fs);
struct saved_item {
struct item_head si_ih;
debugreiserfs/pack.c
+11 -11
View File
@@ -184,7 +184,7 @@ static void pack_indirect(struct packed_item *pi, struct buffer_head *bh,
maybe gencounter (16)
maybe deh_state (16)
*/
static void pack_direntry(reiserfs_filsys_t *fs, struct packed_item *pi,
static void pack_direntry(reiserfs_filsys_t fs, struct packed_item *pi,
struct buffer_head *bh, struct item_head *ih)
{
int i;
@@ -315,7 +315,7 @@ static void pack_stat_data(struct packed_item *pi, struct buffer_head *bh,
}
}
static void pack_full_block(reiserfs_filsys_t *fs, struct buffer_head *bh)
static void pack_full_block(reiserfs_filsys_t fs, struct buffer_head *bh)
{
__u16 magic;
__u32 block;
@@ -338,7 +338,7 @@ static void pack_full_block(reiserfs_filsys_t *fs, struct buffer_head *bh)
/* unformatted node pointer is considered bad when it points either to blocks
of journal, bitmap blocks, super block or is transparently out of range of
disk block numbers */
static int check_unfm_ptr(reiserfs_filsys_t *fs, __u32 block)
static int check_unfm_ptr(reiserfs_filsys_t fs, __u32 block)
{
if (block >= SB_BLOCK_COUNT(fs))
return 1;
@@ -351,7 +351,7 @@ static int check_unfm_ptr(reiserfs_filsys_t *fs, __u32 block)
#endif
/* we only pack leaves which do not have any corruptions */
static int can_pack_leaf(reiserfs_filsys_t *fs, struct buffer_head *bh)
static int can_pack_leaf(reiserfs_filsys_t fs, struct buffer_head *bh)
{
int i;
struct item_head *ih;
@@ -369,7 +369,7 @@ static int can_pack_leaf(reiserfs_filsys_t *fs, struct buffer_head *bh)
/* pack leaf only if all its items are correct: keys are correct,
direntries are hashed properly and hash function is defined,
indirect items are correct, stat data ?, */
static void pack_leaf(reiserfs_filsys_t *fs, struct buffer_head *bh)
static void pack_leaf(reiserfs_filsys_t fs, struct buffer_head *bh)
{
int i;
struct item_head *ih;
@@ -493,13 +493,13 @@ static void pack_leaf(reiserfs_filsys_t *fs, struct buffer_head *bh)
return;
}
static int can_pack_internal(reiserfs_filsys_t *fs, struct buffer_head *bh)
static int can_pack_internal(reiserfs_filsys_t fs, struct buffer_head *bh)
{
return 0;
}
/* pack internal node as a full block */
static void pack_internal(reiserfs_filsys_t *fs, struct buffer_head *bh)
static void pack_internal(reiserfs_filsys_t fs, struct buffer_head *bh)
{
internals++;
if (!can_pack_internal(fs, bh)) {
@@ -511,7 +511,7 @@ static void pack_internal(reiserfs_filsys_t *fs, struct buffer_head *bh)
}
/* packed blocks are marked free in the bitmap*/
static void send_block(reiserfs_filsys_t *fs, struct buffer_head *bh,
static void send_block(reiserfs_filsys_t fs, struct buffer_head *bh,
int send_unknown)
{
int type;
@@ -546,7 +546,7 @@ static void send_block(reiserfs_filsys_t *fs, struct buffer_head *bh,
}
/* super block, journal, bitmaps */
static void pack_frozen_data(reiserfs_filsys_t *fs)
static void pack_frozen_data(reiserfs_filsys_t fs)
{
struct buffer_head *bh;
unsigned long block;
@@ -638,7 +638,7 @@ static void pack_frozen_data(reiserfs_filsys_t *fs)
}
/* pack all "not data blocks" and correct leaf */
void pack_partition(reiserfs_filsys_t *fs)
void pack_partition(reiserfs_filsys_t fs)
{
struct buffer_head *bh;
__u32 magic32;
@@ -699,7 +699,7 @@ void pack_partition(reiserfs_filsys_t *fs)
(double)sent_bytes / had_to_be_sent);
}
void pack_one_block(reiserfs_filsys_t *fs, unsigned long block)
void pack_one_block(reiserfs_filsys_t fs, unsigned long block)
{
__u32 magic32;
__u16 magic16;
debugreiserfs/recover.c
+3 -3
View File
@@ -233,7 +233,7 @@ static void read_map (FILE * fp)
free (buf);
}
void do_recover (reiserfs_filsys_t *fs)
void do_recover (reiserfs_filsys_t fs)
{
FILE * fp;
@@ -276,7 +276,7 @@ static long int get_answer(long int max)
return result;
}
static void recover_items(FILE * fp, reiserfs_filsys_t *fs, FILE * target_file)
static void recover_items(FILE * fp, reiserfs_filsys_t fs, FILE * target_file)
{
struct buffer_head *bh, *bh_pointed;
struct item_head *ih;
@@ -409,7 +409,7 @@ static void recover_items(FILE * fp, reiserfs_filsys_t *fs, FILE * target_file)
free(map);
}
void do_recover(reiserfs_filsys_t *fs)
void do_recover(reiserfs_filsys_t fs)
{
FILE *fp, *recovery;
debugreiserfs/scan.c
+6 -6
View File
@@ -581,7 +581,7 @@ static void map_one_item(struct saved_item *item)
}
// flush map which is in variable map
static void flush_map(reiserfs_filsys_t *fs,
static void flush_map(reiserfs_filsys_t fs,
struct reiserfs_key *dir,
char *name, struct reiserfs_key *key)
{
@@ -718,7 +718,7 @@ static void make_file_map (const void *nodep, VISIT value, int level)
}
*/
static void print_items(FILE * fp, reiserfs_filsys_t *fs)
static void print_items(FILE * fp, reiserfs_filsys_t fs)
{
struct buffer_head *bh;
struct item_head *ih;
@@ -737,7 +737,7 @@ static void print_items(FILE * fp, reiserfs_filsys_t *fs)
}
}
void print_map(reiserfs_filsys_t *fs)
void print_map(reiserfs_filsys_t fs)
{
FILE *fp;
@@ -845,7 +845,7 @@ static void make_map(const void *nodep, VISIT value, int level)
}
/* store map if it is a regular file */
static void locate_file(reiserfs_filsys_t *fs, struct reiserfs_key *key)
static void locate_file(reiserfs_filsys_t fs, struct reiserfs_key *key)
{
INITIALIZE_REISERFS_PATH(path);
struct reiserfs_key *next_key;
@@ -880,7 +880,7 @@ static void locate_file(reiserfs_filsys_t *fs, struct reiserfs_key *key)
}
/* read stdin and look for specified name in the specified directory */
static void look_for_name(reiserfs_filsys_t *fs)
static void look_for_name(reiserfs_filsys_t fs)
{
INITIALIZE_REISERFS_PATH(path);
char *name, *objectid, *dirid;
@@ -998,7 +998,7 @@ static void scan_for_key(struct buffer_head *bh, struct reiserfs_key *key)
}
#endif
void do_scan(reiserfs_filsys_t *fs)
void do_scan(reiserfs_filsys_t fs)
{
unsigned long i;
struct buffer_head *bh;
debugreiserfs/stat.c
+2 -2
View File
@@ -105,7 +105,7 @@ static int is_unique_item(struct obstack *ostack, void **tree, void *ih)
return 1;
}
static void stat1_the_leaf(reiserfs_filsys_t *fs, struct buffer_head *bh)
static void stat1_the_leaf(reiserfs_filsys_t fs, struct buffer_head *bh)
{
int i, i_num;
struct item_head *ih;
@@ -152,7 +152,7 @@ static void stat2_the_leaf (struct buffer_head * bh)
}
*/
void do_stat(reiserfs_filsys_t *fs)
void do_stat(reiserfs_filsys_t fs)
{
unsigned long i;
unsigned long done, total;
fsck/check_tree.c
+24 -24
View File
@@ -111,7 +111,7 @@ static reiserfs_bitmap_t *source_bitmap;
static int tree_scanning_failed = 0;
/* 1 if block is not marked as used in the bitmap */
static int is_block_free(reiserfs_filsys_t *fs, unsigned long block)
static int is_block_free(reiserfs_filsys_t fs, unsigned long block)
{
return !reiserfs_bitmap_test_bit(source_bitmap, block);
}
@@ -132,7 +132,7 @@ static int did_we_meet_it(unsigned long block)
return reiserfs_bitmap_test_bit(control_bitmap, block);
}
static void init_control_bitmap(reiserfs_filsys_t *fs)
static void init_control_bitmap(reiserfs_filsys_t fs)
{
unsigned int i;
unsigned long block;
@@ -197,7 +197,7 @@ static void init_control_bitmap(reiserfs_filsys_t *fs)
/* if we managed to complete tree scanning and if control bitmap and/or proper
amount of free blocks mismatch with bitmap on disk and super block's
s_free_blocks - we can fix that */
static void handle_bitmaps(reiserfs_filsys_t *fs)
static void handle_bitmaps(reiserfs_filsys_t fs)
{
int problem = 0;
@@ -271,7 +271,7 @@ static void handle_bitmaps(reiserfs_filsys_t *fs)
return;
}
static int auto_handle_bitmaps(reiserfs_filsys_t *fs)
static int auto_handle_bitmaps(reiserfs_filsys_t fs)
{
unsigned long i;
@@ -288,7 +288,7 @@ static int auto_handle_bitmaps(reiserfs_filsys_t *fs)
}
/* is this block legal to be pointed to by some place of the tree? */
static int bad_block_number(reiserfs_filsys_t *fs, unsigned long block)
static int bad_block_number(reiserfs_filsys_t fs, unsigned long block)
{
if (block >= get_sb_block_count(fs->fs_ondisk_sb) ||
not_data_block(fs, block)) {
@@ -317,7 +317,7 @@ static int bad_block_number(reiserfs_filsys_t *fs, unsigned long block)
return 0;
}
static int got_already(reiserfs_filsys_t *fs, unsigned long block)
static int got_already(reiserfs_filsys_t fs, unsigned long block)
{
if (did_we_meet_it(block)) {
/* block is in tree at least twice */
@@ -328,7 +328,7 @@ static int got_already(reiserfs_filsys_t *fs, unsigned long block)
}
/* 1 if it does not look like reasonable stat data */
static int bad_stat_data(reiserfs_filsys_t *fs,
static int bad_stat_data(reiserfs_filsys_t fs,
struct buffer_head *bh, struct item_head *ih)
{
unsigned long objectid;
@@ -381,13 +381,13 @@ static int bad_stat_data(reiserfs_filsys_t *fs,
}
/* it looks like we can check item length only */
static int bad_direct_item(reiserfs_filsys_t *fs,
static int bad_direct_item(reiserfs_filsys_t fs,
struct buffer_head *bh, struct item_head *ih)
{
return 0;
}
inline void handle_one_pointer(reiserfs_filsys_t *fs,
inline void handle_one_pointer(reiserfs_filsys_t fs,
struct buffer_head *bh, __le32 * item,
int offset)
{
@@ -400,7 +400,7 @@ inline void handle_one_pointer(reiserfs_filsys_t *fs,
}
}
static int bad_badblocks_item(reiserfs_filsys_t *fs, struct buffer_head *bh,
static int bad_badblocks_item(reiserfs_filsys_t fs, struct buffer_head *bh,
struct item_head *ih)
{
__u32 i;
@@ -475,7 +475,7 @@ static int bad_badblocks_item(reiserfs_filsys_t *fs, struct buffer_head *bh,
/* for each unformatted node pointer: make sure it points to data area and
that it is not in the tree yet */
static int bad_indirect_item(reiserfs_filsys_t *fs, struct buffer_head *bh,
static int bad_indirect_item(reiserfs_filsys_t fs, struct buffer_head *bh,
struct item_head *ih)
{
__le32 *ind = (__le32 *) ih_item_body(bh, ih);
@@ -541,7 +541,7 @@ static int bad_indirect_item(reiserfs_filsys_t *fs, struct buffer_head *bh,
}
/* FIXME: this was is_bad_directory from pass0.c */
static int bad_directory_item(reiserfs_filsys_t *fs,
static int bad_directory_item(reiserfs_filsys_t fs,
struct buffer_head *bh, struct item_head *ih)
{
char *name, *prev_name;
@@ -644,7 +644,7 @@ static int bad_directory_item(reiserfs_filsys_t *fs,
return 0;
}
static int bad_item(reiserfs_filsys_t *fs, struct buffer_head *bh, int num)
static int bad_item(reiserfs_filsys_t fs, struct buffer_head *bh, int num)
{
struct item_head *ih;
int format;
@@ -752,7 +752,7 @@ error:
}
/* 1 if i-th and (i-1)-th items can not be neighbors in a leaf */
int bad_pair(reiserfs_filsys_t *fs, struct buffer_head *bh, int pos)
int bad_pair(reiserfs_filsys_t fs, struct buffer_head *bh, int pos)
{
struct item_head *ih;
@@ -831,7 +831,7 @@ int bad_pair(reiserfs_filsys_t *fs, struct buffer_head *bh, int pos)
}
/* 1 if block head or any of items is bad */
static int bad_leaf(reiserfs_filsys_t *fs, struct buffer_head *bh)
static int bad_leaf(reiserfs_filsys_t fs, struct buffer_head *bh)
{
int i;
@@ -857,7 +857,7 @@ static int bad_leaf(reiserfs_filsys_t *fs, struct buffer_head *bh)
}
/* 1 if bh does not look like internal node */
static int bad_internal(reiserfs_filsys_t *fs, struct buffer_head *bh)
static int bad_internal(reiserfs_filsys_t fs, struct buffer_head *bh)
{
int i;
@@ -895,7 +895,7 @@ static int bad_internal(reiserfs_filsys_t *fs, struct buffer_head *bh)
}
/* h == 0 for root level. block head's level == 1 for leaf level */
static inline int h_to_level(reiserfs_filsys_t *fs, int h)
static inline int h_to_level(reiserfs_filsys_t fs, int h)
{
return get_sb_tree_height(fs->fs_ondisk_sb) - h - 1;
}
@@ -968,7 +968,7 @@ int leaf_fix_key_oid(struct buffer_head *bh, int pos, __u32 oid)
#endif
/* bh must be formatted node. blk_level must be tree_height - h + 1 */
static int bad_node(reiserfs_filsys_t *fs, struct buffer_head **path, int h)
static int bad_node(reiserfs_filsys_t fs, struct buffer_head **path, int h)
{
struct buffer_head **pbh = &path[h];
@@ -1049,7 +1049,7 @@ static struct reiserfs_key *rkey(struct buffer_head **path, int h)
}
/* are all delimiting keys correct */
static int bad_path(reiserfs_filsys_t *fs, struct buffer_head **path, int h1)
static int bad_path(reiserfs_filsys_t fs, struct buffer_head **path, int h1)
{
int h = 0;
struct reiserfs_key *dk;
@@ -1132,7 +1132,7 @@ static int bad_path(reiserfs_filsys_t *fs, struct buffer_head **path, int h1)
return 0;
}
static void before_check_fs_tree(reiserfs_filsys_t *fs)
static void before_check_fs_tree(reiserfs_filsys_t fs)
{
init_control_bitmap(fs);
@@ -1143,7 +1143,7 @@ static void before_check_fs_tree(reiserfs_filsys_t *fs)
proper_id_map(fs) = id_map_init();
}
static void after_check_fs_tree(reiserfs_filsys_t *fs)
static void after_check_fs_tree(reiserfs_filsys_t fs)
{
if (fsck_mode(fs) == FSCK_FIX_FIXABLE) {
reiserfs_flush_to_ondisk_bitmap(fs->fs_bitmap2, fs);
@@ -1159,7 +1159,7 @@ static void after_check_fs_tree(reiserfs_filsys_t *fs)
}
/* pass internal tree of filesystem */
void check_fs_tree(reiserfs_filsys_t *fs)
void check_fs_tree(reiserfs_filsys_t fs)
{
before_check_fs_tree(fs);
@@ -1183,7 +1183,7 @@ void check_fs_tree(reiserfs_filsys_t *fs)
after_check_fs_tree(fs);
}
static int clean_attributes_handler(reiserfs_filsys_t *fs,
static int clean_attributes_handler(reiserfs_filsys_t fs,
struct buffer_head **path, int h)
{
struct buffer_head *bh = path[h];
@@ -1211,7 +1211,7 @@ static int clean_attributes_handler(reiserfs_filsys_t *fs,
return 0;
}
void do_clean_attributes(reiserfs_filsys_t *fs)
void do_clean_attributes(reiserfs_filsys_t fs)
{
pass_through_tree(fs, clean_attributes_handler, NULL, -1);
set_sb_v2_flag(fs->fs_ondisk_sb, reiserfs_attrs_cleared);
fsck/fsck.h
+30 -30
View File
@@ -21,7 +21,7 @@
#include "../version.h"
/* main.c */
extern reiserfs_filsys_t *fs;
extern reiserfs_filsys_t fs;
int main(int argc, char *argv[]);
/* Exit codes. */
@@ -67,10 +67,10 @@ int main(int argc, char *argv[]);
/* pass0.c */
extern reiserfs_bitmap_t *leaves_bitmap;
void pass_0(reiserfs_filsys_t *);
void load_pass_0_result(FILE *, reiserfs_filsys_t *);
void pass_0(reiserfs_filsys_t );
void load_pass_0_result(FILE *, reiserfs_filsys_t );
int leaf_structure_check(reiserfs_filsys_t *fs, struct buffer_head *bh);
int leaf_structure_check(reiserfs_filsys_t fs, struct buffer_head *bh);
int is_used_leaf(unsigned long block);
int is_good_unformatted(unsigned long block);
@@ -84,7 +84,7 @@ void register_uninsertable(unsigned long block);
void register_saved_item(void);
int still_bad_unfm_ptr_1(unsigned long block);
int still_bad_unfm_ptr_2(unsigned long block);
void make_alloc_bitmap(reiserfs_filsys_t *);
void make_alloc_bitmap(reiserfs_filsys_t );
void delete_aux_bitmaps();
void set_aux_bitmaps(reiserfs_bitmap_t *leaves, reiserfs_bitmap_t *good,
@@ -100,8 +100,8 @@ extern reiserfs_bitmap_t *bad_unfm_in_tree_once_bitmap;
#define mark_bad_unfm_in_tree_once(block) __mark (bad_unfm_in_tree_once, block)
/* pass1.c */
void pass_1(reiserfs_filsys_t *);
void load_pass_1_result(FILE *, reiserfs_filsys_t *);
void pass_1(reiserfs_filsys_t );
void load_pass_1_result(FILE *, reiserfs_filsys_t );
struct buffer_head *make_buffer(int dev, unsigned long blocknr, int size,
char *data);
void build_the_tree(void);
@@ -115,8 +115,8 @@ int tree_is_empty(void);
void make_single_leaf_tree(struct buffer_head *bh);
/* pass2.c */
void pass_2(reiserfs_filsys_t *);
void load_pass_2_result(reiserfs_filsys_t *);
void pass_2(reiserfs_filsys_t );
void load_pass_2_result(reiserfs_filsys_t );
void insert_item_separately(struct item_head *ih, char *item, int was_in_tree);
void save_item(struct si **head, struct item_head *ih, char *item,
__u32 blocknr);
@@ -161,9 +161,9 @@ void rewrite_file(struct item_head *ih, int should_relocate,
#define RELOCATED -3
#define LOOP_FOUND -4
void load_semantic_result(FILE *, reiserfs_filsys_t *);
void load_semantic_result(FILE *, reiserfs_filsys_t );
void pass_3_semantic(reiserfs_filsys_t *);
void pass_3_semantic(reiserfs_filsys_t );
void semantic_check(void);
int check_semantic_tree(struct reiserfs_key *key, struct reiserfs_key *parent,
int is_dot_dot, int lost_found,
@@ -174,7 +174,7 @@ int not_a_regfile(void *sd);
int fix_obviously_wrong_sd_mode(struct reiserfs_path *path);
int is_dot_dot(char *name, int namelen);
int is_dot(char *name, int namelen);
/*void create_dir_sd (reiserfs_filsys_t *fs,
/*void create_dir_sd (reiserfs_filsys_t fs,
struct reiserfs_path *path, struct reiserfs_key *key);*/
int rebuild_check_regular_file(struct reiserfs_path *path, void *sd,
struct item_head *new_ih);
@@ -182,9 +182,9 @@ int rebuild_semantic_pass(struct reiserfs_key *key, struct reiserfs_key *parent,
int is_dot_dot, struct item_head *new_ih);
/* lost+found.c */
void pass_3a_look_for_lost(reiserfs_filsys_t *);
void pass_3a_look_for_lost(reiserfs_filsys_t );
void load_lost_found_result(reiserfs_filsys_t *);
void load_lost_found_result(reiserfs_filsys_t );
/* pass4.c */
void pass_4_check_unaccessed_items(void);
@@ -201,10 +201,10 @@ int is_bad_directory(struct item_head *ih, char *item, int dev, int blocksize);
//extern int bad_block_number (struct super_block * s, blocknr_t block);
/* check_tree.c */
void check_fs_tree(reiserfs_filsys_t *);
void do_clean_attributes(reiserfs_filsys_t *fs);
int bad_pair(reiserfs_filsys_t *, struct buffer_head *bh, int i);
int bad_leaf_2(reiserfs_filsys_t *, struct buffer_head *bh);
void check_fs_tree(reiserfs_filsys_t );
void do_clean_attributes(reiserfs_filsys_t fs);
int bad_pair(reiserfs_filsys_t , struct buffer_head *bh, int i);
int bad_leaf_2(reiserfs_filsys_t , struct buffer_head *bh);
#if 0
extern int should_be_relocated(struct reiserfs_key *key);
@@ -227,17 +227,17 @@ void reiserfsck_cut_from_item(struct reiserfs_path *path, int cut_size);
comp3_function_t comp_func, int version);
int usearch_by_entry_key (struct super_block * s, struct reiserfs_key *key, struct reiserfs_path *path);*/
typedef int do_after_read_t(reiserfs_filsys_t *, struct buffer_head **, int h);
typedef int do_on_full_path_t(reiserfs_filsys_t *, struct buffer_head **, int);
void pass_through_tree(reiserfs_filsys_t *, do_after_read_t, do_on_full_path_t,
typedef int do_after_read_t(reiserfs_filsys_t , struct buffer_head **, int h);
typedef int do_on_full_path_t(reiserfs_filsys_t , struct buffer_head **, int);
void pass_through_tree(reiserfs_filsys_t , do_after_read_t, do_on_full_path_t,
int depth);
/* bitmap.c */
int reiserfsck_reiserfs_new_blocknrs(reiserfs_filsys_t *fs,
int reiserfsck_reiserfs_new_blocknrs(reiserfs_filsys_t fs,
unsigned long *pblocknrs,
unsigned long start_from,
int amount_needed);
int reiserfsck_reiserfs_free_block(reiserfs_filsys_t *fs, unsigned long block);
int reiserfsck_reiserfs_free_block(reiserfs_filsys_t fs, unsigned long block);
struct buffer_head *reiserfsck_get_new_buffer(unsigned long start);
int is_block_used(unsigned long block);
void mark_block_used(unsigned long block, int check_hardware);
@@ -254,10 +254,10 @@ void id_map_free(id_map_t *);
int id_map_test(id_map_t *map, __u32 id);
int id_map_mark(id_map_t *map, __u32 id);
__u32 id_map_alloc(id_map_t *map);
void id_map_flush(struct id_map *map, reiserfs_filsys_t *fs);
void id_map_flush(struct id_map *map, reiserfs_filsys_t fs);
/* FIXME: Needs to be implemented
void fetch_objectid_map (struct id_map * map, reiserfs_filsys_t *fs);
void fetch_objectid_map (struct id_map * map, reiserfs_filsys_t fs);
void reiserfs_objectid_map_save (FILE * fp, struct id_map * id_map);
struct id_map * reiserfs_objectid_map_load (FILE * fp);
@@ -463,12 +463,12 @@ struct fsck_data {
/* name of file where we store rollback data */
#define state_rollback_file(fs) fsck_data(fs)->rebuild.rollback_file
int fsck_user_confirmed(reiserfs_filsys_t *fs, char *q, char *a,
int fsck_user_confirmed(reiserfs_filsys_t fs, char *q, char *a,
int default_answer);
void stage_report(int, reiserfs_filsys_t *);
void stage_report(int, reiserfs_filsys_t );
/*pass1: rebuild super block*/
void rebuild_sb(reiserfs_filsys_t *fs, char *filename, struct fsck_data *data);
void rebuild_sb(reiserfs_filsys_t fs, char *filename, struct fsck_data *data);
#define fsck_log(fmt, list...) \
{\
@@ -485,8 +485,8 @@ fflush (fsck_progress_file(fs));\
#define FATAL 1
#define FIXABLE 2
void one_more_corruption(reiserfs_filsys_t *fs, int kind);
void one_less_corruption(reiserfs_filsys_t *fs, int kind);
void one_more_corruption(reiserfs_filsys_t fs, int kind);
void one_less_corruption(reiserfs_filsys_t fs, int kind);
/*
#define one_more_corruption(fs,kind) fsck_check_stat (fs)->kind##_corruptions++
fsck/info.c
+2 -2
View File
@@ -5,7 +5,7 @@
#include "fsck.h"
int fsck_user_confirmed(reiserfs_filsys_t *fs, char *q, char *a,
int fsck_user_confirmed(reiserfs_filsys_t fs, char *q, char *a,
int default_answer)
{
if (!fsck_interactive(fs))
@@ -14,7 +14,7 @@ int fsck_user_confirmed(reiserfs_filsys_t *fs, char *q, char *a,
return user_confirmed(fsck_progress_file(fs), q, a);
}
void stage_report(int pass, reiserfs_filsys_t *fs)
void stage_report(int pass, reiserfs_filsys_t fs)
{
switch (pass) {
case 0:
fsck/lost+found.c
+5 -5
View File
@@ -11,7 +11,7 @@ void print_name(char *name, int len);
void modify_item(struct item_head *ih, void *item);
/* fixme: search_by_key is not needed after any add_entry */
static __u64 _look_for_lost(reiserfs_filsys_t *fs, int link_lost_dirs)
static __u64 _look_for_lost(reiserfs_filsys_t fs, int link_lost_dirs)
{
struct reiserfs_key key, prev_key, *rdkey;
INITIALIZE_REISERFS_PATH(path);
@@ -285,7 +285,7 @@ cont:
}
static void save_lost_found_result(reiserfs_filsys_t *fs)
static void save_lost_found_result(reiserfs_filsys_t fs)
{
FILE *file;
int retval;
@@ -310,7 +310,7 @@ static void save_lost_found_result(reiserfs_filsys_t *fs)
/* we have nothing to load from a state file, but we have to fetch
on-disk bitmap, copy it to allocable bitmap, and fetch objectid
map */
void load_lost_found_result(reiserfs_filsys_t *fs)
void load_lost_found_result(reiserfs_filsys_t fs)
{
fsck_new_bitmap(fs) =
reiserfs_create_bitmap(get_sb_block_count(fs->fs_ondisk_sb));
@@ -330,7 +330,7 @@ void load_lost_found_result(reiserfs_filsys_t *fs)
*/
}
static void after_lost_found(reiserfs_filsys_t *fs)
static void after_lost_found(reiserfs_filsys_t fs)
{
/* update super block: objectid map, fsck state */
set_sb_fs_state(fs->fs_ondisk_sb, LOST_FOUND_DONE);
@@ -362,7 +362,7 @@ static void after_lost_found(reiserfs_filsys_t *fs)
exit(EXIT_OK);
}
void pass_3a_look_for_lost(reiserfs_filsys_t *fs)
void pass_3a_look_for_lost(reiserfs_filsys_t fs)
{
INITIALIZE_REISERFS_PATH(path);
struct item_head *ih;
fsck/main.c
+14 -14
View File
@@ -14,7 +14,7 @@ extern int screen_width;
extern int screen_savebuffer_len;
extern char *screen_savebuffer;
reiserfs_filsys_t *fs;
reiserfs_filsys_t fs;
static char *badblocks_file;
#define print_usage_and_exit() { \
@@ -508,7 +508,7 @@ static void register_timer(void)
alarm(1);
}
static void reset_super_block(reiserfs_filsys_t *fs)
static void reset_super_block(reiserfs_filsys_t fs)
{
struct reiserfs_super_block *sb;
struct reiserfs_journal_header *jh;
@@ -627,7 +627,7 @@ static void reset_super_block(reiserfs_filsys_t *fs)
#define START_FROM_PASS_4 6
/* this decides where to start from */
static int where_to_start_from(reiserfs_filsys_t *fs)
static int where_to_start_from(reiserfs_filsys_t fs)
{
int ret;
FILE *fp = NULL;
@@ -714,7 +714,7 @@ static int where_to_start_from(reiserfs_filsys_t *fs)
return START_FROM_THE_BEGINNING;
}
static void reiserfs_update_interval_fields(reiserfs_filsys_t *fs)
static void reiserfs_update_interval_fields(reiserfs_filsys_t fs)
{
/* Not supported on v3.5 */
if (get_sb_version(fs->fs_ondisk_sb) == REISERFS_FORMAT_3_5)
@@ -731,7 +731,7 @@ static void reiserfs_update_interval_fields(reiserfs_filsys_t *fs)
DEFAULT_CHECK_INTERVAL);
}
static void mark_filesystem_consistent(reiserfs_filsys_t *fs)
static void mark_filesystem_consistent(reiserfs_filsys_t fs)
{
if (!is_opened_rw(fs))
return;
@@ -759,7 +759,7 @@ static void mark_filesystem_consistent(reiserfs_filsys_t *fs)
mark_buffer_dirty(fs->fs_super_bh);
}
static void reiserfsck_replay_journal(reiserfs_filsys_t *fs)
static void reiserfsck_replay_journal(reiserfs_filsys_t fs)
{
struct reiserfs_super_block *on_place_sb;
int sb_size = reiserfs_super_block_size(fs->fs_ondisk_sb);
@@ -797,7 +797,7 @@ static void reiserfsck_replay_journal(reiserfs_filsys_t *fs)
fs->fs_ondisk_sb = on_place_sb;
}
static int the_end(reiserfs_filsys_t *fs)
static int the_end(reiserfs_filsys_t fs)
{
int ret = EXIT_FIXED;
@@ -834,7 +834,7 @@ static int the_end(reiserfs_filsys_t *fs)
}
/* check umounted or read-only mounted filesystems only */
static void prepare_fs_for_check(reiserfs_filsys_t *fs)
static void prepare_fs_for_check(reiserfs_filsys_t fs)
{
/* The method could be called from auto_check already. */
if (fs->fs_flags == O_RDWR)
@@ -890,7 +890,7 @@ static void prepare_fs_for_check(reiserfs_filsys_t *fs)
}
}
static void rebuild_tree(reiserfs_filsys_t *fs)
static void rebuild_tree(reiserfs_filsys_t fs)
{
time_t t;
int ret;
@@ -951,7 +951,7 @@ static void rebuild_tree(reiserfs_filsys_t *fs)
exit(ret);
}
static void clean_attributes(reiserfs_filsys_t *fs)
static void clean_attributes(reiserfs_filsys_t fs)
{
time_t t;
@@ -997,7 +997,7 @@ static void clean_attributes(reiserfs_filsys_t *fs)
}
static int reiserfs_check_auto_state(reiserfs_filsys_t *fs)
static int reiserfs_check_auto_state(reiserfs_filsys_t fs)
{
time_t now = time(NULL);
time_t lastcheck = get_sb_v2_lastcheck(fs->fs_ondisk_sb);
@@ -1038,7 +1038,7 @@ static int reiserfs_check_auto_state(reiserfs_filsys_t *fs)
return 0;
}
static int auto_check(reiserfs_filsys_t *fs)
static int auto_check(reiserfs_filsys_t fs)
{
__u16 state;
int retval = 0;
@@ -1137,7 +1137,7 @@ error:
}
/* check umounted or read-only mounted filesystems only */
static void check_fs(reiserfs_filsys_t *fs)
static void check_fs(reiserfs_filsys_t fs)
{
int retval = EXIT_OK;
time_t t;
@@ -1285,7 +1285,7 @@ static int open_devices_for_rollback(char *file_name, struct fsck_data *data)
return 0;
}
static void fsck_rollback(reiserfs_filsys_t *fs)
static void fsck_rollback(reiserfs_filsys_t fs)
{
time_t t;
fsck/pass0.c
+16 -16
View File
@@ -40,7 +40,7 @@ static int correct_direct_item_offset(__u64 offset, int format)
}
/* bitmaps which are built on pass 0 and are used on pass 1 */
static void make_aux_bitmaps(reiserfs_filsys_t *fs)
static void make_aux_bitmaps(reiserfs_filsys_t fs)
{
struct reiserfs_super_block *sb;
@@ -171,7 +171,7 @@ static int correct_key_format(struct item_head *ih, int symlink)
#if 0
/* fixme: we might try all available hashes */
static int prob_name(reiserfs_filsys_t *fs,
static int prob_name(reiserfs_filsys_t fs,
char **name, int max_len, __u32 deh_offset)
{
int start; /* */
@@ -190,7 +190,7 @@ static int prob_name(reiserfs_filsys_t *fs,
}
#endif
static void hash_hits_init(reiserfs_filsys_t *fs)
static void hash_hits_init(reiserfs_filsys_t fs)
{
fsck_data(fs)->rebuild.hash_amount = known_hashes();
fsck_data(fs)->rebuild.hash_hits =
@@ -198,7 +198,7 @@ static void hash_hits_init(reiserfs_filsys_t *fs)
return;
}
static void add_hash_hit(reiserfs_filsys_t *fs, int hash_code)
static void add_hash_hit(reiserfs_filsys_t fs, int hash_code)
{
fsck_data(fs)->rebuild.hash_hits[hash_code]++;
}
@@ -226,7 +226,7 @@ static int try_to_get_name_length(struct item_head *ih,
#undef DEBUG_VERIFY_DENTRY
/* check directory item and try to recover something */
static int verify_directory_item(reiserfs_filsys_t *fs, struct buffer_head *bh,
static int verify_directory_item(reiserfs_filsys_t fs, struct buffer_head *bh,
int item_num)
{
struct item_head *ih;
@@ -612,7 +612,7 @@ static int is_wrong_short_key(struct reiserfs_key *key)
}
/* 1 if some of fields in the block head of bh look bad */
int leaf_structure_check(reiserfs_filsys_t *fs, struct buffer_head *bh)
int leaf_structure_check(reiserfs_filsys_t fs, struct buffer_head *bh)
{
struct block_head *blkh;
int free_space, counted;
@@ -671,7 +671,7 @@ int leaf_structure_check(reiserfs_filsys_t *fs, struct buffer_head *bh)
/* FIXME: we can improve fixing of broken keys: we can ssfe direct items which
go after stat data and have broken keys */
static void pass0_correct_leaf(reiserfs_filsys_t *fs, struct buffer_head *bh)
static void pass0_correct_leaf(reiserfs_filsys_t fs, struct buffer_head *bh)
{
int file_format = KEY_FORMAT_UNDEFINED;
struct item_head *ih;
@@ -1837,12 +1837,12 @@ int is_leaf_bad(struct buffer_head *bh)
return bad;
}
static int is_to_be_read(reiserfs_filsys_t *fs, unsigned long block)
static int is_to_be_read(reiserfs_filsys_t fs, unsigned long block)
{
return reiserfs_bitmap_test_bit(fsck_source_bitmap(fs), block);
}
static void do_pass_0(reiserfs_filsys_t *fs)
static void do_pass_0(reiserfs_filsys_t fs)
{
struct buffer_head *bh;
unsigned long i;
@@ -2028,7 +2028,7 @@ void make_allocable(unsigned long block)
reiserfs_bitmap_clear_bit(fsck_allocable_bitmap(fs), block);
}
static void choose_hash_function(reiserfs_filsys_t *fs)
static void choose_hash_function(reiserfs_filsys_t fs)
{
unsigned long max;
unsigned int hash_code;
@@ -2078,7 +2078,7 @@ static void choose_hash_function(reiserfs_filsys_t *fs)
/* create bitmap of blocks the tree is to be built off */
/* debugreiserfs and pass0 should share this code -s should show
the same as we could recover - test: zero first 32M */
static void init_source_bitmap(reiserfs_filsys_t *fs)
static void init_source_bitmap(reiserfs_filsys_t fs)
{
FILE *fp;
unsigned long block_count = get_sb_block_count(fs->fs_ondisk_sb);
@@ -2214,7 +2214,7 @@ static void init_source_bitmap(reiserfs_filsys_t *fs)
}
static void before_pass_0(reiserfs_filsys_t *fs)
static void before_pass_0(reiserfs_filsys_t fs)
{
/* bitmap of blocks to be read */
init_source_bitmap(fs);
@@ -2229,7 +2229,7 @@ static void before_pass_0(reiserfs_filsys_t *fs)
hash_hits_init(fs);
}
static void save_pass_0_result(reiserfs_filsys_t *fs)
static void save_pass_0_result(reiserfs_filsys_t fs)
{
FILE *file;
int retval;
@@ -2255,7 +2255,7 @@ static void save_pass_0_result(reiserfs_filsys_t *fs)
/* file 'fp' must contain 3 bitmaps saved during last pass 0: bitmap
of leaves, bitmaps of good and bad unfms*/
void load_pass_0_result(FILE * fp, reiserfs_filsys_t *fs)
void load_pass_0_result(FILE * fp, reiserfs_filsys_t fs)
{
leaves_bitmap = reiserfs_bitmap_load(fp);
good_unfm_bitmap = reiserfs_bitmap_load(fp);
@@ -2274,7 +2274,7 @@ void load_pass_0_result(FILE * fp, reiserfs_filsys_t *fs)
reiserfs_bitmap_ones(bad_unfm_bitmap));
}
static void after_pass_0(reiserfs_filsys_t *fs)
static void after_pass_0(reiserfs_filsys_t fs)
{
time_t t;
@@ -2317,7 +2317,7 @@ static void after_pass_0(reiserfs_filsys_t *fs)
exit(0);
}
void pass_0(reiserfs_filsys_t *fs)
void pass_0(reiserfs_filsys_t fs)
{
if (get_reiserfs_format(fs->fs_ondisk_sb) != fs->fs_format ||
get_reiserfs_format(fs->fs_ondisk_sb) == REISERFS_FORMAT_UNKNOWN) {
fsck/pass1.c
+9 -9
View File
@@ -340,7 +340,7 @@ out:
3. what we should do with directory entries hashed by another hash?
they are deleted for now
*/
static void pass1_correct_leaf(reiserfs_filsys_t *fs, struct buffer_head *bh)
static void pass1_correct_leaf(reiserfs_filsys_t fs, struct buffer_head *bh)
{
unsigned int i, j;
struct item_head *ih;
@@ -483,7 +483,7 @@ struct si *remove_saved_item(struct si *si)
/* fsck starts creating of this bitmap on pass 1. It will then become
on-disk bitmap */
static void init_new_bitmap(reiserfs_filsys_t *fs)
static void init_new_bitmap(reiserfs_filsys_t fs)
{
unsigned int i;
unsigned long block;
@@ -553,7 +553,7 @@ static void init_new_bitmap(reiserfs_filsys_t *fs)
/* this makes a map of blocks which can be allocated when fsck will
continue */
static void find_allocable_blocks(reiserfs_filsys_t *fs)
static void find_allocable_blocks(reiserfs_filsys_t fs)
{
unsigned long i;
@@ -596,7 +596,7 @@ static void find_allocable_blocks(reiserfs_filsys_t *fs)
fs->block_deallocator = reiserfsck_reiserfs_free_block;
}
static void before_pass_1(reiserfs_filsys_t *fs)
static void before_pass_1(reiserfs_filsys_t fs)
{
/* this will become an on-disk bitmap */
init_new_bitmap(fs);
@@ -617,7 +617,7 @@ static void before_pass_1(reiserfs_filsys_t *fs)
/* pass 1 does not deal with objectid */
}
static void save_pass_1_result(reiserfs_filsys_t *fs)
static void save_pass_1_result(reiserfs_filsys_t fs)
{
FILE *file;
int retval;
@@ -645,7 +645,7 @@ static void save_pass_1_result(reiserfs_filsys_t *fs)
state_dump_file(fs));
}
void load_pass_1_result(FILE * fp, reiserfs_filsys_t *fs)
void load_pass_1_result(FILE * fp, reiserfs_filsys_t fs)
{
fsck_new_bitmap(fs) =
reiserfs_create_bitmap(get_sb_block_count(fs->fs_ondisk_sb));
@@ -676,7 +676,7 @@ void load_pass_1_result(FILE * fp, reiserfs_filsys_t *fs)
/* reads blocks marked in leaves_bitmap and tries to insert them into
tree */
static void do_pass_1(reiserfs_filsys_t *fs)
static void do_pass_1(reiserfs_filsys_t fs)
{
struct buffer_head *bh;
unsigned long i;
@@ -775,7 +775,7 @@ static void do_pass_1(reiserfs_filsys_t *fs)
}
static void after_pass_1(reiserfs_filsys_t *fs)
static void after_pass_1(reiserfs_filsys_t fs)
{
time_t t;
@@ -822,7 +822,7 @@ static void after_pass_1(reiserfs_filsys_t *fs)
exit(0);
}
void pass_1(reiserfs_filsys_t *fs)
void pass_1(reiserfs_filsys_t fs)
{
fsck_progress("\nPass 1 (will try to insert %lu leaves):\n",
reiserfs_bitmap_ones(fsck_source_bitmap(fs)));
fsck/pass2.c
+6 -6
View File
@@ -432,12 +432,12 @@ static void put_not_stat_data_items(struct buffer_head *bh)
}
}
static void before_pass_2(reiserfs_filsys_t *fs)
static void before_pass_2(reiserfs_filsys_t fs)
{
/* anything specific for pass 2 ? */
}
static void save_pass_2_result(reiserfs_filsys_t *fs)
static void save_pass_2_result(reiserfs_filsys_t fs)
{
FILE *file;
int retval;
@@ -461,7 +461,7 @@ static void save_pass_2_result(reiserfs_filsys_t *fs)
/* we have nothing to load from a state file, but we have to fetch
on-disk bitmap, copy it to allocable bitmap, and fetch objectid
map */
void load_pass_2_result(reiserfs_filsys_t *fs)
void load_pass_2_result(reiserfs_filsys_t fs)
{
fsck_new_bitmap(fs) =
reiserfs_create_bitmap(get_sb_block_count(fs->fs_ondisk_sb));
@@ -483,7 +483,7 @@ void load_pass_2_result(reiserfs_filsys_t *fs)
/* uninsertable blocks are marked by 0s in uninsertable_leaf_bitmap
during the pass 1. They must be not in the tree */
static void do_pass_2(reiserfs_filsys_t *fs)
static void do_pass_2(reiserfs_filsys_t fs)
{
struct buffer_head *bh;
@@ -552,7 +552,7 @@ cont:
fsck_progress("\n");
}
static void after_pass_2(reiserfs_filsys_t *fs)
static void after_pass_2(reiserfs_filsys_t fs)
{
time_t t;
@@ -620,7 +620,7 @@ static void after_pass_2(reiserfs_filsys_t *fs)
exit(0);
}
void pass_2(reiserfs_filsys_t *fs)
void pass_2(reiserfs_filsys_t fs)
{
if (fsck_log_file(fs) != stderr)
fsck_log("####### Pass 2 #######\n");
fsck/semantic_rebuild.c
+6 -6
View File
@@ -1129,7 +1129,7 @@ void modify_item(struct item_head *ih, void *item)
}
/* mkreiserfs should have created this */
static void make_sure_lost_found_exists(reiserfs_filsys_t *fs)
static void make_sure_lost_found_exists(reiserfs_filsys_t fs)
{
int retval;
INITIALIZE_REISERFS_PATH(path);
@@ -1226,7 +1226,7 @@ static void make_sure_lost_found_exists(reiserfs_filsys_t *fs)
/* Result of the rebuild pass will be saved in the state file which is needed to start
* fsck again from the next pass. */
static void save_rebuild_semantic_result(reiserfs_filsys_t *fs)
static void save_rebuild_semantic_result(reiserfs_filsys_t fs)
{
FILE *file;
int retval;
@@ -1251,7 +1251,7 @@ static void save_rebuild_semantic_result(reiserfs_filsys_t *fs)
/* we have nothing to load from a state file, but we have to fetch
on-disk bitmap, copy it to allocable bitmap, and fetch objectid
map */
void load_semantic_result(FILE * file, reiserfs_filsys_t *fs)
void load_semantic_result(FILE * file, reiserfs_filsys_t fs)
{
fsck_new_bitmap(fs) =
reiserfs_create_bitmap(get_sb_block_count(fs->fs_ondisk_sb));
@@ -1272,12 +1272,12 @@ void load_semantic_result(FILE * file, reiserfs_filsys_t *fs)
*/
}
static void before_pass_3(reiserfs_filsys_t *fs)
static void before_pass_3(reiserfs_filsys_t fs)
{
semantic_id_map(fs) = id_map_init();
}
static void after_pass_3(reiserfs_filsys_t *fs)
static void after_pass_3(reiserfs_filsys_t fs)
{
/* update super block: objectid map, fsck state */
set_sb_fs_state(fs->fs_ondisk_sb, SEMANTIC_DONE);
@@ -1310,7 +1310,7 @@ static void after_pass_3(reiserfs_filsys_t *fs)
}
/* this is part of rebuild tree */
void pass_3_semantic(reiserfs_filsys_t *fs)
void pass_3_semantic(reiserfs_filsys_t fs)
{
before_pass_3(fs);
fsck/super.c
+2 -2
View File
@@ -38,7 +38,7 @@ static int what_fs_version(void)
return exit_code; \
}
int check_sb (reiserfs_filsys_t *fs) {
int check_sb (reiserfs_filsys_t fs) {
int magic = 0, version = 0;
if (!is_blocksize_correct (fs->fs_blocksize))
@@ -168,7 +168,7 @@ int check_sb (reiserfs_filsys_t *fs) {
}
*/
void rebuild_sb(reiserfs_filsys_t *fs, char *filename, struct fsck_data *data)
void rebuild_sb(reiserfs_filsys_t fs, char *filename, struct fsck_data *data)
{
int version = 0;
struct reiserfs_super_block *ondisk_sb = NULL;
fsck/ubitmap.c
+2 -2
View File
@@ -86,7 +86,7 @@ void mark_block_uninsertable(unsigned long block)
}
/* FIXME: should be able to work around no disk space */
int reiserfsck_reiserfs_new_blocknrs(reiserfs_filsys_t *fs,
int reiserfsck_reiserfs_new_blocknrs(reiserfs_filsys_t fs,
unsigned long *free_blocknrs,
unsigned long start, int amount_needed)
{
@@ -119,7 +119,7 @@ struct buffer_head *reiserfsck_get_new_buffer(unsigned long start)
}
/* free block in new bitmap */
int reiserfsck_reiserfs_free_block(reiserfs_filsys_t *fs, unsigned long block)
int reiserfsck_reiserfs_free_block(reiserfs_filsys_t fs, unsigned long block)
{
mark_block_free(block);
fsck/ufile.c
+2 -2
View File
@@ -1397,7 +1397,7 @@ check_again:
return get_bytes_number(ih, fs->fs_blocksize);
}
void one_more_corruption(reiserfs_filsys_t *fs, int kind)
void one_more_corruption(reiserfs_filsys_t fs, int kind)
{
if (kind == FATAL)
fsck_check_stat(fs)->fatal_corruptions++;
@@ -1405,7 +1405,7 @@ void one_more_corruption(reiserfs_filsys_t *fs, int kind)
fsck_check_stat(fs)->fixable_corruptions++;
}
void one_less_corruption(reiserfs_filsys_t *fs, int kind)
void one_less_corruption(reiserfs_filsys_t fs, int kind)
{
if (kind == FATAL)
fsck_check_stat(fs)->fatal_corruptions--;
fsck/uobjectid.c
+2 -2
View File
@@ -209,7 +209,7 @@ start_again:
}
}
void id_map_flush(struct id_map *map, reiserfs_filsys_t *fs)
void id_map_flush(struct id_map *map, reiserfs_filsys_t fs)
{
int size, max, i;
__u32 id, prev_id;
@@ -283,7 +283,7 @@ void id_map_flush(struct id_map *map, reiserfs_filsys_t *fs)
/* FIXME: these 3 methods must be implemented also.
void fetch_objectid_map (struct id_map * map, reiserfs_filsys_t *fs)
void fetch_objectid_map (struct id_map * map, reiserfs_filsys_t fs)
{
int sb_size;
__le32 * sb_objectid_map;
fsck/ustree.c
+1 -1
View File
@@ -194,7 +194,7 @@ static void erase(void)
fflush(stdout);
}
void pass_through_tree(reiserfs_filsys_t *fs, do_after_read_t action1,
void pass_through_tree(reiserfs_filsys_t fs, do_after_read_t action1,
do_on_full_path_t action2, int depth)
{
struct buffer_head *path[MAX_HEIGHT] = { 0, };
include/reiserfs_fs.h
+18 -18
View File
@@ -496,7 +496,7 @@ struct reiserfs_journal_header {
(unsigned long long)((8192 > journal_max_size (block_of_super_block,blocksize)) ? \
journal_max_size (block_of_super_block,blocksize) : 8192)
int reiserfs_replay_journal(reiserfs_filsys_t *fs);
int reiserfs_replay_journal(reiserfs_filsys_t fs);
//#define JOURNAL_DEFAULT_SIZE 8192 number of blocks in the journal
//#define JOURNAL_DEFAULT_SIZE_FOR_BS_1024 8125 number of blocks in the journal for block size 1KB
@@ -1213,7 +1213,7 @@ struct virtual_node {
/* someday somebody will prefix every field in this struct with tb_ */
struct tree_balance {
struct reiserfs_transaction_handle *transaction_handle;
reiserfs_filsys_t *tb_fs;
reiserfs_filsys_t tb_fs;
struct reiserfs_path *tb_path;
struct buffer_head *L[MAX_HEIGHT]; /* array of left neighbors of nodes in the path */
struct buffer_head *R[MAX_HEIGHT]; /* array of right neighbors of nodes in the path */
@@ -1305,7 +1305,7 @@ struct tree_balance {
/* used in do_balance for passing parent of node information that has been
gotten from tb struct */
struct buffer_info {
reiserfs_filsys_t *bi_fs;
reiserfs_filsys_t bi_fs;
struct buffer_head * bi_bh;
struct buffer_head * bi_parent;
int bi_position;
@@ -1412,18 +1412,18 @@ struct buffer_info {
void padd_item (char * item, int total_length, int length);
int B_IS_IN_TREE(struct buffer_head *);
const struct reiserfs_key *get_rkey(const struct reiserfs_path *p_s_chk_path,
const reiserfs_filsys_t *);
const reiserfs_filsys_t );
int bin_search (void * p_v_key, void * p_v_base, int p_n_num, int p_n_width, unsigned int * p_n_pos);
int search_by_key (reiserfs_filsys_t *, struct reiserfs_key *, struct reiserfs_path *, int);
int search_by_entry_key (reiserfs_filsys_t *, struct reiserfs_key *, struct reiserfs_path *);
int search_for_position_by_key (reiserfs_filsys_t *, struct reiserfs_key *, struct reiserfs_path *);
int search_by_objectid (reiserfs_filsys_t *, struct reiserfs_key *, struct reiserfs_path *, int *);
int search_by_key (reiserfs_filsys_t , struct reiserfs_key *, struct reiserfs_path *, int);
int search_by_entry_key (reiserfs_filsys_t , struct reiserfs_key *, struct reiserfs_path *);
int search_for_position_by_key (reiserfs_filsys_t , struct reiserfs_key *, struct reiserfs_path *);
int search_by_objectid (reiserfs_filsys_t , struct reiserfs_key *, struct reiserfs_path *, int *);
void decrement_counters_in_path (struct reiserfs_path *p_s_search_path);
void pathrelse (struct reiserfs_path *p_s_search_path);
int is_left_mergeable (reiserfs_filsys_t *s, struct reiserfs_path *path);
int is_right_mergeable (reiserfs_filsys_t *s, struct reiserfs_path *path);
int is_left_mergeable (reiserfs_filsys_t s, struct reiserfs_path *path);
int is_right_mergeable (reiserfs_filsys_t s, struct reiserfs_path *path);
int are_items_mergeable (struct item_head * left, struct item_head * right, int bsize);
@@ -1445,8 +1445,8 @@ void init_path (struct reiserfs_path *);
void print_tb (int mode, int item_pos, int pos_in_item, struct tree_balance * tb, char * mes);
void print_bmap (FILE * fp, reiserfs_filsys_t *fs, int silent);
void print_objectid_map (FILE * fp, reiserfs_filsys_t *fs);
void print_bmap (FILE * fp, reiserfs_filsys_t fs, int silent);
void print_objectid_map (FILE * fp, reiserfs_filsys_t fs);
@@ -1468,8 +1468,8 @@ void leaf_cut_from_buffer(struct buffer_info *bi, int cut_item_num,
void leaf_paste_entries (struct buffer_head * bh, int item_num, int before, int new_entry_count,
struct reiserfs_de_head * new_dehs, const char * records,
int paste_size);
void delete_item (reiserfs_filsys_t *, struct buffer_head * bh, int item_num);
void cut_entry (reiserfs_filsys_t *, struct buffer_head * bh,
void delete_item (reiserfs_filsys_t , struct buffer_head * bh, int item_num);
void cut_entry (reiserfs_filsys_t , struct buffer_head * bh,
int item_num, int entry_num, int del_count);
@@ -1483,7 +1483,7 @@ void do_balance (struct tree_balance * tb,
void reiserfs_invalidate_buffer (struct tree_balance * tb, struct buffer_head * bh);
int get_left_neighbor_position (struct tree_balance * tb, int h);
int get_right_neighbor_position (struct tree_balance * tb, int h);
void replace_key (reiserfs_filsys_t *, struct buffer_head *, int, struct buffer_head *, int);
void replace_key (reiserfs_filsys_t , struct buffer_head *, int, struct buffer_head *, int);
void replace_lkey (struct tree_balance *, int, struct item_head *);
void replace_rkey (struct tree_balance *, int, struct item_head *);
void make_empty_node (struct buffer_info *);
@@ -1504,9 +1504,9 @@ __u32 r5_hash (const char *msg, int len);
/* node_format.c */
extern unsigned int get_journal_old_start_must (reiserfs_filsys_t *fs);
extern unsigned int get_journal_new_start_must (reiserfs_filsys_t *fs);
extern unsigned int get_journal_start_must (reiserfs_filsys_t *fs);
extern unsigned int get_journal_old_start_must (reiserfs_filsys_t fs);
extern unsigned int get_journal_new_start_must (reiserfs_filsys_t fs);
extern unsigned int get_journal_start_must (reiserfs_filsys_t fs);
/*extern hashf_t hashes [];*/
static inline void buffer_info_init_left(struct tree_balance *tb,
include/reiserfs_lib.h
+76 -76
View File
@@ -9,7 +9,7 @@
#define BADBLOCK_DIRID 1
#define BADBLOCK_OBJID (__u32)-1
typedef struct reiserfs_filsys reiserfs_filsys_t;
typedef struct reiserfs_filsys * reiserfs_filsys_t;
#include "reiserfs_fs.h"
@@ -53,10 +53,10 @@ struct reiserfs_filsys {
int fs_dirt;
int fs_flags;
void *fs_vp;
int (*block_allocator) (reiserfs_filsys_t *fs,
int (*block_allocator) (reiserfs_filsys_t fs,
unsigned long *free_blocknrs,
unsigned long start, int amount_needed);
int (*block_deallocator) (reiserfs_filsys_t *fs, unsigned long block);
int (*block_deallocator) (reiserfs_filsys_t fs, unsigned long block);
};
struct _transaction {
@@ -72,25 +72,25 @@ typedef struct _transaction reiserfs_trans_t;
/* reiserfslib.c */
void init_tb_struct(struct tree_balance *tb, reiserfs_filsys_t *,
void init_tb_struct(struct tree_balance *tb, reiserfs_filsys_t ,
struct reiserfs_path *path, int size);
reiserfs_filsys_t *reiserfs_open(const char *filename, int flags, int *error,
reiserfs_filsys_t reiserfs_open(const char *filename, int flags, int *error,
void *vp, int skip_check);
reiserfs_filsys_t *reiserfs_create(char *filename, int version,
reiserfs_filsys_t reiserfs_create(char *filename, int version,
unsigned long block_count, int block_size,
int default_journal, int new_format);
void reiserfs_flush(reiserfs_filsys_t *);
void reiserfs_free(reiserfs_filsys_t *);
void reiserfs_close(reiserfs_filsys_t *);
void reiserfs_reopen(reiserfs_filsys_t *, int flags);
int is_opened_rw(reiserfs_filsys_t *fs);
void reiserfs_flush(reiserfs_filsys_t );
void reiserfs_free(reiserfs_filsys_t );
void reiserfs_close(reiserfs_filsys_t );
void reiserfs_reopen(reiserfs_filsys_t , int flags);
int is_opened_rw(reiserfs_filsys_t fs);
/*
void reiserfs_read_bitmap_blocks (reiserfs_filsys_t *);
void reiserfs_free_bitmap_blocks (reiserfs_filsys_t *);
void reiserfs_read_bitmap_blocks (reiserfs_filsys_t );
void reiserfs_free_bitmap_blocks (reiserfs_filsys_t );
*/
int no_reiserfs_found(reiserfs_filsys_t *);
int no_reiserfs_found(reiserfs_filsys_t );
int block_size_ok(int blocksize, int force);
int is_block_count_correct(unsigned long block_of_super_block,
unsigned int block_size, unsigned long block_count,
@@ -99,37 +99,37 @@ int is_block_count_correct(unsigned long block_of_super_block,
unsigned long get_size_of_journal_or_reserved_area(struct reiserfs_super_block
*sb);
int reiserfs_new_blocknrs(reiserfs_filsys_t *,
int reiserfs_new_blocknrs(reiserfs_filsys_t ,
unsigned long *free_blocknrs, unsigned long start,
int amount_needed);
int reiserfs_free_block(reiserfs_filsys_t *, unsigned long block);
int spread_bitmaps(reiserfs_filsys_t *);
int filesystem_dirty(reiserfs_filsys_t *);
void mark_filesystem_dirty(reiserfs_filsys_t *);
int reiserfs_free_block(reiserfs_filsys_t , unsigned long block);
int spread_bitmaps(reiserfs_filsys_t );
int filesystem_dirty(reiserfs_filsys_t );
void mark_filesystem_dirty(reiserfs_filsys_t );
void reiserfs_paste_into_item(reiserfs_filsys_t *, struct reiserfs_path *path,
void reiserfs_paste_into_item(reiserfs_filsys_t , struct reiserfs_path *path,
const void *body, int size);
void reiserfs_insert_item(reiserfs_filsys_t *, struct reiserfs_path *path,
void reiserfs_insert_item(reiserfs_filsys_t , struct reiserfs_path *path,
struct item_head *ih, const void *body);
int reiserfs_locate_entry(reiserfs_filsys_t *, struct reiserfs_key *dir,
int reiserfs_locate_entry(reiserfs_filsys_t , struct reiserfs_key *dir,
char *name, struct reiserfs_path *path);
int reiserfs_find_entry(reiserfs_filsys_t *, struct reiserfs_key *dir,
int reiserfs_find_entry(reiserfs_filsys_t , struct reiserfs_key *dir,
char *name, unsigned int *min_gen_counter,
struct reiserfs_key *key);
int reiserfs_add_entry(reiserfs_filsys_t *, struct reiserfs_key *dir,
int reiserfs_add_entry(reiserfs_filsys_t , struct reiserfs_key *dir,
char *name, int name_len, struct reiserfs_key *key,
__u16 fsck_need);
struct reiserfs_key *uget_lkey(struct reiserfs_path *path);
struct reiserfs_key *uget_rkey(struct reiserfs_path *path);
int reiserfs_search_by_key_3(reiserfs_filsys_t *, struct reiserfs_key *key,
int reiserfs_search_by_key_3(reiserfs_filsys_t , struct reiserfs_key *key,
struct reiserfs_path *path);
int reiserfs_search_by_key_4(reiserfs_filsys_t *, struct reiserfs_key *key,
int reiserfs_search_by_key_4(reiserfs_filsys_t , struct reiserfs_key *key,
struct reiserfs_path *path);
int reiserfs_search_by_entry_key(reiserfs_filsys_t *, struct reiserfs_key *key,
int reiserfs_search_by_entry_key(reiserfs_filsys_t , struct reiserfs_key *key,
struct reiserfs_path *path);
int reiserfs_search_by_position(reiserfs_filsys_t *, struct reiserfs_key *key,
int reiserfs_search_by_position(reiserfs_filsys_t , struct reiserfs_key *key,
int version, struct reiserfs_path *path);
struct reiserfs_key *reiserfs_next_key(struct reiserfs_path *path);
void copy_key(void *to, const void *from);
@@ -141,22 +141,22 @@ int comp_items(struct item_head *p_s_ih, struct reiserfs_path *p_s_path);
__u32 hash_value(hashf_t func, char *name, int namelen);
int create_dir_sd(reiserfs_filsys_t *fs,
int create_dir_sd(reiserfs_filsys_t fs,
struct reiserfs_path *path, struct reiserfs_key *key,
void (*modify_item) (struct item_head *, void *));
void make_sure_root_dir_exists(reiserfs_filsys_t *fs,
void make_sure_root_dir_exists(reiserfs_filsys_t fs,
void (*modyfy_item) (struct item_head *, void *),
int ih_flags);
typedef void (*badblock_func_t) (reiserfs_filsys_t *fs,
typedef void (*badblock_func_t) (reiserfs_filsys_t fs,
struct reiserfs_path *badblock_path,
void *data);
void mark_badblock(reiserfs_filsys_t *fs, struct reiserfs_path *badblock_path,
void mark_badblock(reiserfs_filsys_t fs, struct reiserfs_path *badblock_path,
void *data);
int create_badblock_bitmap(reiserfs_filsys_t *fs, char *badblocks_file);
void add_badblock_list(reiserfs_filsys_t *fs, int no_badblock_in_tree_yet);
void badblock_list(reiserfs_filsys_t *fs, badblock_func_t action, void *data);
int create_badblock_bitmap(reiserfs_filsys_t fs, char *badblocks_file);
void add_badblock_list(reiserfs_filsys_t fs, int no_badblock_in_tree_yet);
void badblock_list(reiserfs_filsys_t fs, badblock_func_t action, void *data);
#define reiserfs_fs_bmap_nr(fs) reiserfs_bmap_nr(get_sb_block_count(fs->fs_ondisk_sb), fs->fs_blocksize)
#define reiserfs_bmap_nr(count, blk_size) ((count - 1) / (blk_size * 8) + 1)
#define reiserfs_bmap_over(nr) (nr > ((1LL << 16) - 1))
@@ -168,13 +168,13 @@ extern __u16 root_dir_format;
extern __u16 lost_found_dir_format;
/* bitmap.c */
int reiserfs_open_ondisk_bitmap(reiserfs_filsys_t *);
int reiserfs_create_ondisk_bitmap(reiserfs_filsys_t *);
void reiserfs_free_ondisk_bitmap(reiserfs_filsys_t *);
void reiserfs_close_ondisk_bitmap(reiserfs_filsys_t *);
int reiserfs_open_ondisk_bitmap(reiserfs_filsys_t );
int reiserfs_create_ondisk_bitmap(reiserfs_filsys_t );
void reiserfs_free_ondisk_bitmap(reiserfs_filsys_t );
void reiserfs_close_ondisk_bitmap(reiserfs_filsys_t );
int reiserfs_flush_to_ondisk_bitmap(reiserfs_bitmap_t *bm,
reiserfs_filsys_t *fs);
unsigned int reiserfs_calc_bmap_nr(reiserfs_filsys_t *fs, unsigned int blocks);
reiserfs_filsys_t fs);
unsigned int reiserfs_calc_bmap_nr(reiserfs_filsys_t fs, unsigned int blocks);
reiserfs_bitmap_t *reiserfs_create_bitmap(unsigned int bit_count);
int reiserfs_expand_bitmap(reiserfs_bitmap_t *bm, unsigned int bit_count);
@@ -191,8 +191,8 @@ void reiserfs_bitmap_clear_bit(reiserfs_bitmap_t *bm, unsigned int bit_number);
int reiserfs_bitmap_test_bit(reiserfs_bitmap_t *bm, unsigned int bit_number);
int reiserfs_bitmap_find_zero_bit(reiserfs_bitmap_t *bm, unsigned long *start);
/*int reiserfs_fetch_ondisk_bitmap (reiserfs_bitmap_t *bm, reiserfs_filsys_t *);*/
/*int reiserfs_flush_bitmap (reiserfs_bitmap_t *bm, reiserfs_filsys_t *);*/
/*int reiserfs_fetch_ondisk_bitmap (reiserfs_bitmap_t *bm, reiserfs_filsys_t );*/
/*int reiserfs_flush_bitmap (reiserfs_bitmap_t *bm, reiserfs_filsys_t );*/
void reiserfs_bitmap_zero(reiserfs_bitmap_t *bm);
void reiserfs_bitmap_fill(reiserfs_bitmap_t *bm);
unsigned int reiserfs_bitmap_ones(reiserfs_bitmap_t *bm);
@@ -211,7 +211,7 @@ int is_stage_magic_correct(FILE * fp);
reiserfs_bitmap_t *reiserfs_bitmap_load(FILE * fp);
void reiserfs_bitmap_invert(reiserfs_bitmap_t *bm);
int reiserfs_remove_entry(reiserfs_filsys_t *, struct reiserfs_key *key);
int reiserfs_remove_entry(reiserfs_filsys_t , struct reiserfs_key *key);
/* node_formats.c */
@@ -240,13 +240,13 @@ int is_a_leaf(char *buf, int blocksize);
int leaf_item_number_estimate(struct buffer_head *bh);
char *which_block(int code);
int get_journal_size(reiserfs_filsys_t *);
int not_data_block(reiserfs_filsys_t *, unsigned long block);
int not_journalable(reiserfs_filsys_t *, unsigned long block);
int block_of_bitmap(reiserfs_filsys_t *, unsigned long block);
int block_of_journal(reiserfs_filsys_t *, unsigned long block);
int get_journal_size(reiserfs_filsys_t );
int not_data_block(reiserfs_filsys_t , unsigned long block);
int not_journalable(reiserfs_filsys_t , unsigned long block);
int block_of_bitmap(reiserfs_filsys_t , unsigned long block);
int block_of_journal(reiserfs_filsys_t , unsigned long block);
int is_tree_node(struct buffer_head *bh, int level);
int is_properly_hashed(reiserfs_filsys_t *,
int is_properly_hashed(reiserfs_filsys_t ,
char *name, int namelen, __u32 offset);
int dir_entry_bad_location(struct reiserfs_de_head *deh,
struct item_head *ih, int first);
@@ -257,7 +257,7 @@ void make_empty_dir_item_v1(char *body, __u32 dirid, __u32 objid,
__u32 par_dirid, __u32 par_objid);
void make_empty_dir_item(char *body, __u32 dirid, __u32 objid,
__u32 par_dirid, __u32 par_objid);
int reiserfs_is_fs_consistent(reiserfs_filsys_t *fs);
int reiserfs_is_fs_consistent(reiserfs_filsys_t fs);
typedef void (*item_action_t) (struct buffer_head * bh, struct item_head * ih);
typedef void (*item_head_action_t) (struct item_head * ih);
@@ -276,8 +276,8 @@ void set_offset(int format, struct reiserfs_key *key, loff_t offset);
void set_type_and_offset(int format, struct reiserfs_key *key, loff_t offset,
int type);
typedef int (*check_unfm_func_t) (reiserfs_filsys_t *, __u32);
int is_it_bad_item(reiserfs_filsys_t *, struct item_head *, char *,
typedef int (*check_unfm_func_t) (reiserfs_filsys_t , __u32);
int is_it_bad_item(reiserfs_filsys_t , struct item_head *, char *,
check_unfm_func_t, int bad_dir);
#define hash_func_is_unknown(fs) ((fs)->fs_hash_function == NULL)
@@ -328,36 +328,36 @@ void get_set_sd_field(int field, struct item_head *ih, void *sd,
#define get_sd_first_direct_byte(ih,sd,pfdb) get_set_sd_field (GET_SD_FIRST_DIRECT_BYTE, ih, sd, pfdb, 0/*get*/)
#define set_sd_first_direct_byte(ih,sd,pfdb) get_set_sd_field (GET_SD_FIRST_DIRECT_BYTE, ih, sd, pfdb, 1/*set*/)
int is_objectid_used(reiserfs_filsys_t *fs, __u32 objectid);
void mark_objectid_used(reiserfs_filsys_t *fs, __u32 objectid);
int is_objectid_used(reiserfs_filsys_t fs, __u32 objectid);
void mark_objectid_used(reiserfs_filsys_t fs, __u32 objectid);
/* journal.c */
int get_boundary_transactions(reiserfs_filsys_t *, reiserfs_trans_t *,
int get_boundary_transactions(reiserfs_filsys_t , reiserfs_trans_t *,
reiserfs_trans_t *);
int next_transaction(reiserfs_filsys_t *, reiserfs_trans_t *, reiserfs_trans_t);
int next_transaction(reiserfs_filsys_t , reiserfs_trans_t *, reiserfs_trans_t);
int replay_one_transaction(reiserfs_filsys_t *, reiserfs_trans_t *);
int replay_one_transaction(reiserfs_filsys_t , reiserfs_trans_t *);
typedef void (*action_on_trans_t) (reiserfs_filsys_t *, reiserfs_trans_t *);
void for_each_transaction(reiserfs_filsys_t *, action_on_trans_t);
typedef void (*action_on_trans_t) (reiserfs_filsys_t , reiserfs_trans_t *);
void for_each_transaction(reiserfs_filsys_t , action_on_trans_t);
typedef void (*action_on_block_t) (reiserfs_filsys_t *, reiserfs_trans_t *,
typedef void (*action_on_block_t) (reiserfs_filsys_t , reiserfs_trans_t *,
unsigned int index,
unsigned long in_journal,
unsigned long in_place);
void for_each_block(reiserfs_filsys_t *fs, reiserfs_trans_t *trans,
void for_each_block(reiserfs_filsys_t fs, reiserfs_trans_t *trans,
action_on_block_t action);
int reiserfs_open_journal(reiserfs_filsys_t *, char *, int flags);
int reiserfs_journal_params_check(reiserfs_filsys_t *fs);
int reiserfs_create_journal(reiserfs_filsys_t *fs, char *j_filename,
int reiserfs_open_journal(reiserfs_filsys_t , char *, int flags);
int reiserfs_journal_params_check(reiserfs_filsys_t fs);
int reiserfs_create_journal(reiserfs_filsys_t fs, char *j_filename,
unsigned long offset, unsigned long len,
int transaction_max_size, int force);
int reiserfs_journal_opened(reiserfs_filsys_t *);
void reiserfs_flush_journal(reiserfs_filsys_t *fs);
void reiserfs_free_journal(reiserfs_filsys_t *fs);
void reiserfs_close_journal(reiserfs_filsys_t *);
void reiserfs_reopen_journal(reiserfs_filsys_t *fs, int flag);
int reiserfs_journal_opened(reiserfs_filsys_t );
void reiserfs_flush_journal(reiserfs_filsys_t fs);
void reiserfs_free_journal(reiserfs_filsys_t fs);
void reiserfs_close_journal(reiserfs_filsys_t );
void reiserfs_reopen_journal(reiserfs_filsys_t fs, int flag);
__u32 advise_journal_max_trans_age(void);
__u32 advise_journal_max_commit_age(void);
__u32 advise_journal_max_batch(unsigned long journal_trans_max);
@@ -366,17 +366,17 @@ __u32 advise_journal_max_trans_len(__u32 desired, __u32 journal_size,
/* prints.c */
void print_indirect_item(FILE * fp, struct buffer_head *bh, int item_num);
void print_block(FILE * fp, reiserfs_filsys_t *, struct buffer_head *bh, ...); //int print_mode, int first, int last);
int print_super_block(FILE * fp, reiserfs_filsys_t *, char *file_name,
void print_block(FILE * fp, reiserfs_filsys_t , struct buffer_head *bh, ...); //int print_mode, int first, int last);
int print_super_block(FILE * fp, reiserfs_filsys_t , char *file_name,
struct buffer_head *bh, int short_print);
void print_journal(reiserfs_filsys_t *);
void print_journal_header(reiserfs_filsys_t *fs);
void print_journal(reiserfs_filsys_t );
void print_journal_header(reiserfs_filsys_t fs);
void reiserfs_warning(FILE * fp, const char *fmt, ...);
char ftypelet(mode_t mode);
void reiserfs_print_item(FILE * fp, struct buffer_head *bh,
struct item_head *ih);
void print_filesystem_state(FILE * fp, reiserfs_filsys_t *fs);
void print_one_transaction(reiserfs_filsys_t *fs, reiserfs_trans_t *trans);
void print_filesystem_state(FILE * fp, reiserfs_filsys_t fs);
void print_one_transaction(reiserfs_filsys_t fs, reiserfs_trans_t *trans);
void print_journal_params(FILE * fp, struct journal_params *jp);
char *get_reiserfs_version(__u16 version);
int can_we_format_it(char *device_name, int force);
mkreiserfs/mkreiserfs.c
+6 -6
View File
@@ -105,7 +105,7 @@ enum mkfs_mode {
static int mode;
/* form super block (old one) */
static void make_super_block(reiserfs_filsys_t *fs)
static void make_super_block(reiserfs_filsys_t fs)
{
set_sb_umount_state(fs->fs_ondisk_sb, FS_CLEANLY_UMOUNTED);
set_sb_tree_height(fs->fs_ondisk_sb, 2);
@@ -166,7 +166,7 @@ static void invalidate_other_formats(int dev)
brelse(bh);
}
static void zero_journal(reiserfs_filsys_t *fs)
static void zero_journal(reiserfs_filsys_t fs)
{
unsigned long start, len, done;
struct buffer_head *bh;
@@ -197,7 +197,7 @@ static void zero_journal(reiserfs_filsys_t *fs)
/* this only sets few first bits in bitmap block. Fills not initialized fields
of super block (root block and bitmap block numbers) */
static void make_bitmap(reiserfs_filsys_t *fs)
static void make_bitmap(reiserfs_filsys_t fs)
{
struct reiserfs_super_block *sb = fs->fs_ondisk_sb;
unsigned int i;
@@ -279,7 +279,7 @@ static void set_root_dir_nlink(struct item_head *ih, void *sd)
/* form the root block of the tree (the block head, the item head, the
root directory) */
static void make_root_block(reiserfs_filsys_t *fs)
static void make_root_block(reiserfs_filsys_t fs)
{
struct reiserfs_super_block *sb;
struct buffer_head *bh;
@@ -302,7 +302,7 @@ static void make_root_block(reiserfs_filsys_t *fs)
mark_objectid_used(fs, REISERFS_ROOT_OBJECTID);
}
static void report(reiserfs_filsys_t *fs, char *j_filename)
static void report(reiserfs_filsys_t fs, char *j_filename)
{
// print_block (stdout, fs, fs->fs_super_bh);
struct reiserfs_super_block *sb =
@@ -545,7 +545,7 @@ static int select_format(void)
int main(int argc, char **argv)
{
reiserfs_filsys_t *fs;
reiserfs_filsys_t fs;
int force = 0;
char *device_name = NULL;
char *jdevice_name = NULL;
reiserfscore/bitmap.c
+6 -6
View File
@@ -231,7 +231,7 @@ int reiserfs_bitmap_find_zero_bit(reiserfs_bitmap_t *bm, unsigned long *first)
/* read every bitmap block and copy their content into bitmap 'bm' */
static int reiserfs_fetch_ondisk_bitmap(reiserfs_bitmap_t *bm,
reiserfs_filsys_t *fs)
reiserfs_filsys_t fs)
{
unsigned int last_byte_unused_bits;
unsigned long block, to_copy;
@@ -318,7 +318,7 @@ static int reiserfs_fetch_ondisk_bitmap(reiserfs_bitmap_t *bm,
/* copy bitmap 'bm' to buffers which hold on-disk bitmap if bitmap was ever
changed and return 1. Otherwise - return 0 */
int reiserfs_flush_to_ondisk_bitmap(reiserfs_bitmap_t *bm,
reiserfs_filsys_t *fs)
reiserfs_filsys_t fs)
{
unsigned int last_byte_unused_bits, i;
unsigned long to_copy, copied, block;
@@ -688,7 +688,7 @@ void reiserfs_bitmap_invert(reiserfs_bitmap_t *bm)
/*reiserfs_warning (stderr, "done\n"); */
}
void reiserfs_free_ondisk_bitmap(reiserfs_filsys_t *fs)
void reiserfs_free_ondisk_bitmap(reiserfs_filsys_t fs)
{
if (fs->fs_bitmap2) {
reiserfs_delete_bitmap(fs->fs_bitmap2);
@@ -697,7 +697,7 @@ void reiserfs_free_ondisk_bitmap(reiserfs_filsys_t *fs)
}
/* read bitmap blocks */
int reiserfs_open_ondisk_bitmap(reiserfs_filsys_t *fs)
int reiserfs_open_ondisk_bitmap(reiserfs_filsys_t fs)
{
unsigned int blocks = get_sb_block_count(fs->fs_ondisk_sb);
unsigned int bmap_nr = reiserfs_bmap_nr(blocks, fs->fs_blocksize);
@@ -731,7 +731,7 @@ int reiserfs_open_ondisk_bitmap(reiserfs_filsys_t *fs)
return reiserfs_fetch_ondisk_bitmap(fs->fs_bitmap2, fs);
}
int reiserfs_create_ondisk_bitmap(reiserfs_filsys_t *fs)
int reiserfs_create_ondisk_bitmap(reiserfs_filsys_t fs)
{
if (fs->fs_bitmap2)
reiserfs_panic("bitmap is initiaized already");
@@ -744,7 +744,7 @@ int reiserfs_create_ondisk_bitmap(reiserfs_filsys_t *fs)
return 1;
}
void reiserfs_close_ondisk_bitmap(reiserfs_filsys_t *fs)
void reiserfs_close_ondisk_bitmap(reiserfs_filsys_t fs)
{
if (!fs->fs_bitmap2)
return;
reiserfscore/do_balan.c
+1 -1
View File
@@ -1420,7 +1420,7 @@ struct buffer_head *get_FEB(struct tree_balance *tb)
}
/* Replace n_dest'th key in buffer dest by n_src'th key of buffer src.*/
void replace_key(reiserfs_filsys_t *fs,
void replace_key(reiserfs_filsys_t fs,
struct buffer_head *dest, int n_dest,
struct buffer_head *src, int n_src)
{
reiserfscore/fix_node.c
+7 -7
View File
@@ -904,7 +904,7 @@ int are_items_mergeable(struct item_head *left, struct item_head *right,
}
/* get left neighbor of the leaf node */
static struct buffer_head *get_left_neighbor(reiserfs_filsys_t *s,
static struct buffer_head *get_left_neighbor(reiserfs_filsys_t s,
struct reiserfs_path *path)
{
struct reiserfs_key key;
@@ -926,7 +926,7 @@ static struct buffer_head *get_left_neighbor(reiserfs_filsys_t *s,
return bh;
}
static struct buffer_head *get_right_neighbor(reiserfs_filsys_t *s,
static struct buffer_head *get_right_neighbor(reiserfs_filsys_t s,
struct reiserfs_path *path)
{
struct reiserfs_key key;
@@ -953,7 +953,7 @@ static struct buffer_head *get_right_neighbor(reiserfs_filsys_t *s,
return bh;
}
int is_left_mergeable(reiserfs_filsys_t *s, struct reiserfs_path *path)
int is_left_mergeable(reiserfs_filsys_t s, struct reiserfs_path *path)
{
struct item_head *right;
struct buffer_head *bh;
@@ -972,7 +972,7 @@ int is_left_mergeable(reiserfs_filsys_t *s, struct reiserfs_path *path)
return retval;
}
int is_right_mergeable(reiserfs_filsys_t *s, struct reiserfs_path *path)
int is_right_mergeable(reiserfs_filsys_t s, struct reiserfs_path *path)
{
struct item_head *left;
struct buffer_head *bh;
@@ -1152,7 +1152,7 @@ static int get_empty_nodes(struct tree_balance *p_s_tb, int n_h)
unsigned long *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 */
n_repeat;
reiserfs_filsys_t *fs = p_s_tb->tb_fs;
reiserfs_filsys_t fs = p_s_tb->tb_fs;
if (n_h == 0 && p_s_tb->insert_size[n_h] == 0x7fff)
return CARRY_ON;
@@ -1267,7 +1267,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)
{
struct buffer_head *p_s_father;
reiserfs_filsys_t *fs = p_s_tb->tb_fs;
reiserfs_filsys_t fs = p_s_tb->tb_fs;
unsigned long n_left_neighbor_blocknr;
int n_left_neighbor_position;
@@ -2245,7 +2245,7 @@ static int get_neighbors(struct tree_balance *p_s_tb, int n_h)
int n_child_position,
n_path_offset = PATH_H_PATH_OFFSET(p_s_tb->tb_path, n_h + 1);
unsigned long n_son_number;
reiserfs_filsys_t *fs = p_s_tb->tb_fs;
reiserfs_filsys_t fs = p_s_tb->tb_fs;
struct buffer_head *p_s_bh;
/*struct virtual_node * vn = p_s_tb->tb_vn; */
reiserfscore/journal.c
+20 -20
View File
@@ -19,7 +19,7 @@ static int does_desc_match_commit(struct buffer_head *d_bh,
/* d_bh is descriptor, return number of block where commit block of this
transaction is to be */
static unsigned long commit_expected(reiserfs_filsys_t *fs,
static unsigned long commit_expected(reiserfs_filsys_t fs,
struct buffer_head *d_bh)
{
unsigned long offset;
@@ -35,7 +35,7 @@ static unsigned long commit_expected(reiserfs_filsys_t *fs,
/* d_bh contains journal descriptor, returns number of block where descriptor
block of next transaction should be */
static unsigned long next_desc_expected(reiserfs_filsys_t *fs,
static unsigned long next_desc_expected(reiserfs_filsys_t fs,
struct buffer_head *d_bh)
{
unsigned long offset;
@@ -50,7 +50,7 @@ static unsigned long next_desc_expected(reiserfs_filsys_t *fs,
}
/* common checks for validness of a transaction */
static int transaction_check_content(reiserfs_filsys_t *fs,
static int transaction_check_content(reiserfs_filsys_t fs,
reiserfs_trans_t *trans)
{
struct buffer_head *d_bh, *c_bh;
@@ -102,7 +102,7 @@ error_desc_brelse:
}
/* common checks for validness of a transaction */
static int transaction_check_desc(reiserfs_filsys_t *fs,
static int transaction_check_desc(reiserfs_filsys_t fs,
struct buffer_head *d_bh)
{
struct buffer_head *c_bh;
@@ -127,7 +127,7 @@ static int transaction_check_desc(reiserfs_filsys_t *fs,
/* read the journal and find the oldest and newest transactions, return number
of transactions found */
int get_boundary_transactions(reiserfs_filsys_t *fs,
int get_boundary_transactions(reiserfs_filsys_t fs,
reiserfs_trans_t *oldest,
reiserfs_trans_t *newest)
{
@@ -196,7 +196,7 @@ int get_boundary_transactions(reiserfs_filsys_t *fs,
/* trans is a valid transaction. Look for valid transaction with smallest
trans id which is greater than the id of the current one */
int next_transaction(reiserfs_filsys_t *fs, reiserfs_trans_t *trans,
int next_transaction(reiserfs_filsys_t fs, reiserfs_trans_t *trans,
reiserfs_trans_t break_trans)
{
struct buffer_head *d_bh, *next_d_bh;
@@ -251,7 +251,7 @@ int next_transaction(reiserfs_filsys_t *fs, reiserfs_trans_t *trans,
return found;
}
static void read_journal_write_in_place(reiserfs_filsys_t *fs,
static void read_journal_write_in_place(reiserfs_filsys_t fs,
reiserfs_trans_t *trans,
unsigned int index,
unsigned long in_journal,
@@ -286,7 +286,7 @@ static void read_journal_write_in_place(reiserfs_filsys_t *fs,
}
/* go through all blocks of transaction and call 'action' each of them */
void for_each_block(reiserfs_filsys_t *fs, reiserfs_trans_t *trans,
void for_each_block(reiserfs_filsys_t fs, reiserfs_trans_t *trans,
action_on_block_t action)
{
struct buffer_head *d_bh, *c_bh;
@@ -338,14 +338,14 @@ void for_each_block(reiserfs_filsys_t *fs, reiserfs_trans_t *trans,
}
/* transaction is supposed to be valid */
int replay_one_transaction(reiserfs_filsys_t *fs, reiserfs_trans_t *trans)
int replay_one_transaction(reiserfs_filsys_t fs, reiserfs_trans_t *trans)
{
for_each_block(fs, trans, read_journal_write_in_place);
fsync(fs->fs_dev);
return 0;
}
void for_each_transaction(reiserfs_filsys_t *fs, action_on_trans_t action)
void for_each_transaction(reiserfs_filsys_t fs, action_on_trans_t action)
{
reiserfs_trans_t oldest, newest;
int ret = 0;
@@ -419,7 +419,7 @@ __u32 advise_journal_max_trans_age(void)
return JOURNAL_MAX_TRANS_AGE;
}
int reiserfs_journal_params_check(reiserfs_filsys_t *fs)
int reiserfs_journal_params_check(reiserfs_filsys_t fs)
{
struct reiserfs_journal_header *j_head;
struct reiserfs_super_block *sb = fs->fs_ondisk_sb;
@@ -471,7 +471,7 @@ int reiserfs_journal_params_check(reiserfs_filsys_t *fs)
/* read journal header and make sure that it matches with the filesystem
opened */
int reiserfs_open_journal(reiserfs_filsys_t *fs, char *j_filename, int flags)
int reiserfs_open_journal(reiserfs_filsys_t fs, char *j_filename, int flags)
{
struct reiserfs_super_block *sb;
__u64 count;
@@ -551,7 +551,7 @@ int reiserfs_open_journal(reiserfs_filsys_t *fs, char *j_filename, int flags)
/* initialize super block's journal related fields and journal header fields.
* If len is 0 - make journal of default size */
int reiserfs_create_journal(reiserfs_filsys_t *fs, char *j_device, /* journal device name */
int reiserfs_create_journal(reiserfs_filsys_t fs, char *j_device, /* journal device name */
unsigned long offset, /* journal offset on the j_device */
unsigned long len, /* including journal header */
int transaction_max_size, int force)
@@ -744,7 +744,7 @@ int reiserfs_create_journal(reiserfs_filsys_t *fs, char *j_device, /* journal de
/* brelse journal header, flush all dirty buffers, close device, open, read
journal header */
void reiserfs_reopen_journal(reiserfs_filsys_t *fs, int flag)
void reiserfs_reopen_journal(reiserfs_filsys_t fs, int flag)
{
unsigned long jh_block;
@@ -772,19 +772,19 @@ void reiserfs_reopen_journal(reiserfs_filsys_t *fs, int flag)
die("reiserfs_reopen_journal: reading journal header failed");
}
int reiserfs_journal_opened(reiserfs_filsys_t *fs)
int reiserfs_journal_opened(reiserfs_filsys_t fs)
{
return fs->fs_jh_bh ? 1 : 0;
}
void reiserfs_flush_journal(reiserfs_filsys_t *fs)
void reiserfs_flush_journal(reiserfs_filsys_t fs)
{
if (!reiserfs_journal_opened(fs))
return;
flush_buffers(fs->fs_journal_dev);
}
void reiserfs_free_journal(reiserfs_filsys_t *fs)
void reiserfs_free_journal(reiserfs_filsys_t fs)
{
if (!reiserfs_journal_opened(fs))
return;
@@ -794,7 +794,7 @@ void reiserfs_free_journal(reiserfs_filsys_t *fs)
fs->fs_j_file_name = NULL;
}
void reiserfs_close_journal(reiserfs_filsys_t *fs)
void reiserfs_close_journal(reiserfs_filsys_t fs)
{
reiserfs_flush_journal(fs);
reiserfs_free_journal(fs);
@@ -802,7 +802,7 @@ void reiserfs_close_journal(reiserfs_filsys_t *fs)
}
/* update journal header */
static void update_journal_header(reiserfs_filsys_t *fs,
static void update_journal_header(reiserfs_filsys_t fs,
struct buffer_head *bh_jh,
reiserfs_trans_t *trans)
{
@@ -820,7 +820,7 @@ static void update_journal_header(reiserfs_filsys_t *fs,
}
/* fixme: what should be done when not all transactions can be replayed in proper order? */
int reiserfs_replay_journal(reiserfs_filsys_t *fs)
int reiserfs_replay_journal(reiserfs_filsys_t fs)
{
struct buffer_head *bh;
struct reiserfs_journal_header *j_head;
reiserfscore/lbalance.c
+2 -2
View File
@@ -1150,7 +1150,7 @@ void leaf_paste_entries(struct buffer_head *bh,
/* wrappers for operations on one separated node */
void delete_item(reiserfs_filsys_t *fs, struct buffer_head *bh, int item_num)
void delete_item(reiserfs_filsys_t fs, struct buffer_head *bh, int item_num)
{
struct buffer_info bi;
@@ -1160,7 +1160,7 @@ void delete_item(reiserfs_filsys_t *fs, struct buffer_head *bh, int item_num)
leaf_delete_items_entirely(&bi, item_num, 1);
}
void cut_entry(reiserfs_filsys_t *fs, struct buffer_head *bh,
void cut_entry(reiserfs_filsys_t fs, struct buffer_head *bh,
int item_num, int entry_num, int del_count)
{
struct buffer_info bi;
reiserfscore/node_formats.c
+14 -14
View File
@@ -344,7 +344,7 @@ char *which_block(int code)
}
/** */
int block_of_journal(reiserfs_filsys_t *fs, unsigned long block)
int block_of_journal(reiserfs_filsys_t fs, unsigned long block)
{
if (!is_reiserfs_jr_magic_string(fs->fs_ondisk_sb)) {
/* standard journal */
@@ -367,7 +367,7 @@ int block_of_journal(reiserfs_filsys_t *fs, unsigned long block)
return 0;
}
int block_of_bitmap(reiserfs_filsys_t *fs, unsigned long block)
int block_of_bitmap(reiserfs_filsys_t fs, unsigned long block)
{
if (spread_bitmaps(fs)) {
if (!(block % (fs->fs_blocksize * 8)))
@@ -384,7 +384,7 @@ int block_of_bitmap(reiserfs_filsys_t *fs, unsigned long block)
}
/* check whether 'block' can be pointed to by an indirect item */
int not_data_block(reiserfs_filsys_t *fs, unsigned long block)
int not_data_block(reiserfs_filsys_t fs, unsigned long block)
{
if (block_of_bitmap(fs, block))
/* it is one of bitmap blocks */
@@ -403,7 +403,7 @@ int not_data_block(reiserfs_filsys_t *fs, unsigned long block)
}
/* check whether 'block' can be logged */
int not_journalable(reiserfs_filsys_t *fs, unsigned long block)
int not_journalable(reiserfs_filsys_t fs, unsigned long block)
{
/* we should not update SB with journal copy during fsck */
if (block < fs->fs_super_bh->b_blocknr)
@@ -420,18 +420,18 @@ int not_journalable(reiserfs_filsys_t *fs, unsigned long block)
// in reiserfs version 0 (undistributed bitmap)
// FIXME: what if number of bitmaps is 15?
unsigned int get_journal_old_start_must(reiserfs_filsys_t *fs)
unsigned int get_journal_old_start_must(reiserfs_filsys_t fs)
{
return (REISERFS_OLD_DISK_OFFSET_IN_BYTES / fs->fs_blocksize) + 1 +
get_sb_bmap_nr(fs->fs_ondisk_sb);
}
unsigned int get_journal_new_start_must(reiserfs_filsys_t *fs)
unsigned int get_journal_new_start_must(reiserfs_filsys_t fs)
{
return (REISERFS_DISK_OFFSET_IN_BYTES / fs->fs_blocksize) + 2;
}
unsigned int get_journal_start_must(reiserfs_filsys_t *fs)
unsigned int get_journal_start_must(reiserfs_filsys_t fs)
{
if (is_old_sb_location(fs->fs_super_bh->b_blocknr, fs->fs_blocksize))
return get_journal_old_start_must(fs);
@@ -456,7 +456,7 @@ __u32 get_bytes_number(struct item_head * ih, int blocksize)
return 0;
}
int check_item_f(reiserfs_filsys_t *fs, struct item_head *ih, char *item);
int check_item_f(reiserfs_filsys_t fs, struct item_head *ih, char *item);
/* ih_key, ih_location and ih_item_len seem correct, check other fields */
static int does_ih_look_correct(struct item_head *ih)
@@ -491,7 +491,7 @@ static int does_ih_look_correct(struct item_head *ih)
/* check item length, ih_free_space for pure 3.5 format, unformatted node
pointers */
static int is_bad_indirect(reiserfs_filsys_t *fs, struct item_head *ih,
static int is_bad_indirect(reiserfs_filsys_t fs, struct item_head *ih,
char *item, check_unfm_func_t check_unfm_func)
{
unsigned int i;
@@ -536,7 +536,7 @@ int known_hashes(void)
(hash_value (hashfn, name, namelen) == GET_HASH_VALUE (deh_offset))
/* this also sets hash function */
int is_properly_hashed(reiserfs_filsys_t *fs,
int is_properly_hashed(reiserfs_filsys_t fs,
char *name, int namelen, __u32 offset)
{
unsigned int i;
@@ -665,7 +665,7 @@ int dir_entry_bad_location(struct reiserfs_de_head *deh, struct item_head *ih,
/* the only corruption which is not considered fatal - is hash mismatching. If
bad_dir is set - directory item having such names is considered bad */
static int is_bad_directory(reiserfs_filsys_t *fs, struct item_head *ih,
static int is_bad_directory(reiserfs_filsys_t fs, struct item_head *ih,
char *item, int bad_dir)
{
int i;
@@ -702,7 +702,7 @@ static int is_bad_directory(reiserfs_filsys_t *fs, struct item_head *ih,
}
/* used by debugreisrefs -p only yet */
int is_it_bad_item(reiserfs_filsys_t *fs, struct item_head *ih, char *item,
int is_it_bad_item(reiserfs_filsys_t fs, struct item_head *ih, char *item,
check_unfm_func_t check_unfm, int bad_dir)
{
int retval;
@@ -1159,7 +1159,7 @@ static int comp_ids(const void *p1, const void *p2)
/* functions to manipulate with super block's objectid map */
int is_objectid_used(reiserfs_filsys_t *fs, __u32 objectid)
int is_objectid_used(reiserfs_filsys_t fs, __u32 objectid)
{
__le32 *objectid_map;
__u32 count = get_sb_oid_cursize(fs->fs_ondisk_sb);
@@ -1183,7 +1183,7 @@ int is_objectid_used(reiserfs_filsys_t *fs, __u32 objectid)
return !(pos & 1);
}
void mark_objectid_used(reiserfs_filsys_t *fs, __u32 objectid)
void mark_objectid_used(reiserfs_filsys_t fs, __u32 objectid)
{
int i;
__le32 *objectid_map;
reiserfscore/prints.c
+11 -11
View File
@@ -272,7 +272,7 @@ static void print_path(struct tree_balance *tb, struct reiserfs_path *path)
}
}
static void print_directory_item(FILE *fp, reiserfs_filsys_t *fs,
static void print_directory_item(FILE *fp, reiserfs_filsys_t fs,
struct buffer_head *bh, struct item_head *ih)
{
int i;
@@ -500,7 +500,7 @@ static int print_internal(FILE * fp, struct buffer_head *bh, int first,
}
static int is_symlink = 0;
static int print_leaf(FILE * fp, reiserfs_filsys_t *fs, struct buffer_head *bh,
static int print_leaf(FILE * fp, reiserfs_filsys_t fs, struct buffer_head *bh,
int print_mode, int first, int last)
{
struct item_head *ih;
@@ -606,7 +606,7 @@ void print_journal_params(FILE * fp, struct journal_params *jp)
}
/* return 1 if this is not super block */
int print_super_block(FILE * fp, reiserfs_filsys_t *fs, char *file_name,
int print_super_block(FILE * fp, reiserfs_filsys_t fs, char *file_name,
struct buffer_head *bh, int short_print)
{
struct reiserfs_super_block *sb =
@@ -730,7 +730,7 @@ int print_super_block(FILE * fp, reiserfs_filsys_t *fs, char *file_name,
return 0;
}
void print_filesystem_state(FILE * fp, reiserfs_filsys_t *fs)
void print_filesystem_state(FILE * fp, reiserfs_filsys_t fs)
{
reiserfs_warning(fp, "\nFilesystem state: ");
if (reiserfs_is_fs_consistent(fs))
@@ -753,7 +753,7 @@ static int print_desc_block(FILE * fp, struct buffer_head *bh)
return 0;
}
void print_block(FILE * fp, reiserfs_filsys_t *fs, struct buffer_head *bh, ...) //int print_mode, int first, int last)
void print_block(FILE * fp, reiserfs_filsys_t fs, struct buffer_head *bh, ...) //int print_mode, int first, int last)
{
va_list args;
int mode, first, last;
@@ -970,7 +970,7 @@ end2:
}
/* read bitmap of disk and print details */
void print_bmap(FILE * fp, reiserfs_filsys_t *fs, int silent)
void print_bmap(FILE * fp, reiserfs_filsys_t fs, int silent)
{
struct reiserfs_super_block *sb;
int bmap_nr;
@@ -1013,7 +1013,7 @@ void print_bmap(FILE * fp, reiserfs_filsys_t *fs, int silent)
}
}
void print_objectid_map(FILE * fp, reiserfs_filsys_t *fs)
void print_objectid_map(FILE * fp, reiserfs_filsys_t fs)
{
int i;
struct reiserfs_super_block *sb;
@@ -1057,7 +1057,7 @@ void print_objectid_map(FILE * fp, reiserfs_filsys_t *fs)
}
void print_journal_header(reiserfs_filsys_t *fs)
void print_journal_header(reiserfs_filsys_t fs)
{
struct reiserfs_journal_header *j_head;
@@ -1073,7 +1073,7 @@ void print_journal_header(reiserfs_filsys_t *fs)
print_journal_params(stdout, &j_head->jh_journal);
}
static void print_trans_element(reiserfs_filsys_t *fs,
static void print_trans_element(reiserfs_filsys_t fs,
reiserfs_trans_t *trans, unsigned int index,
unsigned long in_journal,
unsigned long in_place)
@@ -1087,7 +1087,7 @@ static void print_trans_element(reiserfs_filsys_t *fs,
reiserfs_warning(stdout, "\n");
}
void print_one_transaction(reiserfs_filsys_t *fs, reiserfs_trans_t *trans)
void print_one_transaction(reiserfs_filsys_t fs, reiserfs_trans_t *trans)
{
reiserfs_warning(stdout,
"Mountid %u, transid %u, desc %lu, length %u, commit %lu\n",
@@ -1097,7 +1097,7 @@ void print_one_transaction(reiserfs_filsys_t *fs, reiserfs_trans_t *trans)
}
/* print all valid transactions and found dec blocks */
void print_journal(reiserfs_filsys_t *fs)
void print_journal(reiserfs_filsys_t fs)
{
if (!reiserfs_journal_opened(fs)) {
reiserfs_warning(stderr,
reiserfscore/reiserfslib.c
+35 -35
View File
@@ -54,10 +54,10 @@ int is_block_count_correct(unsigned long journal_offset,
/* read super block. fixme: only 4k blocks, pre-journaled format
is refused. Journal and bitmap are to be opened separately.
skip_check is set to 1 if checks of openned SB should be omitted.*/
reiserfs_filsys_t *reiserfs_open(const char *filename, int flags,
reiserfs_filsys_t reiserfs_open(const char *filename, int flags,
int *error, void *vp, int check)
{
reiserfs_filsys_t *fs;
reiserfs_filsys_t fs;
struct buffer_head *bh;
struct reiserfs_super_block *sb;
int fd;
@@ -184,13 +184,13 @@ found:
/* creates buffer for super block and fills it up with fields which are
constant for given size and version of a filesystem */
reiserfs_filsys_t *reiserfs_create(char *filename,
reiserfs_filsys_t reiserfs_create(char *filename,
int version,
unsigned long block_count,
int block_size,
int default_journal, int new_format)
{
reiserfs_filsys_t *fs;
reiserfs_filsys_t fs;
time_t now;
unsigned int bmap_nr = reiserfs_bmap_nr(block_count, block_size);;
@@ -316,23 +316,23 @@ reiserfs_filsys_t *reiserfs_create(char *filename,
return fs;
}
int no_reiserfs_found(reiserfs_filsys_t *fs)
int no_reiserfs_found(reiserfs_filsys_t fs)
{
return (fs == NULL || fs->fs_blocksize == 0) ? 1 : 0;
}
static int new_format(reiserfs_filsys_t *fs)
static int new_format(reiserfs_filsys_t fs)
{
return fs->fs_super_bh->b_blocknr != 2;
}
int spread_bitmaps(reiserfs_filsys_t *fs)
int spread_bitmaps(reiserfs_filsys_t fs)
{
return fs->fs_super_bh->b_blocknr != 2;
}
/* 0 means: do not guarantee that fs is consistent */
int reiserfs_is_fs_consistent(reiserfs_filsys_t *fs)
int reiserfs_is_fs_consistent(reiserfs_filsys_t fs)
{
if (get_sb_umount_state(fs->fs_ondisk_sb) == FS_CLEANLY_UMOUNTED &&
get_sb_fs_state(fs->fs_ondisk_sb) == FS_CONSISTENT)
@@ -342,7 +342,7 @@ int reiserfs_is_fs_consistent(reiserfs_filsys_t *fs)
/* flush bitmap, brelse super block, flush all dirty buffers, close and open
again the device, read super block */
static void reiserfs_only_reopen(reiserfs_filsys_t *fs, int flag)
static void reiserfs_only_reopen(reiserfs_filsys_t fs, int flag)
{
unsigned long super_block;
@@ -377,13 +377,13 @@ static void reiserfs_only_reopen(reiserfs_filsys_t *fs, int flag)
fs->fs_dirt = 0;
}
void reiserfs_reopen(reiserfs_filsys_t *fs, int flag)
void reiserfs_reopen(reiserfs_filsys_t fs, int flag)
{
reiserfs_only_reopen(fs, flag);
reiserfs_reopen_journal(fs, flag);
}
int is_opened_rw(reiserfs_filsys_t *fs)
int is_opened_rw(reiserfs_filsys_t fs)
{
if ((fs->fs_flags) & O_RDWR)
return 1;
@@ -391,7 +391,7 @@ int is_opened_rw(reiserfs_filsys_t *fs)
}
/* flush all changes made on a filesystem */
void reiserfs_flush(reiserfs_filsys_t *fs)
void reiserfs_flush(reiserfs_filsys_t fs)
{
if (fs->fs_dirt) {
reiserfs_flush_journal(fs);
@@ -401,7 +401,7 @@ void reiserfs_flush(reiserfs_filsys_t *fs)
}
/* free all memory involved into manipulating with filesystem */
void reiserfs_free(reiserfs_filsys_t *fs)
void reiserfs_free(reiserfs_filsys_t fs)
{
reiserfs_free_journal(fs);
reiserfs_free_ondisk_bitmap(fs);
@@ -418,7 +418,7 @@ void reiserfs_free(reiserfs_filsys_t *fs)
}
/* this closes everything: journal. bitmap and the fs itself */
void reiserfs_close(reiserfs_filsys_t *fs)
void reiserfs_close(reiserfs_filsys_t fs)
{
reiserfs_close_journal(fs);
reiserfs_close_ondisk_bitmap(fs);
@@ -428,7 +428,7 @@ void reiserfs_close(reiserfs_filsys_t *fs)
fsync(fs->fs_dev);
}
int reiserfs_new_blocknrs(reiserfs_filsys_t *fs,
int reiserfs_new_blocknrs(reiserfs_filsys_t fs,
unsigned long *free_blocknrs,
unsigned long start, int amount_needed)
{
@@ -439,7 +439,7 @@ int reiserfs_new_blocknrs(reiserfs_filsys_t *fs,
return 0;
}
int reiserfs_free_block(reiserfs_filsys_t *fs, unsigned long block)
int reiserfs_free_block(reiserfs_filsys_t fs, unsigned long block)
{
if (fs->block_deallocator)
return fs->block_deallocator(fs, block);
@@ -447,7 +447,7 @@ int reiserfs_free_block(reiserfs_filsys_t *fs, unsigned long block)
return 0;
}
static int reiserfs_search_by_key_x(reiserfs_filsys_t *fs,
static int reiserfs_search_by_key_x(reiserfs_filsys_t fs,
struct reiserfs_key *key,
struct reiserfs_path *path, int key_length)
{
@@ -496,13 +496,13 @@ static int reiserfs_search_by_key_x(reiserfs_filsys_t *fs,
return ITEM_NOT_FOUND;
}
int reiserfs_search_by_key_3(reiserfs_filsys_t *fs, struct reiserfs_key *key,
int reiserfs_search_by_key_3(reiserfs_filsys_t fs, struct reiserfs_key *key,
struct reiserfs_path *path)
{
return reiserfs_search_by_key_x(fs, key, path, 3);
}
int reiserfs_search_by_key_4(reiserfs_filsys_t *fs, struct reiserfs_key *key,
int reiserfs_search_by_key_4(reiserfs_filsys_t fs, struct reiserfs_key *key,
struct reiserfs_path *path)
{
return reiserfs_search_by_key_x(fs, key, path, 4);
@@ -510,7 +510,7 @@ int reiserfs_search_by_key_4(reiserfs_filsys_t *fs, struct reiserfs_key *key,
/* key is key of byte in the regular file. This searches in tree
through items and in the found item as well */
int reiserfs_search_by_position(reiserfs_filsys_t *s, struct reiserfs_key *key,
int reiserfs_search_by_position(reiserfs_filsys_t s, struct reiserfs_key *key,
int version, struct reiserfs_path *path)
{
struct buffer_head *bh;
@@ -692,7 +692,7 @@ struct reiserfs_key *reiserfs_next_key(struct reiserfs_path *path)
}
/* NOTE: this only should be used to look for keys who exists */
int reiserfs_search_by_entry_key(reiserfs_filsys_t *fs,
int reiserfs_search_by_entry_key(reiserfs_filsys_t fs,
struct reiserfs_key *key,
struct reiserfs_path *path)
{
@@ -795,7 +795,7 @@ int reiserfs_search_by_entry_key(reiserfs_filsys_t *fs,
return POSITION_NOT_FOUND;
}
void init_tb_struct(struct tree_balance *tb, reiserfs_filsys_t *fs,
void init_tb_struct(struct tree_balance *tb, reiserfs_filsys_t fs,
struct reiserfs_path *path, int size)
{
memset(tb, '\0', sizeof(struct tree_balance));
@@ -807,7 +807,7 @@ void init_tb_struct(struct tree_balance *tb, reiserfs_filsys_t *fs,
tb->insert_size[0] = size;
}
int reiserfs_remove_entry(reiserfs_filsys_t *fs, struct reiserfs_key *key)
int reiserfs_remove_entry(reiserfs_filsys_t fs, struct reiserfs_key *key)
{
struct reiserfs_path path;
struct tree_balance tb;
@@ -842,7 +842,7 @@ int reiserfs_remove_entry(reiserfs_filsys_t *fs, struct reiserfs_key *key)
return 0;
}
void reiserfs_paste_into_item(reiserfs_filsys_t *fs,
void reiserfs_paste_into_item(reiserfs_filsys_t fs,
struct reiserfs_path *path, const void *body,
int size)
{
@@ -856,7 +856,7 @@ void reiserfs_paste_into_item(reiserfs_filsys_t *fs,
do_balance(&tb, NULL, body, M_PASTE, 0 /* zero num */ );
}
void reiserfs_insert_item(reiserfs_filsys_t *fs, struct reiserfs_path *path,
void reiserfs_insert_item(reiserfs_filsys_t fs, struct reiserfs_path *path,
struct item_head *ih, const void *body)
{
struct tree_balance tb;
@@ -884,7 +884,7 @@ __u32 hash_value(hashf_t func, char *name, int namelen)
/* if name is found in a directory - return 1 and set path to the name,
otherwise return 0 and pathrelse path */
int reiserfs_locate_entry(reiserfs_filsys_t *fs, struct reiserfs_key *dir,
int reiserfs_locate_entry(reiserfs_filsys_t fs, struct reiserfs_key *dir,
char *name, struct reiserfs_path *path)
{
struct reiserfs_key entry_key;
@@ -947,7 +947,7 @@ int reiserfs_locate_entry(reiserfs_filsys_t *fs, struct reiserfs_key *dir,
found. Stores key found in the entry in 'key'. Returns minimal not used
generation counter in 'min_gen_counter'. dies if found object is not a
directory. */
int reiserfs_find_entry(reiserfs_filsys_t *fs, struct reiserfs_key *dir,
int reiserfs_find_entry(reiserfs_filsys_t fs, struct reiserfs_key *dir,
char *name, unsigned int *min_gen_counter,
struct reiserfs_key *key)
{
@@ -1071,7 +1071,7 @@ static char *make_entry(char *entry, char *name, struct reiserfs_key *key,
/* add new name into a directory. If it exists in a directory - do
nothing */
int reiserfs_add_entry(reiserfs_filsys_t *fs, struct reiserfs_key *dir,
int reiserfs_add_entry(reiserfs_filsys_t fs, struct reiserfs_key *dir,
char *name, int name_len, struct reiserfs_key *key,
__u16 fsck_need)
{
@@ -1154,7 +1154,7 @@ void copy_short_key(void *to, const void *from)
}
/* inserts new or old stat data of a directory (unreachable, nlinks == 0) */
int create_dir_sd(reiserfs_filsys_t *fs,
int create_dir_sd(reiserfs_filsys_t fs,
struct reiserfs_path *path, struct reiserfs_key *key,
void (*modify_item) (struct item_head *, void *))
{
@@ -1195,7 +1195,7 @@ int create_dir_sd(reiserfs_filsys_t *fs,
return key_format;
}
void make_sure_root_dir_exists(reiserfs_filsys_t *fs,
void make_sure_root_dir_exists(reiserfs_filsys_t fs,
void (*modify_item) (struct item_head *, void *),
int ih_flags)
{
@@ -1290,7 +1290,7 @@ int can_we_format_it(char *device_name, int force)
return 1;
}
int create_badblock_bitmap(reiserfs_filsys_t *fs, char *badblocks_file)
int create_badblock_bitmap(reiserfs_filsys_t fs, char *badblocks_file)
{
FILE *fd;
char buf[128];
@@ -1342,7 +1342,7 @@ int create_badblock_bitmap(reiserfs_filsys_t *fs, char *badblocks_file)
return 0;
}
void badblock_list(reiserfs_filsys_t *fs, badblock_func_t action, void *data)
void badblock_list(reiserfs_filsys_t fs, badblock_func_t action, void *data)
{
struct reiserfs_path badblock_path;
struct reiserfs_key rd_key = badblock_key;
@@ -1389,7 +1389,7 @@ void badblock_list(reiserfs_filsys_t *fs, badblock_func_t action, void *data)
}
}
static void callback_badblock_rm(reiserfs_filsys_t *fs,
static void callback_badblock_rm(reiserfs_filsys_t fs,
struct reiserfs_path *badblock_path,
void *data)
{
@@ -1409,7 +1409,7 @@ static void callback_badblock_rm(reiserfs_filsys_t *fs,
do_balance(&tb, NULL, NULL, M_DELETE, 0 /* zero num */);
}
void mark_badblock(reiserfs_filsys_t *fs,
void mark_badblock(reiserfs_filsys_t fs,
struct reiserfs_path *badblock_path, void *data)
{
struct item_head *tmp_ih;
@@ -1430,7 +1430,7 @@ void mark_badblock(reiserfs_filsys_t *fs,
pathrelse(badblock_path);
}
void add_badblock_list(reiserfs_filsys_t *fs, int replace)
void add_badblock_list(reiserfs_filsys_t fs, int replace)
{
struct tree_balance tb;
struct reiserfs_path badblock_path;
reiserfscore/stree.c
+4 -4
View File
@@ -189,7 +189,7 @@ const struct reiserfs_key MAX_KEY =
tree), and in this case we return a special key, either MIN_KEY or
MAX_KEY. */
static const struct reiserfs_key *get_lkey(const struct reiserfs_path *p_s_chk_path,
const reiserfs_filsys_t *fs)
const reiserfs_filsys_t fs)
{
struct reiserfs_super_block *sb;
int n_position, n_path_offset = p_s_chk_path->path_length;
@@ -228,7 +228,7 @@ static const struct reiserfs_key *get_lkey(const struct reiserfs_path *p_s_chk_p
/* Get delimiting key of the buffer at the path and its right neighbor. */
const struct reiserfs_key *get_rkey(const struct reiserfs_path *p_s_chk_path,
const reiserfs_filsys_t *fs)
const reiserfs_filsys_t fs)
{
struct reiserfs_super_block *sb;
int n_position, n_path_offset = p_s_chk_path->path_length;
@@ -273,7 +273,7 @@ const struct reiserfs_key *get_rkey(const struct reiserfs_path *p_s_chk_path,
which is MIN_KEY or MAX_KEY. */
static inline int key_in_buffer(const struct reiserfs_path *p_s_chk_path, /* Path which should be checked. */
const struct reiserfs_key *p_s_key, /* Key which should be checked. */
reiserfs_filsys_t *fs /* Super block pointer. */
reiserfs_filsys_t fs /* Super block pointer. */
)
{
@@ -317,7 +317,7 @@ void pathrelse(struct reiserfs_path *p_s_search_path)
key. search_by_key returns a path that must 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 */
int search_by_key(reiserfs_filsys_t *fs, struct reiserfs_key *p_s_key, /* Key to search */
int search_by_key(reiserfs_filsys_t fs, struct reiserfs_key *p_s_key, /* Key to search */
struct reiserfs_path *p_s_search_path, /* This structure was
allocated and
initialized by the
resize_reiserfs/do_shrink.c
+5 -5
View File
@@ -20,7 +20,7 @@ static reiserfs_bitmap_t *bmp;
static struct reiserfs_super_block *ondisk_sb;
/* abnornal exit from block reallocation process */
static void quit_resizer(reiserfs_filsys_t *fs)
static void quit_resizer(reiserfs_filsys_t fs)
{
/* save changes to bitmap blocks */
reiserfs_close(fs);
@@ -30,7 +30,7 @@ static void quit_resizer(reiserfs_filsys_t *fs)
}
/* block moving */
static unsigned long move_generic_block(reiserfs_filsys_t *fs,
static unsigned long move_generic_block(reiserfs_filsys_t fs,
unsigned long block,
unsigned long bnd, int h)
{
@@ -87,7 +87,7 @@ static unsigned long move_generic_block(reiserfs_filsys_t *fs,
return unused_block;
}
static unsigned long move_unformatted_block(reiserfs_filsys_t *fs,
static unsigned long move_unformatted_block(reiserfs_filsys_t fs,
unsigned long block,
unsigned long bnd, int h)
{
@@ -100,7 +100,7 @@ static unsigned long move_unformatted_block(reiserfs_filsys_t *fs,
}
/* recursive function processing all tree nodes */
static unsigned long move_formatted_block(reiserfs_filsys_t *fs,
static unsigned long move_formatted_block(reiserfs_filsys_t fs,
unsigned long block,
unsigned long bnd, int h)
{
@@ -189,7 +189,7 @@ static unsigned long move_formatted_block(reiserfs_filsys_t *fs,
return new_blocknr;
}
int shrink_fs(reiserfs_filsys_t *fs, long long int blocks)
int shrink_fs(reiserfs_filsys_t fs, long long int blocks)
{
unsigned long n_root_block;
unsigned int bmap_nr_new;
resize_reiserfs/resize.h
+1 -1
View File
@@ -44,4 +44,4 @@ extern int opt_safe;
extern int resize_fs_online(char *devname, long long int blocks);
/* do_shrink.c */
extern int shrink_fs(reiserfs_filsys_t *, long long int blocks);
extern int shrink_fs(reiserfs_filsys_t , long long int blocks);
resize_reiserfs/resize_reiserfs.c
+3 -3
View File
@@ -88,7 +88,7 @@ static int bwrite_cond(struct buffer_head *bh)
}
/* the first one of the most important functions */
static int expand_fs(reiserfs_filsys_t *fs, long long int block_count_new)
static int expand_fs(reiserfs_filsys_t fs, long long int block_count_new)
{
unsigned int bmap_nr_new, bmap_nr_old;
struct reiserfs_super_block *sb;
@@ -138,7 +138,7 @@ static int expand_fs(reiserfs_filsys_t *fs, long long int block_count_new)
return 0;
}
static int resizer_check_fs_size(reiserfs_filsys_t *fs, long long int new_size)
static int resizer_check_fs_size(reiserfs_filsys_t fs, long long int new_size)
{
if (new_size < 0) {
reiserfs_warning(stderr, "\nresizer_reiserfs: the new size "
@@ -187,7 +187,7 @@ int main(int argc, char *argv[])
char *bytes_count_str = NULL;
char *devname;
char *jdevice_name = NULL;
reiserfs_filsys_t *fs;
reiserfs_filsys_t fs;
struct reiserfs_super_block *sb;
int c;
tune/tune.c
+7 -7
View File
@@ -83,7 +83,7 @@ static unsigned char UUID[16];
static char *badblocks_file;
/* If specified paramenters defines the standard journal, make it standard. */
static int should_make_journal_standard(reiserfs_filsys_t *fs,
static int should_make_journal_standard(reiserfs_filsys_t fs,
char *j_new_dev_name)
{
if (!is_reiserfs_jr_magic_string(fs->fs_ondisk_sb))
@@ -126,7 +126,7 @@ static int should_make_journal_standard(reiserfs_filsys_t *fs,
return 1;
}
static int set_standard_journal_params(reiserfs_filsys_t *fs)
static int set_standard_journal_params(reiserfs_filsys_t fs)
{
struct buffer_head *bh;
@@ -193,7 +193,7 @@ static int set_standard_journal_params(reiserfs_filsys_t *fs)
return 1;
}
static void zero_journal(reiserfs_filsys_t *fs)
static void zero_journal(reiserfs_filsys_t fs)
{
unsigned int i;
struct buffer_head *bh;
@@ -285,7 +285,7 @@ static void set_time_last_checked(char *str)
print_usage_and_exit();
}
static void callback_new_badblocks(reiserfs_filsys_t *fs,
static void callback_new_badblocks(reiserfs_filsys_t fs,
struct reiserfs_path *badblock_path,
void *data)
{
@@ -310,7 +310,7 @@ static void callback_new_badblocks(reiserfs_filsys_t *fs,
pathrelse(badblock_path);
}
static void callback_clear_badblocks(reiserfs_filsys_t *fs,
static void callback_clear_badblocks(reiserfs_filsys_t fs,
struct reiserfs_path *badblock_path,
void *data)
{
@@ -328,7 +328,7 @@ static void callback_clear_badblocks(reiserfs_filsys_t *fs,
pathrelse(badblock_path);
}
static void add_badblocks(reiserfs_filsys_t *fs)
static void add_badblocks(reiserfs_filsys_t fs)
{
unsigned long i, marked = 0;
@@ -389,7 +389,7 @@ static void add_badblocks(reiserfs_filsys_t *fs)
int main(int argc, char **argv)
{
reiserfs_filsys_t *fs;
reiserfs_filsys_t fs;
char *device_name;
char *jdevice_name;
char *j_new_device_name;