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

Imported reiserfsprogs-3.6.19

Browse Source
This commit is contained in:
Jeff Mahoney committed 2012-10-11 11:31:31 -04:00
1 parent 3078c83c48
commit 0ed773997f
34 files changed
+724 -560
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

ChangeLog
+17
View File
@@ -1,3 +1,20 @@
2004-10-13
3.6.19 release.
2004-09-22
Some bug fixes:
- stop handling directory item if it has been removed on fsck pass0
- handle correctly cases when hash functions return 0
- additional check for wrong order of hashes when generation counters
differ.
2004-08-18
{get|set}_unaligned macroses fix for broken powerpc linux kernel
headers.
2004-08-18
Patches from Jeff Mahoney:
- warnings cleanups
- sd_blocks check fix for quota
- make fsck -a works quitely
- fix the definition of BLKGETSIZE64
2004-08-03
3.6.18 release.
2004-06-18
configure
Vendored
+1 -1
View File
@@ -1605,7 +1605,7 @@ fi
# Define the identity of the package.
PACKAGE=reiserfsprogs
VERSION=3.6.18
VERSION=3.6.19
cat >>confdefs.h <<_ACEOF
configure.in
+1 -1
View File
@@ -6,7 +6,7 @@ AC_PREREQ(2.50)
AH_TEMPLATE([HAVE_LIBUUID], [Define for enable libuuid using.])
AH_TEMPLATE([ENABLE_DEBUG], [Define for enable debug info.])
AM_INIT_AUTOMAKE(reiserfsprogs, 3.6.18)
AM_INIT_AUTOMAKE(reiserfsprogs, 3.6.19)
AM_MAINTAINER_MODE
dnl We install in /sbin, the utils are to be available on boot
debugreiserfs/corruption.c
+5 -5
View File
@@ -728,7 +728,7 @@ void do_leaves_corruption (reiserfs_filsys_t * fs,
}
if (reiserfs_open_ondisk_bitmap (fs) < 0)
reiserfs_panic ("Could not open ondisk bitmap");
reiserfs_exit (1, "Could not open ondisk bitmap");
for (i = 0; (i < get_sb_block_count (fs->fs_ondisk_sb)) &&
nr_leaves < nr_leaves_cr; i ++) {
@@ -853,7 +853,7 @@ void do_ih_random_corrupt (reiserfs_filsys_t * fs,
}
if (reiserfs_open_ondisk_bitmap (fs) < 0)
reiserfs_panic ("Could not open ondisk bitmap");
reiserfs_exit (1, "Could not open ondisk bitmap");
for (i = 0; (i < get_sb_block_count (fs->fs_ondisk_sb)) &&
nr_leaves < nr_leaves_cr; i ++) {
@@ -960,7 +960,7 @@ void do_dir_random_corrupt (reiserfs_filsys_t * fs,
}
if (reiserfs_open_ondisk_bitmap (fs) < 0)
reiserfs_panic ("Could not open ondisk bitmap");
reiserfs_exit (1, "Could not open ondisk bitmap");
for (i = 0; (i < get_sb_block_count (fs->fs_ondisk_sb)) &&
nr_leaves < nr_leaves_cr; i ++) {
@@ -1041,7 +1041,7 @@ void do_sd_random_corrupt (reiserfs_filsys_t * fs,
}
if (reiserfs_open_ondisk_bitmap (fs) < 0)
reiserfs_panic ("Could not open ondisk bitmap");
reiserfs_exit (1, "Could not open ondisk bitmap");
for (i = 0; (i < get_sb_block_count (fs->fs_ondisk_sb)) &&
nr_leaves < nr_leaves_cr; i ++) {
@@ -1122,7 +1122,7 @@ void do_ind_random_corrupt (reiserfs_filsys_t * fs,
}
if (reiserfs_open_ondisk_bitmap (fs) < 0)
reiserfs_panic ("Could not open ondisk bitmap");
reiserfs_exit (1, "Could not open ondisk bitmap");
for (i = 0; (i < get_sb_block_count (fs->fs_ondisk_sb)) &&
nr_leaves < nr_leaves_cr; i ++) {
debugreiserfs/debugreiserfs.8
+1 -1
View File
@@ -1,7 +1,7 @@
.\" -*- nroff -*-
.\" Copyright 1996-2004 Hans Reiser.
.\"
.TH DEBUGREISERFS 8 "February 2004" "Reiserfsprogs 3.6.18"
.TH DEBUGREISERFS 8 "February 2004" "Reiserfsprogs 3.6.19"
.SH NAME
debugreiserfs \- The debugging tool for the ReiserFS filesystem.
.SH SYNOPSIS
debugreiserfs/debugreiserfs.c
+353 -332
View File
@@ -45,6 +45,7 @@ Options:\n\
-J\tsearch block numbers in the journal\n\
-t\tstat the device\n\
-v\tverboes unpack, prints the block number of every block being unpacked\n\
-Z\tzero all data.
To build a map of a file blocks by name:
debugreiserfs device -a mapfile -n filename
@@ -73,55 +74,59 @@ static void print_disk_tree (reiserfs_filsys_t * fs, unsigned long block_nr)
static int level = -1;
if (level == -1)
level = get_sb_tree_height (fs->fs_ondisk_sb);
level = get_sb_tree_height (fs->fs_ondisk_sb);
bh = bread (fs->fs_dev, block_nr, fs->fs_blocksize);
if (!bh) {
die ("Could not read block %lu\n", block_nr);
die ("Could not read block %lu\n", block_nr);
}
level --;
if (level < 1)
die ("level too small");
die ("level too small");
if (level != get_blkh_level (B_BLK_HEAD (bh))) {
printf ("%d expected, %d found in %lu\n", level, get_blkh_level (B_BLK_HEAD (bh)),
bh->b_blocknr);
printf ("%d expected, %d found in %lu\n", level,
get_blkh_level (B_BLK_HEAD (bh)), bh->b_blocknr);
}
if (is_internal_node (bh)) {
struct disk_child * dc;
struct disk_child * dc;
g_stat_info.nr_internals ++;
print_block (stdout, fs, bh, data (fs)->options & PRINT_TREE_DETAILS, -1, -1);
g_stat_info.nr_internals ++;
print_block (stdout, fs, bh,
data(fs)->options & PRINT_TREE_DETAILS, -1, -1);
dc = B_N_CHILD (bh, 0);
count = B_NR_ITEMS(bh);
for (i = 0; i <= count; i++, dc++)
print_disk_tree (fs, get_dc_child_blocknr (dc));
dc = B_N_CHILD (bh, 0);
count = B_NR_ITEMS(bh);
for (i = 0; i <= count; i++, dc++)
print_disk_tree (fs, get_dc_child_blocknr (dc));
} else if (is_leaf_node (bh)) {
struct item_head *ih;
g_stat_info.nr_leaves ++;
print_block (stdout, fs, bh, data (fs)->options & PRINT_TREE_DETAILS, -1, -1);
ih = B_N_PITEM_HEAD (bh, 0);
count = leaf_item_number_estimate(bh);
for (i = 0; i < count; i++, ih++) {
if (is_indirect_ih(ih)) {
__u32 * ind_item = (__u32 *)B_I_PITEM (bh, ih);
for (j = 0; j < (int)I_UNFM_NUM (ih); j ++) {
if (d32_get (ind_item, j)) {
g_stat_info.nr_unformatted += 1;
}
}
}
}
struct item_head *ih;
g_stat_info.nr_leaves ++;
print_block (stdout, fs, bh,
data (fs)->options & PRINT_TREE_DETAILS, -1, -1);
ih = B_N_PITEM_HEAD (bh, 0);
count = leaf_item_number_estimate(bh);
for (i = 0; i < count; i++, ih++) {
if (is_indirect_ih(ih)) {
__u32 * ind_item = (__u32 *)B_I_PITEM (bh, ih);
for (j = 0; j < (int)I_UNFM_NUM (ih); j ++) {
if (d32_get (ind_item, j)) {
g_stat_info.nr_unformatted += 1;
}
}
}
}
} else {
print_block (stdout, fs, bh, data (fs)->options & PRINT_TREE_DETAILS, -1, -1);
reiserfs_warning (stdout, "print_disk_tree: bad block type (%b)\n", bh);
print_block (stdout, fs, bh,
data (fs)->options & PRINT_TREE_DETAILS, -1, -1);
reiserfs_warning (stdout, "print_disk_tree: bad block "
"type (%b)\n", bh);
}
brelse (bh);
level ++;
@@ -149,8 +154,12 @@ static void print_disk_blocks (reiserfs_filsys_t * fs)
}
type = who_is_this (bh->b_data, bh->b_size);
if (type != THE_UNKNOWN)
print_block (stdout, fs, bh, PRINT_TREE_DETAILS | PRINT_DIRECT_ITEMS, -1, -1);
if (type != THE_UNKNOWN) {
print_block (stdout, fs, bh,
PRINT_TREE_DETAILS | PRINT_DIRECT_ITEMS,
-1, -1);
}
if (type == THE_INTERNAL)
g_stat_info.nr_internals ++;
else if (type == THE_LEAF || type == HAS_IH_ARRAY)
@@ -172,44 +181,52 @@ static void print_one_block (reiserfs_filsys_t * fs, unsigned long block)
unsigned long bm_block;
if (spread_bitmaps (fs))
bm_block = ( block / (fs->fs_blocksize * 8) ) ?
(block / (fs->fs_blocksize * 8)) * (fs->fs_blocksize * 8) :
bm_block =
( block / (fs->fs_blocksize * 8) ) ?
(block / (fs->fs_blocksize * 8)) *
(fs->fs_blocksize * 8) :
fs->fs_super_bh->b_blocknr + 1;
else
bm_block = fs->fs_super_bh->b_blocknr + 1 + (block / (fs->fs_blocksize * 8));
bm_block = fs->fs_super_bh->b_blocknr + 1 +
(block / (fs->fs_blocksize * 8));
bm_bh = bread (fs->fs_dev, bm_block, fs->fs_blocksize);
if (bm_bh) {
if ( misc_test_bit((block % (fs->fs_blocksize * 8)), bm_bh->b_data) )
fprintf (stderr, "%lu is used in ondisk bitmap\n", block);
else
fprintf (stderr, "%lu is free in ondisk bitmap\n", block);
if (misc_test_bit((block % (fs->fs_blocksize * 8)),
bm_bh->b_data))
{
fprintf (stderr, "%lu is used in "
"ondisk bitmap\n", block);
} else {
fprintf (stderr, "%lu is free in "
"ondisk bitmap\n", block);
}
brelse (bm_bh);
}
} else {
if (reiserfs_bitmap_test_bit (fs->fs_bitmap2, block))
fprintf (stderr, "%lu is used in ondisk bitmap\n", block);
fprintf (stderr, "%lu is used in ondisk bitmap\n", block);
else
fprintf (stderr, "%lu is free in ondisk bitmap\n", block);
fprintf (stderr, "%lu is free in ondisk bitmap\n", block);
}
bh = bread (fs->fs_dev, block, fs->fs_blocksize);
if (!bh) {
printf ("print_one_block: bread failed\n");
return;
printf ("print_one_block: bread failed\n");
return;
}
if (debug_mode (fs) == DO_PACK) {
pack_one_block (fs, bh->b_blocknr);
brelse (bh);
return;
pack_one_block (fs, bh->b_blocknr);
brelse (bh);
return;
}
if (who_is_this (bh->b_data, bh->b_size) != THE_UNKNOWN)
print_block (stdout, fs, bh, PRINT_TREE_DETAILS, -1, -1);
print_block (stdout, fs, bh, PRINT_TREE_DETAILS, -1, -1);
else
printf ("Looks like unformatted\n");
printf ("Looks like unformatted\n");
brelse (bh);
return;
}
@@ -225,7 +242,8 @@ char * badblocks_file;
char * corruption_list_file;
char *program_name;
static char * parse_options (struct debugreiserfs_data * data, int argc, char * argv [])
static char * parse_options (struct debugreiserfs_data * data,
int argc, char * argv [])
{
int c;
char * tmp;
@@ -240,161 +258,166 @@ static char * parse_options (struct debugreiserfs_data * data, int argc, char *
else
program_name = argv[ 0 ];
while ((c = getopt (argc, argv, "a:b:C:F:SU1:pkn:Nfr:dDomj:JqtZl:LVB:uv")) != EOF) {
switch (c) {
case 'a': /* -r will read this, -n and -N will write to it */
asprintf (&data->map_file, "%s", optarg);
break;
case 'b':
/* will load bitmap from a file and read only blocks
marked in it. This is for -p and -k */
asprintf (&data->input_bitmap, "%s", optarg);
data->scan_area = EXTERN_BITMAP;
break;
case 'S':
/* have debugreiserfs -p or -k to read all the device */
data->scan_area = ALL_BLOCKS;
break;
case 'U':
/* have debugreiserfs -p or -k to read unused blocks only */
data->scan_area = UNUSED_BLOCKS;
break;
case '1': /* print a single node */
data->block = strtol (optarg, &tmp, 0);
if (*tmp)
die ("parse_options: bad block number");
break;
case 'C':
data->mode = DO_CORRUPT_ONE;
data->block = strtol (optarg, &tmp, 0);
if (*tmp) {
die ("parse_options: bad block number");
}
break;
case 'F':
data->mode = DO_CORRUPT_FILE;
if (asprintf (&corruption_list_file, "%s", optarg) == -1 ) {
die ("parse_options: bad list corruption file");
}
break;
case 'p':
data->mode = DO_PACK;
break;
case 'u':
data->mode = DO_UNPACK;
break;
while ((c = getopt (argc, argv, "a:b:C:F:SU1:pkn:Nfr:dDomj:JqtZl:LVB:uv"))
!= EOF)
{
switch (c) {
case 'a': /* -r will read this, -n and -N will write to it */
asprintf (&data->map_file, "%s", optarg);
break;
case 't':
data->mode = DO_STAT;
break;
case 'k':
/* read the device and print reiserfs blocks which contain defined key */
data->mode = DO_SCAN;
break;
case 'n': /* scan for names matching a specified pattern */
data->mode = DO_SCAN_FOR_NAME;
data->pattern = optarg;
/*asprintf (&data->pattern, "%s", optarg);*/
break;
case 'N': /* search name in the tree */
data->mode = DO_LOOK_FOR_NAME;
break;
case 'f':
data->mode = DO_FILE_MAP;
break;
case 'b':
/* will load bitmap from a file and read only blocks
marked in it. This is for -p and -k */
asprintf (&data->input_bitmap, "%s", optarg);
data->scan_area = EXTERN_BITMAP;
break;
case 'r':
asprintf (&data->recovery_file, "%s", optarg);
data->mode = DO_RECOVER;
break;
case 'S':
/* have debugreiserfs -p or -k to read all the device */
data->scan_area = ALL_BLOCKS;
break;
case 'd':
/* print leaf details from internal tree */
data->options |= PRINT_TREE_DETAILS;
break;
case 'D':
/* print leaf details accordingly the bitmap - can be used with -S */
data->options |= PRINT_DETAILS;
break;
case 'o':
/* print objectid map */
data->options |= PRINT_OBJECTID_MAP;
break;
case 'm': /* print a block map */
case 'M': /* print a block map with details */
data->options |= PRINT_BITMAP;
break;
case 'j': /* -j must have a parameter */
data->options |= PRINT_JOURNAL;
data->journal_device_name = optarg;
break;
case 'J':
data->options |= PRINT_JOURNAL_HEADER;
break;
case 'R': /* read block numbers from stdin and look for them in the
journal */
data->mode = DO_SCAN_JOURNAL;
data->JJ ++;
break;
case 'B': /*disabled for a while*/
asprintf (&badblocks_file, "%s", optarg);
data->mode = DO_EXTRACT_BADBLOCKS;
break;
case 'q':
/* this makes packing to not show speed info during -p or -P */
data->options |= BE_QUIET;
break;
case 'Z':
data->mode = DO_ZERO_BITMAP;
break;
case 'l': /* --logfile */
data->log_file_name = optarg;
data->log = fopen (optarg, "w");
if (!data->log)
fprintf (stderr, "debugreiserfs: Cannot not open \'%s\': %s",
optarg, strerror(errno));
break;
case 'L' :
/* random fs corruption */
data->mode = DO_RANDOM_CORRUPTION;
break;
case 'V':
data->mode = DO_NOTHING;
break;
case 'v':
data->options |= BE_VERBOSE;
break;
}
case 'U':
/* have debugreiserfs -p or -k to read unused blocks only */
data->scan_area = UNUSED_BLOCKS;
break;
case '1': /* print a single node */
data->block = strtol (optarg, &tmp, 0);
if (*tmp)
die ("parse_options: bad block number");
break;
case 'C':
data->mode = DO_CORRUPT_ONE;
data->block = strtol (optarg, &tmp, 0);
if (*tmp) {
die ("parse_options: bad block number");
}
break;
case 'F':
data->mode = DO_CORRUPT_FILE;
if (asprintf (&corruption_list_file, "%s", optarg) == -1 ) {
die ("parse_options: bad list corruption file");
}
break;
case 'p':
data->mode = DO_PACK;
break;
case 'u':
data->mode = DO_UNPACK;
break;
case 't':
data->mode = DO_STAT;
break;
case 'k':
/* read the device and print reiserfs blocks which contain
defined key */
data->mode = DO_SCAN;
break;
case 'n': /* scan for names matching a specified pattern */
data->mode = DO_SCAN_FOR_NAME;
data->pattern = optarg;
/*asprintf (&data->pattern, "%s", optarg);*/
break;
case 'N': /* search name in the tree */
data->mode = DO_LOOK_FOR_NAME;
break;
case 'f':
data->mode = DO_FILE_MAP;
break;
case 'r':
asprintf (&data->recovery_file, "%s", optarg);
data->mode = DO_RECOVER;
break;
case 'd':
/* print leaf details from internal tree */
data->options |= PRINT_TREE_DETAILS;
break;
case 'D':
/* print leaf details accordingly the bitmap - can be used
with -S */
data->options |= PRINT_DETAILS;
break;
case 'o':
/* print objectid map */
data->options |= PRINT_OBJECTID_MAP;
break;
case 'm': /* print a block map */
case 'M': /* print a block map with details */
data->options |= PRINT_BITMAP;
break;
case 'j': /* -j must have a parameter */
data->options |= PRINT_JOURNAL;
data->journal_device_name = optarg;
break;
case 'J':
data->options |= PRINT_JOURNAL_HEADER;
break;
case 'R': /* read block numbers from stdin and look for them in the
journal */
data->mode = DO_SCAN_JOURNAL;
data->JJ ++;
break;
case 'B': /*disabled for a while*/
asprintf (&badblocks_file, "%s", optarg);
data->mode = DO_EXTRACT_BADBLOCKS;
break;
case 'q':
/* this makes packing to not show speed info during -p or -P */
data->options |= BE_QUIET;
break;
case 'Z':
data->mode = DO_ZERO;
break;
case 'l': /* --logfile */
data->log_file_name = optarg;
data->log = fopen (optarg, "w");
if (!data->log) {
fprintf (stderr, "debugreiserfs: Cannot not open "
"\'%s\': %s", optarg, strerror(errno));
}
break;
case 'L' :
/* random fs corruption */
data->mode = DO_RANDOM_CORRUPTION;
break;
case 'V':
data->mode = DO_NOTHING;
break;
case 'v':
data->options |= BE_VERBOSE;
break;
}
}
if (data->mode == DO_NOTHING) {
print_banner(program_name);
exit(0);
print_banner(program_name);
exit(0);
}
if (optind != argc - 1)
/* only one non-option argument is permitted */
print_usage_and_exit();
/* only one non-option argument is permitted */
print_usage_and_exit();
print_banner(program_name);
@@ -407,9 +430,9 @@ void pack_partition (reiserfs_filsys_t * fs);
static void do_pack (reiserfs_filsys_t * fs)
{
if (certain_block (fs))
pack_one_block (fs, certain_block (fs));
pack_one_block (fs, certain_block (fs));
else
pack_partition (fs);
pack_partition (fs);
}
/*
@@ -434,51 +457,49 @@ static void init_bitmap (reiserfs_filsys_t * fs)
if (reiserfs_open_ondisk_bitmap (fs) < 0)
reiserfs_panic ("Could not open ondisk bitmap");
reiserfs_exit (1, "Could not open ondisk bitmap");
block_count = get_sb_block_count (fs->fs_ondisk_sb);
switch (scan_area (fs)) {
case ALL_BLOCKS:
input_bitmap (fs) = reiserfs_create_bitmap (block_count);
reiserfs_bitmap_fill (input_bitmap (fs));
reiserfs_warning (stderr, "Whole device (%d blocks) is to be scanned\n",
reiserfs_bitmap_ones (input_bitmap (fs)));
break;
input_bitmap (fs) = reiserfs_create_bitmap (block_count);
reiserfs_bitmap_fill (input_bitmap (fs));
reiserfs_warning (stderr, "Whole device (%d blocks) is to be scanned\n",
reiserfs_bitmap_ones (input_bitmap (fs)));
break;
case USED_BLOCKS:
reiserfs_warning (stderr, "Loading on-disk bitmap .. ");
input_bitmap (fs) = reiserfs_create_bitmap (block_count);
reiserfs_bitmap_copy (input_bitmap (fs), fs->fs_bitmap2);
reiserfs_warning (stderr, "%d bits set - done\n",
reiserfs_bitmap_ones (input_bitmap (fs)));
break;
reiserfs_warning (stderr, "Loading on-disk bitmap .. ");
input_bitmap (fs) = reiserfs_create_bitmap (block_count);
reiserfs_bitmap_copy (input_bitmap (fs), fs->fs_bitmap2);
reiserfs_warning (stderr, "%d bits set - done\n",
reiserfs_bitmap_ones (input_bitmap (fs)));
break;
case UNUSED_BLOCKS:
reiserfs_warning (stderr, "Loading on-disk bitmap .. ");
input_bitmap (fs) = reiserfs_create_bitmap (block_count);
reiserfs_bitmap_copy (input_bitmap (fs), fs->fs_bitmap2);
reiserfs_bitmap_invert (input_bitmap (fs));
reiserfs_warning (stderr, "%d bits set - done\n",
reiserfs_bitmap_ones (input_bitmap (fs)));
break;
reiserfs_warning (stderr, "Loading on-disk bitmap .. ");
input_bitmap (fs) = reiserfs_create_bitmap (block_count);
reiserfs_bitmap_copy (input_bitmap (fs), fs->fs_bitmap2);
reiserfs_bitmap_invert (input_bitmap (fs));
reiserfs_warning (stderr, "%d bits set - done\n",
reiserfs_bitmap_ones (input_bitmap (fs)));
break;
case EXTERN_BITMAP:
fp = fopen (input_bitmap_file_name(fs), "r");
if (!fp)
reiserfs_panic ("init_bitmap: could not load bitmap: %m\n");
input_bitmap (fs) = reiserfs_bitmap_load (fp);
if (!input_bitmap (fs))
reiserfs_panic ("could not load fitmap from \"%s\"",
input_bitmap_file_name(fs));
reiserfs_warning (stderr, "%d blocks marked in the given bitmap\n",
reiserfs_bitmap_ones (input_bitmap (fs)));
fclose (fp);
break;
fp = fopen (input_bitmap_file_name(fs), "r");
if (!fp) {
reiserfs_exit (1, "init_bitmap: could not load bitmap: %m\n");
}
input_bitmap (fs) = reiserfs_bitmap_load (fp);
if (!input_bitmap (fs)) {
reiserfs_exit (1, "could not load fitmap from \"%s\"",
input_bitmap_file_name(fs));
}
reiserfs_warning (stderr, "%d blocks marked in the given bitmap\n",
reiserfs_bitmap_ones (input_bitmap (fs)));
fclose (fp);
break;
default:
reiserfs_panic ("No area to scan specified");
reiserfs_panic ("No area to scan specified");
}
}
@@ -486,17 +507,20 @@ static void init_bitmap (reiserfs_filsys_t * fs)
static void do_dump_tree (reiserfs_filsys_t * fs)
{
if (certain_block (fs)) {
print_one_block (fs, certain_block (fs));
return;
print_one_block (fs, certain_block (fs));
return;
}
if (data (fs)->options & PRINT_JOURNAL || data (fs)->options & PRINT_JOURNAL_HEADER) {
if (!reiserfs_journal_opened (fs) &&
reiserfs_open_journal (fs, data (fs)->journal_device_name, O_RDONLY))
{
printf ("Could not open journal\n");
return;
}
if (((data (fs)->options & PRINT_JOURNAL) ||
(data (fs)->options & PRINT_JOURNAL_HEADER)) &&
!reiserfs_journal_opened (fs))
{
if (reiserfs_open_journal (fs, data(fs)->journal_device_name,
O_RDONLY))
{
printf ("Could not open journal\n");
return;
}
}
print_filesystem_state (stdout, fs);
@@ -517,19 +541,24 @@ static void do_dump_tree (reiserfs_filsys_t * fs)
if (data (fs)->options & PRINT_DETAILS)
init_bitmap (fs);
if (data (fs)->options & PRINT_DETAILS || data (fs)->options & PRINT_TREE_DETAILS) {
if (data (fs)->options & PRINT_DETAILS) {
print_disk_blocks (fs);
printf("The '%s' device with reiserfs has:\n", fs->fs_file_name);
} else {
print_disk_tree (fs, get_sb_root_block (fs->fs_ondisk_sb));
printf("The internal reiserfs tree has:\n");
}
/* print the statistic */
printf ("\t%d internal + %d leaves + %d unformatted nodes = %d blocks\n",
g_stat_info.nr_internals, g_stat_info.nr_leaves, g_stat_info.nr_unformatted,
g_stat_info.nr_internals + g_stat_info.nr_leaves + g_stat_info.nr_unformatted);
if (data (fs)->options & PRINT_DETAILS ||
data (fs)->options & PRINT_TREE_DETAILS)
{
if (data (fs)->options & PRINT_DETAILS) {
print_disk_blocks (fs);
printf("The '%s' device with reiserfs has:\n",
fs->fs_file_name);
} else {
print_disk_tree (fs, get_sb_root_block(fs->fs_ondisk_sb));
printf("The internal reiserfs tree has:\n");
}
/* print the statistic */
printf ("\t%d internal + %d leaves + %d "
"unformatted nodes = %d blocks\n",
g_stat_info.nr_internals, g_stat_info.nr_leaves,
g_stat_info.nr_unformatted, g_stat_info.nr_internals +
g_stat_info.nr_leaves + g_stat_info.nr_unformatted);
}
}
@@ -555,9 +584,8 @@ void extract_badblock_list () {
FILE *fd;
if (!(fd = fopen (badblocks_file, "w"))) {
reiserfs_warning (stderr, "debugreiserfs: could not open badblock file %s\n",
badblocks_file);
exit (1);
reiserfs_exit(1, "debugreiserfs: could not open badblock file %s\n",
badblocks_file);
}
badblock_list(fs, callback_badblock_print, fd);
@@ -586,9 +614,8 @@ void do_corrupt_blocks (reiserfs_filsys_t * fs)
fd = fopen (corruption_list_file, "r");
if (fd == NULL) {
reiserfs_warning (stderr, "debugreiserfs: could not open corruption_list_file %s\n",
corruption_list_file);
exit (1);
reiserfs_exit(1, "debugreiserfs: could not open corruption "
"list file %s\n", corruption_list_file);
}
while (1) {
@@ -615,7 +642,7 @@ void do_corrupt_blocks (reiserfs_filsys_t * fs)
return;
}
void zero_bitmap_blocks(reiserfs_filsys_t * fs) {
void debugreiserfs_zero_reiserfs(reiserfs_filsys_t * fs) {
unsigned long done, total, i;
struct buffer_head * bh;
@@ -647,6 +674,7 @@ void zero_bitmap_blocks(reiserfs_filsys_t * fs) {
fflush(stderr);
}
/* FIXME: need to open reiserfs filesystem first */
int main (int argc, char * argv[])
{
@@ -666,93 +694,86 @@ int main (int argc, char * argv[])
fs = reiserfs_open (file_name, O_RDONLY, &error, data, 0);
if (no_reiserfs_found (fs)) {
fprintf (stderr, "\n\ndebugreiserfs: can not open reiserfs on \"%s\": %s\n\n",
file_name, error ? strerror (error) : "no filesystem found");
exit(1) ;
reiserfs_exit (1, "\n\ndebugreiserfs: can not open reiserfs on "
"\"%s\": %s\n\n", file_name, error ? strerror(error)
: "no filesystem found");
exit(1) ;
}
if (reiserfs_open_journal (fs, data (fs)->journal_device_name, O_RDONLY)) {
fprintf(stderr, "\ndebugreiserfs: Failed to open the fs journal.\n");
fprintf(stderr,"\ndebugreiserfs: Failed to open the fs journal.\n");
}
switch (debug_mode (fs)) {
case DO_STAT:
init_bitmap (fs);
do_stat (fs);
break;
init_bitmap (fs);
do_stat (fs);
break;
case DO_PACK:
init_bitmap (fs);
do_pack (fs);
break;
init_bitmap (fs);
do_pack (fs);
break;
case DO_CORRUPT_ONE:
reiserfs_reopen (fs, O_RDWR);
do_corrupt_one_block (fs, (char *)NULL);
break;
reiserfs_reopen (fs, O_RDWR);
do_corrupt_one_block (fs, (char *)NULL);
break;
case DO_CORRUPT_FILE:
reiserfs_reopen (fs, O_RDWR);
do_corrupt_blocks (fs);
break;
case DO_RANDOM_CORRUPTION:
reiserfs_reopen (fs, O_RDWR);
/*
do_leaves_corruption (fs);
do_bitmap_corruption (fs);
*/
do_fs_random_corrupt (fs);
break;
reiserfs_reopen (fs, O_RDWR);
do_corrupt_blocks (fs);
break;
case DO_RANDOM_CORRUPTION:
reiserfs_reopen (fs, O_RDWR);
/*
do_leaves_corruption (fs);
do_bitmap_corruption (fs);
*/
do_fs_random_corrupt (fs);
break;
case DO_DUMP:
do_dump_tree (fs);
break;
do_dump_tree (fs);
break;
case DO_SCAN:
case DO_SCAN_FOR_NAME:
case DO_LOOK_FOR_NAME:
case DO_SCAN_JOURNAL:
init_bitmap (fs);
do_scan (fs);
break;
init_bitmap (fs);
do_scan (fs);
break;
case DO_FILE_MAP:
print_map(fs);
break;
print_map(fs);
break;
case DO_RECOVER:
do_recover (fs);
break;
do_recover (fs);
break;
case DO_TEST:
/*do_test (fs);*/
break;
/*do_test (fs);*/
break;
case DO_EXTRACT_BADBLOCKS:
reiserfs_warning (stderr, "Will try to extract list of bad blocks and "
"save it to '%s' file\n", badblocks_file);
extract_badblock_list ();
reiserfs_warning (stderr, "Done\n\n");
break;
reiserfs_warning (stderr, "Will try to extract list of bad blocks "
"and save it to '%s' file\n", badblocks_file);
extract_badblock_list ();
reiserfs_warning (stderr, "Done\n\n");
break;
case DO_ZERO:
init_bitmap (fs);
debugreiserfs_zero_reiserfs(fs);
break;
}
reiserfs_close (fs);
if (data(fs)->log) {
fclose (data(fs)->log);
fclose (data(fs)->log);
}
return 0;
}
/*
Local variables:
c-indentation-style: "K&R"
mode-name: "LC"
c-basic-offset: 4
tab-width: 4
fill-column: 80
End:
*/
debugreiserfs/debugreiserfs.h
+1 -1
View File
@@ -39,7 +39,7 @@ extern reiserfs_filsys_t * fs;
#define DO_SCAN_JOURNAL 13 /* -J */
#define DO_EXTRACT_BADBLOCKS 14
#define DO_FILE_MAP 15
#define DO_ZERO_BITMAP 16
#define DO_ZERO 16
#define DO_NOTHING 17
debugreiserfs/scan.c
+3 -2
View File
@@ -792,8 +792,9 @@ static void make_map(const void *nodep, VISIT value, int level) {
if (fp == 0) {
fp = fopen (file_name, "w+");
if (!fp)
reiserfs_panic ("could open %s: %m", file_name);
if (!fp) {
reiserfs_exit (1, "could open %s: %m", file_name);
}
}
}
debugreiserfs/stat.c
+5 -3
View File
@@ -241,11 +241,13 @@ void do_stat (reiserfs_filsys_t * fs)
return;
fp = fopen (input_bitmap_file_name(fs), "w");
if (!fp)
reiserfs_panic ("stat: could not open %s to save bitmap: %m\n",
input_bitmap_file_name(fs));
if (!fp) {
reiserfs_exit (1, "could not open %s to save bitmap: %m\n",
input_bitmap_file_name(fs));
}
reiserfs_warning (stderr, "Updated bitmap contains %d blocks marked\n",
reiserfs_bitmap_ones (input_bitmap (fs)));
reiserfs_bitmap_save (fp, input_bitmap (fs));
fclose (fp);
return;
debugreiserfs/unpack.c
+1 -2
View File
@@ -128,8 +128,7 @@ static void unpack_direntry (struct packed_item * pi, struct buffer_head * bh,
/* old or new ".." */
set_deh_offset (deh, DOT_DOT_OFFSET);
else if (hash_func)
set_deh_offset (deh, GET_HASH_VALUE (hash_func (item + location,
namelen)));
set_deh_offset (deh, hash_value(hash_func, item + location, namelen));
if (mask & HAS_GEN_COUNTER) {
fread_le16 (&gen_counter);
set_deh_offset (deh, get_deh_offset (deh) | gen_counter);
fsck/check_tree.c
+22 -4
View File
@@ -541,8 +541,8 @@ static int bad_directory_item (reiserfs_filsys_t * fs,
struct buffer_head * bh,
struct item_head * ih)
{
char * name;
int namelen;
char *name, *prev_name;
__u32 off, prev_off;
unsigned int count, i;
struct reiserfs_de_head * deh = B_I_DEH (bh, ih);
int min_entry_size = 1;/* We have no way to understand whether the
@@ -550,6 +550,7 @@ static int bad_directory_item (reiserfs_filsys_t * fs,
converted to it. So, we assume that minimal name
length is 1 */
__u16 state;
int namelen;
count = get_ih_entry_count (ih);
@@ -580,17 +581,34 @@ static int bad_directory_item (reiserfs_filsys_t * fs,
}
/* check name hashing */
prev_name = B_I_PITEM(bh, ih) + get_ih_item_len(ih);
prev_off = 0;
for (i = 0; i < count; i ++, deh ++) {
namelen = name_in_entry_length (ih, deh, i);
name = name_in_entry (deh, i);
if (!is_properly_hashed (fs, name, namelen, get_deh_offset (deh))) {
off = get_deh_offset (deh);
if (namelen > (int)REISERFS_MAX_NAME_LEN(fs->fs_blocksize) ||
name >= prev_name || off <= prev_off)
{
fsck_log ("%s: block %lu: The directory item %k has a broken entry "
"(%d)\n", __FUNCTION__, bh->b_blocknr, &ih->ih_key, i);
one_more_corruption (fs, FATAL);
return 1;
}
if (!is_properly_hashed (fs, name, namelen, off)) {
fsck_log ("%s: block %lu: The directory item %k has a not properly "
"hashed entry (%d)\n", __FUNCTION__, bh->b_blocknr,
&ih->ih_key, i);
one_more_corruption (fs, FATAL);
one_more_corruption (fs, FATAL);
return 1;
}
prev_name = name;
prev_off = off;
}
deh = B_I_DEH (bh, ih);
fsck/main.c
+27 -19
View File
@@ -228,6 +228,7 @@ static char * parse_options (struct fsck_data * data, int argc, char * argv [])
case 'a':
case 'p':
data->options |= OPT_QUIET;
mode = FSCK_AUTO;
break;
@@ -673,7 +674,8 @@ static void mark_filesystem_consistent (reiserfs_filsys_t * fs)
if (!reiserfs_journal_opened (fs)) {
/* make sure journal is not standard */
if (!is_reiserfs_jr_magic_string (fs->fs_ondisk_sb))
die ("Filesystem with default journal must be opened.");
reiserfs_exit(EXIT_OPER, "Filesystem with default journal "
"must be opened.");
fsck_progress ("WARNING: You must use reiserfstune to specify a new "
"journal before mounting it.\n");
@@ -785,13 +787,17 @@ static void prepare_fs_for_check(reiserfs_filsys_t * fs) {
/* If not CHECK mode, lock the process in the memory. */
if (fsck_mode (fs) != FSCK_CHECK) {
if (mlockall(MCL_CURRENT)) {
reiserfs_warning (stderr, "Failed to lock the process to "
"fsck the mounted ro partition. %s.\n",
strerror(errno));
exit(EXIT_OPER);
reiserfs_exit(EXIT_OPER, "Failed to lock the process to "
"fsck the mounted ro partition. %s.\n",
strerror(errno));
}
}
if (fsck_skip_journal (fs)) {
reiserfs_exit(EXIT_USER, "Jounrnal of the mounted "
"filesystem must be specified.\n");
}
if (!reiserfs_journal_opened (fs)) {
/* just to make sure */
reiserfs_panic ("Journal is not opened");
@@ -879,7 +885,7 @@ static void clean_attributes (reiserfs_filsys_t * fs) {
time (&t);
if (get_sb_umount_state (fs->fs_ondisk_sb) != FS_CLEANLY_UMOUNTED) {
fsck_progress ("Filesystem does not look cleanly umounted\n"
fsck_progress ("Filesystem is not clean\n"
"Check consistency of the partition first.\n");
exit(EXIT_USER);
}
@@ -1227,8 +1233,9 @@ int main (int argc, char * argv [])
'fsck.run'. Logs get there if log file was not specified*/
data->options |= OPT_QUIET;
data->progress = fopen ("fsck.run", "a+");
if (!data->progress)
reiserfs_panic ("reiserfsck: Cannot not open \"fsck.run\"");
if (!data->progress) {
reiserfs_exit(EXIT_OPER, "reiserfsck: Cannot not open \"fsck.run\"");
}
if (data->log == stdout)
/* no log file specifed - redirect log into 'fsck.run' */
@@ -1255,19 +1262,20 @@ int main (int argc, char * argv [])
} else {
fs = reiserfs_open (file_name, O_RDONLY, &error, data,
data->mode != FSCK_SB);
if (error) {
reiserfs_exit(EXIT_OPER, "Failed to open the device "
"'%s': %s\n\n", file_name, strerror(error));
}
if (data->mode != FSCK_SB) {
if (no_reiserfs_found (fs)) {
if (error) {
die ("Failed to open the device '%s': %s\n\n",
file_name, strerror(error));
} else {
die ("Failed to open the filesystem.\n\n"
"If the partition table has not been changed, and the partition is\n"
"valid and it really contains a reiserfs partition, then the\n"
"superblock is corrupted and you need to run this utility with\n"
"--rebuild-sb.\n");
}
reiserfs_exit(EXIT_OPER, "Failed to open the filesystem.\n\n"
"If the partition table has not been changed, "
"and the partition is\nvalid and it really "
"contains a reiserfs partition, then the\n"
"superblock is corrupted and you need to run "
"this utility with\n--rebuild-sb.\n");
}
if (fsck_skip_journal (fs) &&
!is_reiserfs_jr_magic_string (fs->fs_ondisk_sb))
fsck/pass0.c
+25 -11
View File
@@ -365,8 +365,7 @@ static int verify_directory_item (reiserfs_filsys_t * fs, struct buffer_head * b
hash_code = 0;
for (j = min_length; j <= max_length; j ++) {
hash_code = find_hash_in_use (name, j,
GET_HASH_VALUE (get_deh_offset (deh + i)),
hash_code = find_hash_in_use (name, j, get_deh_offset (deh + i),
get_sb_hash_code (fs->fs_ondisk_sb));
/* add_hash_hit (fs, hash_code);*/
if (code2func (hash_code) != 0) {
@@ -527,9 +526,11 @@ static int verify_directory_item (reiserfs_filsys_t * fs, struct buffer_head * b
}
}
if (bad == get_ih_entry_count (&tmp) && lost_found != bad) {
fsck_log ("%s: block %lu, item %H: All entries were deleted from the directory\n",
__FUNCTION__, bh->b_blocknr, &tmp);
if (bad == get_ih_entry_count (&tmp)) {
if (lost_found != bad) {
fsck_log ("%s: block %lu, item %H: All entries were deleted from the directory\n",
__FUNCTION__, bh->b_blocknr, &tmp);
}
return -1;
}
@@ -586,6 +587,9 @@ int leaf_structure_check (reiserfs_filsys_t * fs, struct buffer_head * bh) {
return 1;
}
if (get_blkh_nr_items (blkh) == 0)
return 0;
counted = leaf_count_ih(bh->b_data, bh->b_size);
if (counted < get_blkh_nr_items (blkh)) {
@@ -1770,12 +1774,19 @@ static void init_source_bitmap (reiserfs_filsys_t * fs)
case EXTERN_BITMAP:
fp = fopen (fsck_data (fs)->rebuild.bitmap_file_name, "r");
if (!fp)
reiserfs_panic ("Could not load bitmap: %s\n", strerror(errno));
if (!fp) {
reiserfs_exit (EXIT_OPER, "Could not load bitmap: %s\n",
strerror(errno));
}
fsck_source_bitmap (fs) = reiserfs_bitmap_load (fp);
if (!fsck_source_bitmap (fs))
reiserfs_panic ("Could not load fitmap from \"%s\"",
fsck_data (fs)->rebuild.bitmap_file_name);
if (!fsck_source_bitmap (fs)) {
reiserfs_exit (EXIT_OPER, "Could not load fitmap from \"%s\"",
fsck_data (fs)->rebuild.bitmap_file_name);
}
fsck_progress ("%d blocks marked used in extern bitmap\n",
reiserfs_bitmap_ones (fsck_source_bitmap (fs)));
fclose (fp);
@@ -1967,7 +1978,10 @@ 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)
reiserfs_panic ("pass 0: ReiserFS format version mismatch found, you should run --rebuild-sb");
{
reiserfs_exit (EXIT_OPER, "pass 0: ReiserFS format version mismatch "
"found, you should run --rebuild-sb");
}
fsck_progress ("\nPass 0:\n");
if (fsck_log_file (fs) != stderr)
fsck/pass1.c
+19 -2
View File
@@ -349,11 +349,13 @@ static void pass1_correct_leaf (reiserfs_filsys_t * fs,
for (i = 0; i < B_NR_ITEMS (bh); i ++, ih ++) {
if (is_direntry_ih (ih)) {
struct reiserfs_de_head * deh;
__u32 offset;
char * name;
int name_len;
unsigned int hash_code;
deh = B_I_DEH (bh, ih);
offset = 0;
for (j = 0; j < get_ih_entry_count (ih); j ++) {
name = name_in_entry (deh + j, j);
name_len = name_in_entry_length (ih, deh + j, j);
@@ -363,8 +365,7 @@ static void pass1_correct_leaf (reiserfs_filsys_t * fs,
continue;
}
hash_code = find_hash_in_use (name, name_len,
GET_HASH_VALUE (get_deh_offset (deh + j)),
hash_code = find_hash_in_use (name, name_len, get_deh_offset (deh + j),
get_sb_hash_code (fs->fs_ondisk_sb));
if (hash_code != get_sb_hash_code (fs->fs_ondisk_sb)) {
fsck_log ("pass1: block %lu, item %d, entry %d: The entry \"%.*s\" of the %k is hashed with %s "
@@ -381,8 +382,24 @@ static void pass1_correct_leaf (reiserfs_filsys_t * fs,
fsck_log(" - deleted\n");
j --;
deh = B_I_DEH (bh, ih);
continue;
}
}
if (j && offset >= get_deh_offset (deh + j)) {
fsck_log ("pass1: block %lu, item %d, entry %d: The entry "
"\"%.*s\" of the %k has hash offset %lu not "
"larger smaller than the previous one %lu. The "
"entry is deleted.\n", bh->b_blocknr,
i, j, name_len, name, &ih->ih_key,
get_deh_offset(deh + j), offset);
cut_entry (fs, bh, i, j, 1);
j --;
deh = B_I_DEH (bh, ih);
continue;
}
offset = get_deh_offset (deh + j);
}
continue;
}
fsck/reiserfsck.8
+1 -1
View File
@@ -1,7 +1,7 @@
.\" -*- nroff -*-
.\" Copyright 1996-2004 Hans Reiser.
.\"
.TH REISERFSCK 8 "February 2004" "Reiserfsprogs-3.6.18"
.TH REISERFSCK 8 "February 2004" "Reiserfsprogs-3.6.19"
.SH NAME
reiserfsck \- The checking tool for the ReiserFS filesystem.
.SH SYNOPSIS
fsck/semantic_rebuild.c
+2 -1
View File
@@ -172,7 +172,8 @@ int wrong_st_blocks (struct key * key, __u32 * blocks, __u32 sd_blocks, __u16 mo
int ret = 0;
if (S_ISREG (mode) || S_ISLNK (mode) || S_ISDIR (mode)) {
if (*blocks != sd_blocks) {
if ((!S_ISLNK(mode) && *blocks != sd_blocks) ||
(S_ISLNK(mode) && *blocks != sd_blocks && (ROUND_UP(*blocks) != sd_blocks))) {
fsck_log ("vpf-10680: The %s %K has the wrong block count in the StatData "
"(%u)%s(%u)\n", S_ISDIR (mode) ? "directory" : S_ISREG (mode) ? "file" : "link", key, sd_blocks,
fsck_mode(fs) == FSCK_CHECK ? ", should be " : " - corrected to ", *blocks);
fsck/super.c
+9 -5
View File
@@ -220,7 +220,8 @@ void rebuild_sb (reiserfs_filsys_t * fs, char * filename, struct fsck_data * dat
fs->fs_blocksize = retval;
}
block_count = count_blocks (filename, fs->fs_blocksize);
if (!(block_count = count_blocks (filename, fs->fs_blocksize)))
exit(EXIT_OPER);
/* save ondisk_sb somewhere and work in temp area */
ondisk_sb = fs->fs_ondisk_sb;
@@ -358,7 +359,8 @@ void rebuild_sb (reiserfs_filsys_t * fs, char * filename, struct fsck_data * dat
retval = 4096;
}
block_count = count_blocks (filename, retval);
if (!(block_count = count_blocks (filename, retval)))
exit(EXIT_OPER);
switch(version){
case 1:
@@ -601,8 +603,8 @@ void rebuild_sb (reiserfs_filsys_t * fs, char * filename, struct fsck_data * dat
}
if (!reiserfs_journal_opened(fs)) {
fsck_log ("Journal cannot be opened, assuming specified journal device "
"is correct\n");
fsck_log ("Journal cannot be opened, assuming specified "
"journal device is correct\n");
}
}
@@ -629,7 +631,9 @@ void rebuild_sb (reiserfs_filsys_t * fs, char * filename, struct fsck_data * dat
} else
set_jp_journal_1st_block (sb_jp(sb), default_value);
p_jp_dev_size = count_blocks (journal_dev_name, fs->fs_blocksize);
if (!(p_jp_dev_size = count_blocks (journal_dev_name, fs->fs_blocksize)))
exit(EXIT_OPER);
/* some checks for journal offset */
if (strcmp(fs->fs_file_name, journal_dev_name) != 0) {
if (p_jp_dev_size < get_jp_journal_1st_block (sb_jp(sb)) + 1)
include/reiserfs_fs.h
+8
View File
@@ -40,6 +40,14 @@
#include <asm/unaligned.h>
#ifndef get_unaligned
#if defined(__ppc__) || defined(ppc) || defined(__ppc) || \
defined(__PPC) || defined(powerpc) || defined(__powerpc__)
# define get_unaligned(ptr) (*(ptr))
# define put_unaligned(val,ptr) ((void)(*(ptr) = (val)))
#endif
#endif
#define get_leXX(xx,p,field) (le##xx##_to_cpu ((p)->field))
#define set_leXX(xx,p,field,val) do { (p)->field = cpu_to_le##xx(val); } while (0)
include/reiserfs_lib.h
+3 -2
View File
@@ -135,6 +135,8 @@ int comp_keys_3 (const void * k1, const void * k2);
int comp_short_keys (const void * p_s_key1, const void * p_s_key2);
int comp_items (struct item_head * p_s_ih, struct path * p_s_path);
__u32 hash_value (hashf_t func, char * name, int namelen);
int create_dir_sd (reiserfs_filsys_t * fs,
struct path * path, struct key * key,
void (*modify_item)(struct item_head *, void *));
@@ -279,7 +281,7 @@ char *code2name (unsigned int code);
int func2code (hashf_t func);
hashf_t code2func (unsigned int code);
hashf_t name2func (char * hash);
int find_hash_in_use (char * name, int namelen, __u32 hash_value_masked, unsigned int code_to_try_first);
int find_hash_in_use (char * name, int namelen, __u32 deh_offset, unsigned int code_to_try_first);
int entry_length (struct item_head * ih, struct reiserfs_de_head * deh,
int pos_in_item);
@@ -385,7 +387,6 @@ int can_we_format_it (char * device_name, int force);
#define reiserfs_exit(val, fmt, list...) \
{\
fflush (stdout);\
fprintf (stderr, "%s %d %s\n", __FILE__, __LINE__, __FUNCTION__);\
reiserfs_warning (stderr, (const char *)fmt, ## list);\
reiserfs_warning (stderr, "\n" );\
exit (val);\
lib/io.c
+17 -11
View File
@@ -408,7 +408,8 @@ struct buffer_head * getblk (int dev, unsigned long block, int size)
if (buffers_memory >= buffer_soft_limit) {
if (sync_buffers (&Buffer_list_head, dev, 32) == 0) {
grow_buffers(size);
buffer_soft_limit = buffers_memory + GROW_BUFFERS__NEW_BUFERS_PER_CALL * size;
buffer_soft_limit = buffers_memory +
GROW_BUFFERS__NEW_BUFERS_PER_CALL * size;
}
} else {
if (grow_buffers(size) == 0)
@@ -418,7 +419,8 @@ struct buffer_head * getblk (int dev, unsigned long block, int size)
bh = get_free_buffer (&g_free_buffers, size);
if (bh == NULL) {
show_buffers (dev, size);
die ("getblk: no free buffers after grow_buffers and refill (%d)", g_nr_buffers);
die ("getblk: no free buffers after grow_buffers "
"and refill (%d)", g_nr_buffers);
}
}
@@ -499,19 +501,20 @@ struct buffer_head * bread (int dev, unsigned long block, size_t size)
ret = f_read(bh);
if (ret > 0)
die ("%s: End of file, cannot read the block (%lu).\n", __FUNCTION__, block);
else if (ret < 0) {
if (ret > 0) {
die ("%s: End of file, cannot read the block (%lu).\n",
__FUNCTION__, block);
} else if (ret < 0) {
/* BAD BLOCK LIST SUPPORT
* die ("%s: Cannot read a block # %lu. Specify list of badblocks\n",*/
if (errno == EIO) {
check_hd_msg();
die ("%s: Cannot read the block (%lu): (%s).\n", __FUNCTION__,
block, strerror(errno));
die ("%s: Cannot read the block (%lu): (%s).\n",
__FUNCTION__, block, strerror(errno));
} else {
fprintf (stderr, "%s: Cannot read the block (%lu): (%s).\n", __FUNCTION__,
block, strerror(errno));
fprintf (stderr, "%s: Cannot read the block (%lu): (%s).\n",
__FUNCTION__, block, strerror(errno));
return NULL;
}
}
@@ -904,11 +907,14 @@ static void check_and_free_buffer_mem (void)
count += _check_and_free_buffer_list(g_free_buffers);
if (count != g_nr_buffers)
die ("check_and_free_buffer_mem: found %d buffers, must be %d", count, g_nr_buffers);
die ("check_and_free_buffer_mem: found %d buffers, must be %d",
count, g_nr_buffers);
/* free buffer heads */
while ((next = g_buffer_heads)) {
g_buffer_heads = *(struct buffer_head **)(next + GROW_BUFFERS__NEW_BUFERS_PER_CALL);
g_buffer_heads = *(struct buffer_head **)
(next + GROW_BUFFERS__NEW_BUFERS_PER_CALL);
freemem (next);
}
lib/misc.c
+11 -3
View File
@@ -462,7 +462,13 @@ void print_how_far (FILE * fp,
}
#if defined(__linux__) && defined(_IOR) && !defined(BLKGETSIZE64)
# define BLKGETSIZE64 _IOR(0x12, 114, __u64)
/* Note! Despite this call being called with *64, it must be encoded to
* return only sizeof(size_t), since in earlier kernel versions it was
* declared _IOR(0x12, 114, sizeof(u64)), making it use sizeof(sizeof(u64)).
*
* However, the call itself does always return 64bit!
*/
# define BLKGETSIZE64 _IOR(0x12, 114, size_t)
#endif
/* To not have problem with last sectors on the block device when switching
@@ -500,8 +506,10 @@ unsigned long count_blocks (char * filename, int blocksize)
return 0;
fd = open (filename, O_RDONLY);
if (fd == -1)
die ("count_blocks: open failed (%s)", strerror (errno));
if (fd == -1) {
fprintf(stderr, "Failed to open '%s': %s.\n", filename, strerror(errno));
return 0;
}
#ifdef BLKGETSIZE64
{
mkreiserfs/mkreiserfs.8
+1 -1
View File
@@ -1,7 +1,7 @@
.\" -*- nroff -*-
.\" Copyright 1996-2004 Hans Reiser.
.\"
.TH MKREISERFS 8 "February 2004" "Reiserfsprogs-3.6.18"
.TH MKREISERFS 8 "February 2004" "Reiserfsprogs-3.6.19"
.SH NAME
mkreiserfs \- The create tool for the Linux ReiserFS filesystem.
.SH SYNOPSIS
mkreiserfs/mkreiserfs.c
+83 -70
View File
@@ -149,8 +149,9 @@ static void invalidate_other_formats (int dev)
struct buffer_head * bh;
bh = bread (dev, 0, 64 * 1024);
if (!bh)
die ("Unable to read first blocks of the device");
if (!bh) {
reiserfs_exit(1, "Unable to read first blocks of the device");
}
#if defined(__sparc__) || defined(__sparc_v9__)
memset (bh->b_data + 1024, 0, bh->b_size - 1024);
#else
@@ -178,8 +179,9 @@ void zero_journal (reiserfs_filsys_t * fs)
for (i = 0; i < len; i ++) {
print_how_far (stdout, &done, len, 1, 1/*be quiet*/);
bh = getblk (fs->fs_journal_dev, start + i, fs->fs_blocksize);
if (!bh)
die ("zero_journal: getblk failed");
if (!bh) {
reiserfs_exit(1, "zero_journal: getblk failed");
}
memset (bh->b_data, 0, bh->b_size);
mark_buffer_dirty (bh);
mark_buffer_uptodate (bh, 1);
@@ -194,8 +196,7 @@ 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;
unsigned long block;
@@ -222,31 +223,31 @@ static void make_bitmap (reiserfs_filsys_t * fs)
block = fs->fs_super_bh->b_blocknr + 1;
for (i = 0; i < get_sb_bmap_nr (sb); i ++) {
reiserfs_bitmap_set_bit (fs->fs_bitmap2, block);
marked ++;
if (spread_bitmaps (fs))
block = (block / (fs->fs_blocksize * 8) + 1) *
(fs->fs_blocksize * 8);
else
block ++;
reiserfs_bitmap_set_bit (fs->fs_bitmap2, block);
marked ++;
if (spread_bitmaps (fs))
block = (block / (fs->fs_blocksize * 8) + 1) *
(fs->fs_blocksize * 8);
else
block ++;
}
if (!get_size_of_journal_or_reserved_area (fs->fs_ondisk_sb))
/* root block follows directly super block and first bitmap */
block = fs->fs_super_bh->b_blocknr + 1 + 1;
if (!get_size_of_journal_or_reserved_area (fs->fs_ondisk_sb))
/* root block follows directly super block and first bitmap */
block = fs->fs_super_bh->b_blocknr + 1 + 1;
else {
/* makr journal blocks as used */
for (i = 0; i <= get_jp_journal_size (sb_jp (sb)); i ++) {
reiserfs_bitmap_set_bit (fs->fs_bitmap2,
i + get_jp_journal_1st_block (sb_jp (sb)));
marked ++;
}
block = get_jp_journal_1st_block (sb_jp (sb)) + i;
/* makr journal blocks as used */
for (i = 0; i <= get_jp_journal_size (sb_jp (sb)); i ++) {
reiserfs_bitmap_set_bit (fs->fs_bitmap2,
i + get_jp_journal_1st_block (sb_jp (sb)));
marked ++;
}
block = get_jp_journal_1st_block (sb_jp (sb)) + i;
}
/*get correct block - not journal nor bitmap*/
while (block_of_journal (fs, block) || block_of_bitmap (fs, block)) {
block++;
block++;
}
while ((block < get_sb_block_count (sb)) &&
@@ -256,7 +257,7 @@ static void make_bitmap (reiserfs_filsys_t * fs)
}
if (block >= get_sb_block_count (sb))
die ("mkreiserfs: too many bad blocks");
reiserfs_exit(1, "mkreiserfs: too many bad blocks");
reiserfs_bitmap_set_bit (fs->fs_bitmap2, block);
marked ++;
@@ -286,8 +287,10 @@ static void make_root_block (reiserfs_filsys_t * fs)
sb = fs->fs_ondisk_sb;
/* get memory for root block */
bh = getblk (fs->fs_dev, get_sb_root_block (sb), get_sb_block_size (sb));
if (!bh)
die ("make_root_block: getblk failed");
if (!bh) {
reiserfs_exit(1, "getblk failed");
}
mark_buffer_uptodate (bh, 1);
@@ -295,7 +298,6 @@ static void make_root_block (reiserfs_filsys_t * fs)
make_sure_root_dir_exists (fs, set_root_dir_nlink, 0);
brelse (bh);
/**/
mark_objectid_used (fs, REISERFS_ROOT_PARENT_OBJECTID);
mark_objectid_used (fs, REISERFS_ROOT_OBJECTID);
}
@@ -312,74 +314,78 @@ static void report (reiserfs_filsys_t * fs, char * j_filename)
dev_t rdev;
if (!is_any_reiserfs_magic_string (sb))
return;
return;
if (fstat (fs->fs_super_bh->b_dev, &st) == -1) {
/*reiserfs_warning (stderr, "fstat failed: %s\n", strerror(errno));*/
rdev = 0;
/*reiserfs_warning (stderr, "fstat failed: %s\n", strerror(errno));*/
rdev = 0;
} else
rdev = st.st_rdev;
rdev = st.st_rdev;
if (mode & DEBUG_MODE) {
reiserfs_warning (stdout, "Block %lu (0x%x) contains super block. ",
fs->fs_super_bh->b_blocknr, rdev);
reiserfs_warning (stdout, "Block %lu (0x%x) contains super block. ",
fs->fs_super_bh->b_blocknr, rdev);
}
switch (get_reiserfs_format (sb)) {
case REISERFS_FORMAT_3_5:
reiserfs_warning (stdout, " Format 3.5 with ");
break;
reiserfs_warning (stdout, " Format 3.5 with ");
break;
case REISERFS_FORMAT_3_6:
reiserfs_warning (stdout, "Format 3.6 with ");
break;
reiserfs_warning (stdout, "Format 3.6 with ");
break;
}
if (is_reiserfs_jr_magic_string (sb))
reiserfs_warning (stdout, "non-");
reiserfs_warning (stdout, "non-");
reiserfs_warning (stdout, "standard journal\n");
reiserfs_warning (stdout, "Count of blocks on the device: %u\n",
get_sb_block_count (sb));
get_sb_block_count (sb));
reiserfs_warning (stdout, "Number of blocks consumed by mkreiserfs "
"formatting process: %u\n", get_sb_block_count (sb) - get_sb_free_blocks (sb));
"formatting process: %u\n", get_sb_block_count (sb)
- get_sb_free_blocks (sb));
if (mode & DEBUG_MODE)
reiserfs_warning (stdout, "Free blocks: %u\n", get_sb_free_blocks (sb));
reiserfs_warning (stdout, "Free blocks: %u\n",
get_sb_free_blocks (sb));
reiserfs_warning (stdout, "Blocksize: %d\n", get_sb_block_size (sb));
reiserfs_warning (stdout, "Hash function used to sort names: %s\n",
code2name (get_sb_hash_code (sb)));
code2name (get_sb_hash_code (sb)));
if (mode & DEBUG_MODE) {
reiserfs_warning (stdout, "Number of bitmaps: %u\n", get_sb_bmap_nr (sb));
reiserfs_warning (stdout, "Root block: %u\n", get_sb_root_block (sb));
reiserfs_warning (stdout, "Tree height: %d\n", get_sb_tree_height (sb));
reiserfs_warning (stdout, "Objectid map size %d, max %d\n",
get_sb_oid_cursize (sb), get_sb_oid_maxsize (sb));
get_sb_oid_cursize (sb), get_sb_oid_maxsize (sb));
reiserfs_warning (stdout, "Journal parameters:\n");
print_journal_params (stdout, sb_jp (sb));
} else {
if (j_filename && strcmp (j_filename, fs->fs_file_name))
reiserfs_warning (stdout, "Journal Device [0x%x]\n",
get_jp_journal_dev (sb_jp (sb)));
reiserfs_warning (stdout, "Journal Device [0x%x]\n",
get_jp_journal_dev (sb_jp (sb)));
reiserfs_warning (stdout, "Journal Size %u blocks (first block %u)\n",
get_jp_journal_size (sb_jp (sb)) + 1,
get_jp_journal_1st_block (sb_jp (sb)));
get_jp_journal_size (sb_jp (sb)) + 1,
get_jp_journal_1st_block (sb_jp (sb)));
reiserfs_warning (stdout, "Journal Max transaction length %u\n",
get_jp_journal_max_trans_len (sb_jp (sb)));
get_jp_journal_max_trans_len (sb_jp (sb)));
}
if (j_filename && strcmp (j_filename, fs->fs_file_name)) {
reiserfs_warning (stdout, "Space on this device reserved by journal: %u\n",
get_sb_reserved_for_journal (sb));
reiserfs_warning (stdout, "Space on this device reserved by journal: "
"%u\n", get_sb_reserved_for_journal (sb));
}
if (mode & DEBUG_MODE) {
reiserfs_warning (stdout, "Filesystem state 0x%x\n", get_sb_fs_state (sb));
reiserfs_warning (stdout, "sb_version %u\n", get_sb_version (sb));
reiserfs_warning (stdout, "Filesystem state 0x%x\n",
get_sb_fs_state (sb));
reiserfs_warning (stdout, "sb_version %u\n",
get_sb_version (sb));
}
if (get_reiserfs_format (sb) == REISERFS_FORMAT_3_6) {
reiserfs_warning (stdout, "inode generation number: %u\n",
get_sb_v2_inode_generation (sb));
get_sb_v2_inode_generation (sb));
reiserfs_warning (stdout, "UUID: %U\n", sb->s_uuid);
if (strcmp (sb->s_label, ""))
reiserfs_warning (stdout, "LABEL: %s\n", sb->s_label);
reiserfs_warning (stdout, "LABEL: %s\n", sb->s_label);
}
return;
@@ -391,24 +397,25 @@ static void report (reiserfs_filsys_t * fs, char * j_filename)
static void set_hash_function (char * str)
{
if (!strcmp (str, "tea"))
Hash = TEA_HASH;
Hash = TEA_HASH;
else if (!strcmp (str, "rupasov"))
Hash = YURA_HASH;
Hash = YURA_HASH;
else if (!strcmp (str, "r5"))
Hash = R5_HASH;
Hash = R5_HASH;
else
message("wrong hash type specified. Using default");
message("wrong hash type specified. Using default");
}
static void set_reiserfs_version (char * str)
{
if (!strcmp (str, "3.5"))
Format = "3.5";
Format = "3.5";
else {
Format = "3.6";
if (strcmp (str, "3.6"))
message("wrong reiserfs version specified. Using default 3.6 format");
Format = "3.6";
if (strcmp (str, "3.6"))
message("wrong reiserfs version specified. "
"Using default 3.6 format");
}
}
@@ -418,8 +425,12 @@ static int str2int (char * str)
char * tmp;
val = (int) strtol (str, &tmp, 0);
if (*tmp)
die ("%s: strtol is unable to make an integer of %s\n", program_name, str);
if (*tmp) {
reiserfs_exit (1, "%s: strtol is unable to make an integer of %s\n",
program_name, str);
}
return val;
}
@@ -429,8 +440,9 @@ static void set_block_size (char * str, int *b_size)
*b_size = str2int (str);
if (!is_blocksize_correct (*b_size))
die ("%s: wrong blocksize %s specified, only power of 2 from 512-8192 "
"interval are supported", program_name, str);
reiserfs_exit (1, "%s: wrong blocksize %s specified, "
"only power of 2 from 512-8192 interval "
"are supported", program_name, str);
}
@@ -466,7 +478,8 @@ static int is_journal_default (char * name, char * jname, int blocksize)
return 0;
if (Journal_size && Journal_size !=
journal_default_size(REISERFS_DISK_OFFSET_IN_BYTES / blocksize, blocksize) + 1)
journal_default_size(REISERFS_DISK_OFFSET_IN_BYTES / blocksize,
blocksize) + 1)
/* journal size is set and it is not default size */
return 0;
@@ -484,7 +497,6 @@ static int select_format (void)
{
struct utsname sysinfo;
if (Format) {
if (!strcmp (Format, "3.5"))
return REISERFS_FORMAT_3_5;
@@ -661,7 +673,8 @@ int main (int argc, char **argv)
fs_size = str2int (argv[optind + 1]);
} else if (optind == argc - 1) {
/* number of blocks is not specified */
fs_size = count_blocks (device_name, Block_size);
if (!(fs_size = count_blocks (device_name, Block_size)))
exit(1);
} else {
print_usage_and_exit ();
}
reiserfscore/bitmap.c
+14 -7
View File
@@ -253,9 +253,13 @@ static int reiserfs_fetch_ondisk_bitmap (reiserfs_bitmap_t * bm, reiserfs_filsys
if (!bh) {
reiserfs_warning (stderr, "reiserfs_fetch_ondisk_bitmap: "
"bread failed reading bitmap (%lu)\n", block);
bh = getblk (fs->fs_dev, block, fs->fs_blocksize);
if (!bh)
reiserfs_panic ("reiserfs_fetch_ondisk_bitmap: getblk failed");
if (!bh) {
reiserfs_exit (1, "reiserfs_fetch_ondisk_bitmap: "
"getblk failed");
}
memset (bh->b_data, 0xff, bh->b_size);
mark_buffer_uptodate (bh, 1);
}
@@ -341,9 +345,10 @@ int reiserfs_flush_to_ondisk_bitmap (reiserfs_bitmap_t * bm, reiserfs_filsys_t *
while (to_copy) {
/* we bread to make sure that filesystem contains enough blocks */
bh = getblk (fs->fs_dev, block, fs->fs_blocksize);
if (!bh)
reiserfs_panic ("reiserfs_flush_to_ondisk_bitmap: "
"getblk failed for (%lu)\n", block);
if (!bh) {
reiserfs_exit (1, "Getblk failed for (%lu)\n", block);
}
memset (bh->b_data, 0xff, bh->b_size);
mark_buffer_uptodate (bh, 1);
@@ -685,7 +690,8 @@ void reiserfs_free_ondisk_bitmap (reiserfs_filsys_t * fs)
int reiserfs_open_ondisk_bitmap (reiserfs_filsys_t * fs)
{
if (fs->fs_bitmap2)
reiserfs_panic ("%s: bitmap is initiaized already", __FUNCTION__);
reiserfs_panic ("bitmap is initiaized already");
fs->fs_bitmap2 = reiserfs_create_bitmap (get_sb_block_count (fs->fs_ondisk_sb));
if (!fs->fs_bitmap2)
return -1;
@@ -705,7 +711,8 @@ int reiserfs_open_ondisk_bitmap (reiserfs_filsys_t * fs)
int reiserfs_create_ondisk_bitmap (reiserfs_filsys_t * fs)
{
if (fs->fs_bitmap2)
reiserfs_panic ("create: bitmap is initiaized already");
reiserfs_panic ("bitmap is initiaized already");
fs->fs_bitmap2 = reiserfs_create_bitmap (get_sb_block_count (fs->fs_ondisk_sb));
if (!fs->fs_bitmap2)
return 0;
reiserfscore/journal.c
+25 -11
View File
@@ -501,25 +501,37 @@ int reiserfs_open_journal (reiserfs_filsys_t * fs, char * j_filename, int flags)
"specified journal device %s.\nMust be not less than (%lu).\n",
get_jp_journal_size (sb_jp (sb)) + 1, j_filename,
JOURNAL_MIN_SIZE + 1);
close(fs->fs_journal_dev);
return 1;
}
count = count_blocks (j_filename, fs->fs_blocksize);
if (get_jp_journal_1st_block (sb_jp (sb)) + get_jp_journal_size (sb_jp (sb)) + 1 > count) {
reiserfs_warning (stderr, "Detected journal on specified device %s does not fit to "
"the device.\nStart block (%lu) + size (%lu) less than device size (%lu).\n",
j_filename, get_jp_journal_1st_block(sb_jp (sb)),
get_jp_journal_size(sb_jp (sb)) + 1, count);
if (!(count = count_blocks (j_filename, fs->fs_blocksize))) {
close(fs->fs_journal_dev);
return -1;
}
if (get_jp_journal_1st_block (sb_jp (sb)) +
get_jp_journal_size (sb_jp (sb)) + 1 > count)
{
reiserfs_warning (stderr, "Detected journal on specified device %s "
"does not fit to the device.\nStart block (%lu) + "
"size (%lu) less than device size (%lu).\n",
j_filename, get_jp_journal_1st_block(sb_jp (sb)),
get_jp_journal_size(sb_jp (sb)) + 1, count);
close(fs->fs_journal_dev);
return 1;
}
/* read journal header */
fs->fs_jh_bh = bread (fs->fs_journal_dev, get_jp_journal_1st_block (sb_jp (sb))
+ get_jp_journal_size (sb_jp (sb)), fs->fs_blocksize);
fs->fs_jh_bh = bread (fs->fs_journal_dev,
get_jp_journal_1st_block (sb_jp (sb)) +
get_jp_journal_size (sb_jp (sb)),
fs->fs_blocksize);
if (!fs->fs_jh_bh) {
reiserfs_warning (stderr, "reiserfs_open_journal: bread failed reading "
"journal header.\n");
reiserfs_warning (stderr, "reiserfs_open_journal: bread failed "
"reading journal header.\n");
close(fs->fs_journal_dev);
return -1;
}
@@ -574,7 +586,9 @@ int reiserfs_create_journal(
st.st_rdev = 0;
} else {
/* journal is to be on separate device */
blocks = count_blocks (j_device, fs->fs_blocksize);
if (!(blocks = count_blocks (j_device, fs->fs_blocksize)))
return 0;
if (!len) {
/* default size of a journal on a separate device is whole device */
if (blocks < offset) {
reiserfscore/node_formats.c
+9 -8
View File
@@ -528,7 +528,7 @@ int known_hashes (void)
#define good_name(hashfn,name,namelen,deh_offset) \
(GET_HASH_VALUE ((hashfn) (name, namelen)) == GET_HASH_VALUE (deh_offset))
(hash_value (hashfn, name, namelen) == GET_HASH_VALUE (deh_offset))
/* this also sets hash function */
@@ -579,7 +579,7 @@ int is_properly_hashed (reiserfs_filsys_t * fs,
}
int find_hash_in_use (char * name, int namelen, __u32 hash_value_masked, unsigned int code_to_try_first)
int find_hash_in_use (char * name, int namelen, __u32 offset, unsigned int code_to_try_first)
{
unsigned int i;
@@ -587,14 +587,14 @@ int find_hash_in_use (char * name, int namelen, __u32 hash_value_masked, unsigne
return UNSET_HASH;
if (code_to_try_first) {
if (hash_value_masked == GET_HASH_VALUE (hashes [code_to_try_first].func (name, namelen)))
if (good_name (hashes [code_to_try_first].func, name, namelen, offset))
return code_to_try_first;
}
for (i = 1; i < HASH_AMOUNT; i ++) {
if (i == code_to_try_first)
continue;
if (hash_value_masked == GET_HASH_VALUE (hashes [i].func (name, namelen)))
if (good_name (hashes [i].func, name, namelen, offset))
return i;
}
@@ -1051,17 +1051,18 @@ char * name_in_entry (struct reiserfs_de_head * deh, int pos_in_item)
int name_in_entry_length (struct item_head * ih,
struct reiserfs_de_head * deh, int pos_in_item)
{
int len;
int len, i;
char * name;
len = entry_length (ih, deh, pos_in_item);
name = name_in_entry (deh, pos_in_item);
// name might be padded with 0s
while (!name [len - 1] && len > 0)
len --;
i = 0;
while (name[i] && i < len)
i++;
return len;
return i;
}
int name_length (char * name, int key_format)
reiserfscore/prints.c
+2 -3
View File
@@ -332,8 +332,7 @@ void print_directory_item (FILE * fp, reiserfs_filsys_t * fs,
GET_HASH_VALUE (get_deh_offset (deh)),
GET_GENERATION_NUMBER (get_deh_offset (deh)),
get_deh_location (deh), get_deh_state (deh),
code2name (find_hash_in_use (name, namelen,
GET_HASH_VALUE (get_deh_offset (deh)),
code2name (find_hash_in_use (name, namelen, get_deh_offset (deh),
fs ? get_sb_hash_code (fs->fs_ondisk_sb) : UNSET_HASH)));
/*fs ? (is_properly_hashed (fs, name, namelen, deh_offset (deh)) ? "" : "(BROKEN)") : "??");*/
}
@@ -648,7 +647,7 @@ int print_super_block (FILE * fp, reiserfs_filsys_t * fs, char * file_name,
"bitmaps, data, reserved] blocks): %u\n", get_sb_free_blocks (sb));
reiserfs_warning (fp, "Root block: %u\n", get_sb_root_block (sb));
}
reiserfs_warning (fp, "Filesystem marked as %scleanly umounted\n",
reiserfs_warning (fp, "Filesystem is %sclean\n",
(get_sb_umount_state (sb) == FS_CLEANLY_UMOUNTED) ? "" : "NOT ");
if (short_print)
reiserfscore/reiserfslib.c
+14 -27
View File
@@ -52,7 +52,8 @@ int is_block_count_correct (unsigned long journal_offset, unsigned int block_siz
/* 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 (char * filename, int flags, int *error, void * vp, int check)
reiserfs_filsys_t * reiserfs_open (char * filename, int flags,
int *error, void * vp, int check)
{
reiserfs_filsys_t * fs;
struct buffer_head * bh;
@@ -838,16 +839,11 @@ void reiserfs_insert_item (reiserfs_filsys_t * fs, struct path * path,
/*===========================================================================*/
static __u32 hash_value (reiserfs_filsys_t * fs, char * name)
__u32 hash_value (hashf_t func, char * name, int namelen)
{
__u32 res;
if (!strcmp (name, "."))
return DOT_OFFSET;
if (!strcmp (name, ".."))
return DOT_DOT_OFFSET;
res = reiserfs_hash (fs) (name, strlen (name));
res = func (name, namelen);
res = GET_HASH_VALUE(res);
if (res == 0)
res = 128;
@@ -864,14 +860,12 @@ int reiserfs_locate_entry (reiserfs_filsys_t * fs, struct key * dir, char * name
struct key entry_key;
struct item_head * ih;
struct reiserfs_de_head * deh;
__u32 hash;
int i, retval;
struct key * rdkey;
set_key_dirid (&entry_key, get_key_dirid (dir));
set_key_objectid (&entry_key, get_key_objectid (dir));
hash = hash_value (fs, name);
set_key_offset_v1 (&entry_key, hash);
set_key_offset_v1 (&entry_key, 0);
set_key_uniqueness (&entry_key, DIRENTRY_UNIQUENESS);
@@ -884,12 +878,6 @@ int reiserfs_locate_entry (reiserfs_filsys_t * fs, struct key * dir, char * name
ih = get_ih (path);
deh = B_I_DEH (get_bh (path), ih) + path->pos_in_item;
for (i = path->pos_in_item; i < get_ih_entry_count (ih); i ++, deh ++) {
if (GET_HASH_VALUE (get_deh_offset (deh)) != GET_HASH_VALUE (hash)) {
/* all entries having the same hash were scanned */
pathrelse (path);
return 0;
}
/* the name in directory has the same hash as the given name */
if ((name_in_entry_length (ih, deh, i) == (int)strlen (name)) &&
!memcmp (name_in_entry (deh, i), name, strlen (name))) {
@@ -907,13 +895,6 @@ int reiserfs_locate_entry (reiserfs_filsys_t * fs, struct key * dir, char * name
if (!is_direntry_key (rdkey))
reiserfs_panic ("reiserfs_locate_entry: can not find name in broken directory yet");
/* next item is the item of the directory we are looking name in */
if (GET_HASH_VALUE (get_offset (rdkey)) != hash) {
/* but there is no names with given hash */
pathrelse (path);
return 0;
}
/* first name of that item may be a name we are looking for */
entry_key = *rdkey;
pathrelse (path);
@@ -947,7 +928,12 @@ int reiserfs_find_entry (reiserfs_filsys_t * fs, struct key * dir, char * name,
set_key_dirid (&entry_key, get_key_dirid (dir));
set_key_objectid (&entry_key, get_key_objectid (dir));
hash = hash_value (fs, name);
if (!strcmp (name, "."))
hash = DOT_OFFSET;
else if (!strcmp (name, ".."))
hash = DOT_DOT_OFFSET;
else
hash = hash_value (reiserfs_hash (fs), name, strlen (name));
set_key_offset_v1 (&entry_key, hash);
set_key_uniqueness (&entry_key, DIRENTRY_UNIQUENESS);
@@ -1059,11 +1045,12 @@ int reiserfs_add_entry (reiserfs_filsys_t * fs, struct key * dir, char * name, i
/* compose entry key to look for its place in the tree */
set_key_dirid (&(entry_ih.ih_key), get_key_dirid (dir));
set_key_objectid (&(entry_ih.ih_key), get_key_objectid (dir));
hash = hash_value (fs, name) + gen_counter;
if (!strcmp (name, "."))
hash = DOT_OFFSET;
if (!strcmp (name, ".."))
else if (!strcmp (name, ".."))
hash = DOT_DOT_OFFSET;
else
hash = hash_value (reiserfs_hash (fs), name, strlen (name)) + gen_counter;
set_key_offset_v1 (&(entry_ih.ih_key), hash);
set_key_uniqueness (&(entry_ih.ih_key), DIRENTRY_UNIQUENESS);
reiserfsprogs.spec
+1 -1
View File
@@ -1,4 +1,4 @@
%define reiserfsprogsversion 3.6.18
%define reiserfsprogsversion 3.6.19
Vendor: Hans Reiser
Distribution: Hans Reiser
resize_reiserfs/do_shrink.c
+11 -6
View File
@@ -25,19 +25,24 @@ static void quit_resizer(reiserfs_filsys_t * fs)
/* save changes to bitmap blocks */
reiserfs_close (fs);
/* leave fs in ERROR state */
DIE ("fs shrinking was not completed successfully, run reiserfsck.");
reiserfs_exit(1, "fs shrinking was not completed successfully, "
"run reiserfsck.");
}
/* block moving */
static unsigned long move_generic_block(reiserfs_filsys_t * fs, unsigned long block, unsigned long bnd, int h)
static unsigned long move_generic_block(reiserfs_filsys_t * fs,
unsigned long block,
unsigned long bnd, int h)
{
struct buffer_head * bh, * bh2;
/* primitive fsck */
if (block > get_sb_block_count(ondisk_sb)) {
fprintf(stderr, "resize_reiserfs: invalid block number (%lu) found.\n", block);
fprintf(stderr, "resize_reiserfs: invalid block number "
"(%lu) found.\n", block);
quit_resizer(fs);
}
/* progress bar, 3D style :) */
if (opt_verbose)
print_how_far(stderr, &total_node_cnt, blocks_used, 1, 0);
@@ -57,7 +62,7 @@ static unsigned long move_generic_block(reiserfs_filsys_t * fs, unsigned long bl
bh = bread(fs->fs_dev, block, fs->fs_blocksize);
if (!bh)
reiserfs_panic ("move_generic_block: bread failed.\n");
reiserfs_exit (1, "move_generic_block: bread failed.\n");
reiserfs_bitmap_find_zero_bit(bmp, &unused_block);
if (unused_block == 0 || unused_block >= bnd) {
@@ -103,7 +108,7 @@ static unsigned long move_formatted_block(reiserfs_filsys_t * fs, unsigned long
bh = bread(fs->fs_dev, block, fs->fs_blocksize);
if (!bh)
reiserfs_panic ("move_formatted_block: bread failed");
reiserfs_exit (1, "move_formatted_block: bread failed");
if (is_leaf_node (bh)) {
@@ -208,7 +213,7 @@ int shrink_fs(reiserfs_filsys_t * fs, long long int blocks)
reiserfs_reopen(fs, O_RDWR);
if (reiserfs_open_ondisk_bitmap (fs))
DIE("cannot open ondisk bitmap");
reiserfs_exit(1, "cannot open ondisk bitmap");
bmp = fs->fs_bitmap2;
ondisk_sb = fs->fs_ondisk_sb;
resize_reiserfs/resize_reiserfs.8
+1 -1
View File
@@ -1,7 +1,7 @@
.\" -*- nroff -*-
.\" Copyright 1996-2004 Hans Reiser.
.\"
.TH RESIZE_REISERFS 8 "January 2004" "Reiserfsprogs-3.6.18"
.TH RESIZE_REISERFS 8 "January 2004" "Reiserfsprogs-3.6.19"
.SH NAME
resize_reiserfs \- resizer tool for the ReiserFS filesystem
.SH SYNOPSIS
resize_reiserfs/resize_reiserfs.c
+26 -14
View File
@@ -99,7 +99,7 @@ static int expand_fs (reiserfs_filsys_t * fs, long long int block_count_new) {
reiserfs_reopen(fs, O_RDWR);
if (reiserfs_open_ondisk_bitmap (fs))
DIE("cannot open ondisk bitmap");
reiserfs_exit(1, "cannot open ondisk bitmap");
sb = fs->fs_ondisk_sb;
@@ -109,7 +109,7 @@ static int expand_fs (reiserfs_filsys_t * fs, long long int block_count_new) {
if (reiserfs_expand_bitmap(fs->fs_bitmap2, block_count_new))
DIE("cannot expand bitmap\n");
reiserfs_exit(1, "cannot expand bitmap\n");
/* count bitmap blocks in new fs */
@@ -201,12 +201,12 @@ int main(int argc, char *argv[]) {
switch (c) {
case 's' :
if (!optarg)
DIE("Missing argument to -s option");
reiserfs_exit(1, "Missing argument to -s option");
bytes_count_str = optarg;
break;
case 'j' :
if (!optarg)
DIE("Missing argument to -j option");
reiserfs_exit(1, "Missing argument to -j option");
jdevice_name = optarg;
case 'f':
opt_force = 1;
@@ -244,26 +244,38 @@ int main(int argc, char *argv[]) {
devname = argv[optind];
fs = reiserfs_open(devname, O_RDONLY, &error, 0, 1);
if (!fs)
DIE ("cannot open '%s': %s", devname, strerror(error));
if (!fs) {
if (error) {
reiserfs_exit(1, "cannot open '%s': %s",
devname, strerror(error));
} else {
exit(1);
}
}
if (reiserfs_open_journal (fs, jdevice_name, O_RDWR | O_LARGEFILE))
DIE ("Failed to open the journal device (%s).", jdevice_name);
if (reiserfs_open_journal (fs, jdevice_name, O_RDWR | O_LARGEFILE)) {
reiserfs_exit(1, "Failed to open the journal device (%s).",
jdevice_name);
}
if (reiserfs_journal_params_check(fs)) {
if (!opt_skipj)
DIE ("Wrong journal parameters detected on (%s)", jdevice_name);
else
if (!opt_skipj) {
reiserfs_exit(1, "Wrong journal parameters detected on (%s)",
jdevice_name);
} else {
reiserfs_close_journal(fs);
}
}
/* forced to continue without journal available/specified */
if (no_reiserfs_found (fs)) {
DIE ("no reiserfs found on the device.");
reiserfs_exit(1, "no reiserfs found on the device.");
}
if (!spread_bitmaps (fs)) {
DIE ("cannot resize reiserfs in old (not spread bitmap) format.");
reiserfs_exit(1, "cannot resize reiserfs in old (not spread "
"bitmap) format.");
}
sb = fs->fs_ondisk_sb;
@@ -295,7 +307,7 @@ int main(int argc, char *argv[]) {
if (get_sb_umount_state(sb) != FS_CLEANLY_UMOUNTED)
/* fixme: shouldn't we check for something like: fsck guarantees: fs is ok */
DIE ("the file system isn't in valid state.");
reiserfs_exit(1, "the file system isn't in valid state.");
/* Needed to keep idiot compiler from issuing false warning */
sb_old = 0;
tune/reiserfstune.8
+1 -1
View File
@@ -1,7 +1,7 @@
.\" -*- nroff -*-
.\" Copyright 1996-2004 Hans Reiser.
.\"
.TH REISERFSTUNE 8 "February 2004" "Reiserfsprogs-3.6.18"
.TH REISERFSTUNE 8 "February 2004" "Reiserfsprogs-3.6.19"
.SH NAME
reiserfstune \- The tunning tool for the ReiserFS filesystem.
.SH SYNOPSIS
tune/tune.c
+4 -3
View File
@@ -525,7 +525,8 @@ int main (int argc, char **argv)
#if defined(O_LARGEFILE)
| O_LARGEFILE
#endif
)) {
))
{
message ("Failed to open the journal device (%s).", jdevice_name);
return 1;
}
@@ -577,10 +578,10 @@ int main (int argc, char **argv)
} else {
#if defined(HAVE_LIBUUID) && defined(HAVE_UUID_UUID_H)
if (!uuid_is_null(UUID))
reiserfs_panic ("UUID cannot be specified for 3.5 format\n");
reiserfs_exit (1, "UUID cannot be specified for 3.5 format\n");
#endif
if (LABEL)
reiserfs_panic ("LABEL cannot be specified for 3.5 format\n");
reiserfs_exit (1, "LABEL cannot be specified for 3.5 format\n");
}
if (!j_new_device_name) {