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

Imported reiserfsprogs-3.6.9

Browse Source
This commit is contained in:
Jeff Mahoney committed 2012-10-11 11:29:29 -04:00
1 parent 99c89460c3
commit cccefa4d84
86 files changed
+13393 -6954
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

fsck/super.c
+334 -171
View File
@@ -1,5 +1,11 @@
/*
* Copyright 2001-2003 by Hans Reiser, licensing governed by
* reiserfsprogs/README
*/
#include "fsck.h"
#include <stdlib.h>
#include <errno.h>
#define fsck_conditional_log(sb_found, fmt, list...) { \
if (sb_found) \
@@ -11,7 +17,7 @@ int what_fs_version ()
size_t n = 0;
char * answer = 0;
int version;
printf("\nwhat is version of ReiserFS you use[1-4]\n"
printf("\nwhat the version of ReiserFS do you use[1-4]\n"
"\t(1) 3.6.x\n"
"\t(2) >=3.5.9 (introduced in the middle of 1999) (if you use linux 2.2, choose this one)\n"
"\t(3) < 3.5.9 converted to new format (don't choose if unsure)\n"
@@ -24,12 +30,12 @@ int what_fs_version ()
return version;
}
/*
#define super_error(exit_code, text) { \
fsck_log(text); \
return exit_code; \
}
/*
int check_sb (reiserfs_filsys_t * fs) {
int magic = 0, version = 0;
@@ -165,6 +171,7 @@ void rebuild_sb (reiserfs_filsys_t * fs, char * filename, struct fsck_data * dat
int version = 0;
struct reiserfs_super_block * ondisk_sb = 0;
struct reiserfs_super_block * sb = 0;
struct reiserfs_journal_header *j_head;
int magic_was_found = 0;
unsigned long block_count = 0;
@@ -179,8 +186,8 @@ void rebuild_sb (reiserfs_filsys_t * fs, char * filename, struct fsck_data * dat
char * answer = 0;
size_t n = 0;
struct stat stat_buf;
int retval;
struct stat64 stat_buf;
int retval, exit_code = EXIT_OK;
if (!no_reiserfs_found (fs)) {
sb = getmem (sizeof (*sb));
@@ -195,9 +202,10 @@ void rebuild_sb (reiserfs_filsys_t * fs, char * filename, struct fsck_data * dat
if (strcmp(answer, "\n")) {
retval = (int) strtol (answer, &tmp, 0);
if ((*tmp && strcmp(tmp, "\n")) || retval < 0)
reiserfs_exit (16, "rebuild_sb: wrong block size specified\n");
reiserfs_exit (EXIT_USER, "rebuild_sb: wrong block size specified\n");
if (!is_blocksize_correct (retval))
reiserfs_exit (16, "rebuild_sb: wrong block size specified, only divisible by 1024 are supported currently\n");
reiserfs_exit (EXIT_USER, "rebuild_sb: wrong block size specified, "
"only power of 2 from 512-8192 interval are supported.\n");
} else
retval = 4096;
@@ -215,42 +223,57 @@ void rebuild_sb (reiserfs_filsys_t * fs, char * filename, struct fsck_data * dat
/* 3_6 magic */
if (fsck_data (fs)->journal_dev_name)
/* journal dev must not be specified with standard journal */
reiserfs_exit (16, "Reiserfs with standard journal found, but there was specified a journal dev");
reiserfs_exit (EXIT_USER, "ReiserFS with default journal "
"is found, but there was specified a journal device.");
if (get_jp_journal_1st_block(sb_jp(sb)) == get_journal_new_start_must (fs))
if (fs->fs_super_bh->b_blocknr ==
REISERFS_DISK_OFFSET_IN_BYTES / fs->fs_blocksize)
version = 1;
else if (get_jp_journal_1st_block(sb_jp(sb)) == get_journal_old_start_must (fs))
else if (fs->fs_super_bh->b_blocknr ==
REISERFS_OLD_DISK_OFFSET_IN_BYTES / fs->fs_blocksize)
version = 3;
magic_was_found = 2;
} else if (is_reiserfs_3_5_magic_string (sb)) {
if (fsck_data (fs)->journal_dev_name)
/* journal dev must not be specified with standard journal */
reiserfs_exit (16, "Reiserfs with standard journal found, but there was specified a journal dev");
reiserfs_exit (EXIT_USER, "ReiserFS with default journal "
"is found, but there was specified a journal device.");
/* 3_5 magic */
if (get_jp_journal_1st_block(sb_jp(sb)) == get_journal_new_start_must (fs))
if (fs->fs_super_bh->b_blocknr ==
REISERFS_DISK_OFFSET_IN_BYTES / fs->fs_blocksize)
version = 2;
else if (get_jp_journal_1st_block(sb_jp(sb)) == get_journal_old_start_must (fs))
else if (fs->fs_super_bh->b_blocknr ==
REISERFS_OLD_DISK_OFFSET_IN_BYTES / fs->fs_blocksize)
version = 4;
magic_was_found = 1;
magic_was_found = 1;
} else if (is_reiserfs_jr_magic_string (sb)) {
if (!fsck_data (fs)->journal_dev_name)
if (!fsck_data (fs)->journal_dev_name && !fsck_skip_journal(fs))
/* journal dev must be specified with non standard journal */
reiserfs_exit (16, "Reiserfs with non standard journal found, but there was not specified any journal dev");
reiserfs_exit (EXIT_USER, "ReiserFS with non default journal "
"is found, but there was not specified any journal device.");
if (get_sb_version (sb) == REISERFS_FORMAT_3_6) {
/*non-standard magic + sb_format == 3_6*/
if (get_jp_journal_1st_block(sb_jp(sb)) == get_journal_new_start_must (fs))
if (fs->fs_super_bh->b_blocknr ==
REISERFS_DISK_OFFSET_IN_BYTES / fs->fs_blocksize)
version = 1;
else if (get_jp_journal_1st_block(sb_jp(sb)) == get_journal_old_start_must (fs))
else if (fs->fs_super_bh->b_blocknr ==
REISERFS_OLD_DISK_OFFSET_IN_BYTES / fs->fs_blocksize)
version = 3;
magic_was_found = 3;
} else if (get_sb_version (sb) == REISERFS_FORMAT_3_5) {
/* non-standard magic + sb_format == 3_5 */
if (get_jp_journal_1st_block(sb_jp(sb)) == get_journal_new_start_must (fs))
if (fs->fs_super_bh->b_blocknr ==
REISERFS_DISK_OFFSET_IN_BYTES / fs->fs_blocksize)
version = 2;
else if (get_jp_journal_1st_block(sb_jp(sb)) == get_journal_old_start_must (fs))
else if (fs->fs_super_bh->b_blocknr ==
REISERFS_OLD_DISK_OFFSET_IN_BYTES / fs->fs_blocksize)
version = 4;
magic_was_found = 3;
} else {
/* non-standard magic + bad sb_format */
@@ -258,7 +281,8 @@ void rebuild_sb (reiserfs_filsys_t * fs, char * filename, struct fsck_data * dat
magic_was_found = 3;
}
} else
reiserfs_exit (16, "we opened device but there is no magic and there is no correct superbblock format found");
reiserfs_exit (EXIT_USER, "We opened device but there is no magic "
"and there is no correct superblock format found.");
if (magic_was_found == 1 || magic_was_found == 2)
standard_journal = 1;
@@ -272,7 +296,10 @@ void rebuild_sb (reiserfs_filsys_t * fs, char * filename, struct fsck_data * dat
do {
printf("\nDid you use resizer(y/n)[n]: ");
getline (&answer, &n, stdin);
} while (strcmp ("y\n", answer) && strcmp ("n\n", answer) && strcmp ("\n", answer));
} while(strcmp ("y\n", answer) &&
strcmp ("n\n", answer) &&
strcmp ("\n", answer));
if (!strcmp ("y\n", answer)) {
printf("\nEnter partition size [%lu]: ", block_count);
getline (&answer, &n, stdin);
@@ -280,26 +307,31 @@ void rebuild_sb (reiserfs_filsys_t * fs, char * filename, struct fsck_data * dat
block_count = atoi (answer);
set_sb_block_count (sb, block_count);
} else {
fsck_conditional_log (magic_was_found, "rebuild-sb: wrong block count occured (%lu), fixed (%lu)\n",
get_sb_block_count(sb), block_count);
fsck_conditional_log (magic_was_found, "rebuild-sb: wrong block count "
"occured (%lu), fixed (%lu)\n", get_sb_block_count(sb), block_count);
set_sb_block_count (sb, block_count);
}
}
if (get_sb_block_size (sb) != fs->fs_blocksize) {
fsck_log("rebuild-sb: wrong block size occured (%lu), fixed (%lu)\n", get_sb_block_size (sb), fs->fs_blocksize);
fsck_log("rebuild-sb: wrong block size occured (%lu), fixed (%lu)\n",
get_sb_block_size (sb), fs->fs_blocksize);
set_sb_block_size (sb, fs->fs_blocksize);
}
}
/* if no reiserfs_found or bad data found in that SB, what was checked in previous clause */
/* if no reiserfs_found or bad data found in that SB, what was checked in previous
* clause */
if (no_reiserfs_found (fs)) {
int fd;
fd = open (filename, O_RDWR | O_LARGEFILE);
if (fd == -1)
reiserfs_exit (8, "rebuils_sb: cannot open device %s", filename);
if (fd == -1) {
reiserfs_exit (EXIT_OPER, "rebuils_sb: cannot open device %s",
filename);
}
version = what_fs_version ();
@@ -311,9 +343,10 @@ void rebuild_sb (reiserfs_filsys_t * fs, char * filename, struct fsck_data * dat
if (strcmp(answer, "\n")) {
retval = (int) strtol (answer, &tmp, 0);
if ((*tmp && strcmp(tmp, "\n")) || retval < 0)
reiserfs_exit (16, "rebuild_sb: wrong block size specified\n");
reiserfs_exit (EXIT_USER, "rebuild_sb: wrong block size specified\n");
if (!is_blocksize_correct (retval))
reiserfs_exit (16, "rebuild_sb: wrong block size specified, only divisible by 1024 are supported currently\n");
reiserfs_exit (EXIT_USER, "rebuild_sb: wrong block size specified, "
"only divisible by 1024 are supported currently\n");
} else
retval = 4096;
}
@@ -335,19 +368,27 @@ void rebuild_sb (reiserfs_filsys_t * fs, char * filename, struct fsck_data * dat
break;
}
if (fs == NULL)
return;
sb = fs->fs_ondisk_sb;
fs->fs_vp = data;
if (!fsck_skip_journal (fs)) {
if (!fsck_data (fs)->journal_dev_name) {
do {
printf("\nNo journal device was specified. (If journal is not available, re-run with --no-journal-available).\n"\
"Is journal standard? (y/n)[y]: ");
printf("\nNo journal device was specified. (If journal is not "
"available, re-run with --no-journal-available option specified).\n"
"Is journal default? (y/n)[y]: ");
getline (&answer, &n, stdin);
} while (strcmp ("y\n", answer) && strcmp ("n\n", answer) && strcmp ("\n", answer));
} while(strcmp ("y\n", answer) &&
strcmp ("n\n", answer) &&
strcmp ("\n", answer));
if (!strcmp ("n\n", answer)) {
printf("\nSpecify journal device with -j option.\n");
exit(16);
exit(EXIT_USER);
}
standard_journal = 1;
} else {
@@ -358,7 +399,7 @@ void rebuild_sb (reiserfs_filsys_t * fs, char * filename, struct fsck_data * dat
}
do {
printf("\nDid you use resiser(y/n)[n]: ");
printf("\nDid you use resizer(y/n)[n]: ");
getline (&answer, &n, stdin);
} while (strcmp ("y\n", answer) && strcmp ("n\n", answer) && strcmp ("\n", answer));
if (!strcmp ("y\n", answer)) {
@@ -369,64 +410,83 @@ void rebuild_sb (reiserfs_filsys_t * fs, char * filename, struct fsck_data * dat
set_sb_block_count (sb, block_count);
}
set_sb_fs_state (sb, REISERFS_CORRUPTED);
set_sb_fs_state (sb, FS_ERROR);
}
if (version == 1 || version == 3) {
if (get_reiserfs_format (sb) != REISERFS_FORMAT_3_6) {
fsck_log("rebuild-sb: wrong reiserfs version occured (%lu), fixed (%lu)\n", get_reiserfs_format (sb), REISERFS_FORMAT_3_6);
fsck_log("rebuild-sb: wrong reiserfs version occured (%lu), fixed (%lu)\n",
get_reiserfs_format (sb), REISERFS_FORMAT_3_6);
set_sb_version (sb, REISERFS_FORMAT_3_6);
}
} else if (version == 2 || version == 4) {
if (get_reiserfs_format (sb) != REISERFS_FORMAT_3_5) {
fsck_log("rebuild-sb: wrong reiserfs version occured (%lu), fixed (%lu)\n", get_reiserfs_format (sb), REISERFS_FORMAT_3_5);
fsck_log("rebuild-sb: wrong reiserfs version occured (%lu), fixed (%lu)\n",
get_reiserfs_format (sb), REISERFS_FORMAT_3_5);
set_sb_version (sb, REISERFS_FORMAT_3_5);
}
}
p_oid_maxsize = (fs->fs_blocksize - reiserfs_super_block_size (sb)) / sizeof(__u32) / 2 * 2;
p_oid_maxsize = (fs->fs_blocksize - reiserfs_super_block_size (sb)) /
sizeof(__u32) / 2 * 2;
if (get_sb_oid_maxsize (sb) != p_oid_maxsize) {
fsck_log("rebuild-sb: wrong objectid map max size occured (%lu), fixed (%lu)\n", get_sb_oid_maxsize (sb), p_oid_maxsize);
fsck_log("rebuild-sb: wrong objectid map max size occured (%lu), fixed (%lu)\n",
get_sb_oid_maxsize (sb), p_oid_maxsize);
set_sb_oid_maxsize (sb, p_oid_maxsize);
}
p_bmap_nr = (block_count + (fs->fs_blocksize * 8 - 1)) / (fs->fs_blocksize * 8);
if (get_sb_bmap_nr (sb) != p_bmap_nr) {
fsck_log("rebuild-sb: wrong bitmap number occured (%lu), fixed (%lu)\n", get_sb_bmap_nr (sb), p_bmap_nr);
set_sb_bmap_nr (sb, (block_count + (fs->fs_blocksize * 8 - 1)) / (fs->fs_blocksize * 8));
fsck_log("rebuild-sb: wrong bitmap number occured (%lu), fixed (%lu)\n",
get_sb_bmap_nr (sb), p_bmap_nr);
set_sb_bmap_nr (sb,
(block_count + (fs->fs_blocksize * 8 - 1)) / (fs->fs_blocksize * 8));
}
if (get_sb_root_block (sb) > block_count) {
fsck_log("rebuild-sb: wrong root block occured (%lu), zeroed\n", get_sb_root_block (sb));
fsck_log("rebuild-sb: wrong root block occured (%lu), zeroed\n",
get_sb_root_block (sb));
set_sb_root_block (sb, 0);
}
if (get_sb_free_blocks (sb) > block_count) {
fsck_log ("rebuild-sb: wrong free block count occured (%lu), zeroed\n", get_sb_free_blocks (sb));
fsck_log ("rebuild-sb: wrong free block count occured (%lu), zeroed\n",
get_sb_free_blocks (sb));
set_sb_free_blocks (sb, 0);
}
if (get_sb_umount_state (sb) != REISERFS_CLEANLY_UMOUNTED && get_sb_umount_state (sb) != REISERFS_NOT_CLEANLY_UMOUNTED) {
fsck_conditional_log (magic_was_found, "rebuild-sb: wrong umount state, fixed to (REISERFS_NOT_CLEANLY_UMOUNTED)\n",
get_sb_umount_state (sb));
set_sb_umount_state (sb, REISERFS_NOT_CLEANLY_UMOUNTED);
if (get_sb_umount_state (sb) != FS_CLEANLY_UMOUNTED &&
get_sb_umount_state (sb) != FS_NOT_CLEANLY_UMOUNTED)
{
fsck_conditional_log (magic_was_found, "rebuild-sb: wrong umount state (%u), "
"fixed to (FS_NOT_CLEANLY_UMOUNTED)\n", get_sb_umount_state (sb));
set_sb_umount_state (sb, FS_NOT_CLEANLY_UMOUNTED);
}
if (get_sb_oid_cursize (sb) == 1 || get_sb_oid_cursize (sb) > get_sb_oid_maxsize (sb)) {
fsck_log("rebuild-sb: wrong objectid map occured (%lu), zeroed\n", get_sb_oid_cursize (sb));
if (get_sb_oid_cursize (sb) == 1 ||
get_sb_oid_cursize (sb) > get_sb_oid_maxsize (sb))
{
fsck_log("rebuild-sb: wrong objectid map occured (%lu), zeroed\n",
get_sb_oid_cursize (sb));
set_sb_oid_cursize (sb, 0);
}
if ( get_sb_tree_height (sb) &&
((get_sb_tree_height (sb) < DISK_LEAF_NODE_LEVEL + 1) ||
(get_sb_tree_height (sb) > MAX_HEIGHT)) ) {
fsck_log("rebuild-sb: wrong tree height occured, zeroed\n", get_sb_tree_height (sb));
fsck_log("rebuild-sb: wrong tree height occured (%u), zeroed\n",
get_sb_tree_height (sb));
set_sb_tree_height (sb, 0);
}
if (get_sb_hash_code (sb) && code2name (get_sb_hash_code (sb)) == 0) {
fsck_log("rebuild-sb: wrong hash occured (%lu), zeroed\n", get_sb_hash_code (sb));
fsck_log("rebuild-sb: wrong hash occured (%lu), zeroed\n",
get_sb_hash_code (sb));
set_sb_hash_code (sb, 0);
}
@@ -435,7 +495,8 @@ void rebuild_sb (reiserfs_filsys_t * fs, char * filename, struct fsck_data * dat
if (generate_random_uuid (sb->s_uuid)) {
fsck_log ("rebuild-sb: no uuid found, failed to genetate UUID\n");
} else {
fsck_log ("rebuild-sb: no uuid found, a new uuid generated (%U)\n", sb->s_uuid);
fsck_log ("rebuild-sb: no uuid found, a new uuid generated (%U)\n",
sb->s_uuid);
}
}
if (sb->s_flags != 0 && sb->s_flags != 1) {
@@ -465,112 +526,87 @@ void rebuild_sb (reiserfs_filsys_t * fs, char * filename, struct fsck_data * dat
p_jp_journal_1st_block = get_journal_start_must (fs);
if (!fsck_skip_journal (fs) && standard_journal == 1) {
if (get_jp_journal_dev (sb_jp(sb)) != 0) {
fsck_conditional_log (magic_was_found, "rebuild-sb: wrong journal device occured (%lu), fixed (0)\n",
get_jp_journal_dev (sb_jp(sb)));
if (standard_journal == 1) {
if (get_jp_journal_dev (sb_jp(sb)) != 0) {
fsck_conditional_log (magic_was_found, "rebuild-sb: wrong journal device "
"occured (%lu), fixed (0)\n", get_jp_journal_dev (sb_jp(sb)));
set_jp_journal_dev (sb_jp(sb), 0);
}
if (get_sb_reserved_for_journal (sb) != 0) {
fsck_log ("rebuild-sb: wrong size reserved for standard journal occured (%lu), fixed (0)\n",
get_sb_reserved_for_journal (sb));
fsck_log ("rebuild-sb: wrong size reserved for default journal occured "
"(%lu), fixed (0)\n", get_sb_reserved_for_journal (sb));
set_sb_reserved_for_journal (sb, 0);
}
if (get_jp_journal_1st_block (sb_jp(sb)) != p_jp_journal_1st_block) {
fsck_conditional_log (magic_was_found, "rebuild-sb: wrong journal first block occured (%lu), fixed (%lu)\n",
get_jp_journal_1st_block (sb_jp(sb)), p_jp_journal_1st_block);
fsck_conditional_log (magic_was_found, "rebuild-sb: wrong journal first "
"block occured (%lu), fixed (%lu)\n", get_jp_journal_1st_block (sb_jp(sb)),
p_jp_journal_1st_block);
set_jp_journal_1st_block (sb_jp(sb) , p_jp_journal_1st_block);
}
if (get_jp_journal_size (sb_jp(sb)) != journal_default_size(fs->fs_super_bh->b_blocknr, fs->fs_blocksize)) {
fsck_conditional_log (magic_was_found, "rebuild-sb: wrong journal size occured (%lu), fixed (%lu)\n",
get_jp_journal_size (sb_jp(sb)) + 1,
journal_default_size (fs->fs_super_bh->b_blocknr, fs->fs_blocksize) + 1);
set_jp_journal_size (sb_jp(sb), journal_default_size (fs->fs_super_bh->b_blocknr, fs->fs_blocksize));
}
if (get_jp_journal_max_trans_len (sb_jp(sb)) !=
advise_journal_max_trans_len( get_jp_journal_max_trans_len (sb_jp(sb)),
get_jp_journal_size (sb_jp(sb)),
fs->fs_blocksize))
if (get_jp_journal_size (sb_jp(sb)) !=
journal_default_size(fs->fs_super_bh->b_blocknr, fs->fs_blocksize))
{
fsck_conditional_log (magic_was_found, "rebuild-sb: wrong journal max transaction length occured (%lu), fixed (%d)\n",
get_jp_journal_max_trans_len (sb_jp(sb)),
advise_journal_max_trans_len ( get_jp_journal_max_trans_len (sb_jp(sb)),
get_jp_journal_size (sb_jp(sb)),
fs->fs_blocksize));
set_jp_journal_max_trans_len (sb_jp(sb),
advise_journal_max_trans_len( get_jp_journal_max_trans_len (sb_jp(sb)),
get_jp_journal_size (sb_jp(sb)),
fs->fs_blocksize));
}
/* if (get_jp_journal_magic (sb_jp(sb)) != 0) {
fsck_log ("rebuild-sb: wrong journal magic occured (%lu), fixed (0)\n", get_jp_journal_magic (sb_jp(sb)));
set_jp_journal_magic (sb_jp(sb), 0);
}*/
if (get_jp_journal_max_batch (sb_jp(sb)) != advise_journal_max_batch(get_jp_journal_max_trans_len (sb_jp(sb)))) {
fsck_conditional_log (magic_was_found, "rebuild-sb: wrong journal max batch size occured (%lu), fixed (%d)\n",
get_jp_journal_max_batch (sb_jp(sb)), advise_journal_max_batch(get_jp_journal_max_trans_len (sb_jp(sb))));
set_jp_journal_max_batch (sb_jp(sb), advise_journal_max_batch(get_jp_journal_max_trans_len (sb_jp(sb))));
}
if (get_jp_journal_max_commit_age (sb_jp(sb)) != advise_journal_max_commit_age()) {
fsck_conditional_log (magic_was_found, "rebuild-sb: wrong journal max commit age occured (%lu), fixed (%d)\n",
get_jp_journal_max_commit_age (sb_jp(sb)), advise_journal_max_commit_age());
set_jp_journal_max_commit_age (sb_jp(sb), advise_journal_max_commit_age());
}
if (get_jp_journal_max_trans_age (sb_jp(sb)) != advise_journal_max_trans_age()) {
fsck_log ("rebuild-sb: wrong journal max commit age occured (%lu), fixed (0)\n",
get_jp_journal_max_trans_age (sb_jp(sb)), advise_journal_max_trans_age());
set_jp_journal_max_trans_age (sb_jp(sb), advise_journal_max_trans_age());
fsck_conditional_log (magic_was_found, "rebuild-sb: wrong journal size "
"occured (%lu), fixed (%lu)\n", get_jp_journal_size (sb_jp(sb)) + 1,
journal_default_size (fs->fs_super_bh->b_blocknr,
fs->fs_blocksize) + 1);
set_jp_journal_size (sb_jp(sb),
journal_default_size (fs->fs_super_bh->b_blocknr, fs->fs_blocksize));
}
if ((retval = reiserfs_open_journal(fs, filename, O_RDWR | O_LARGEFILE))) {
fsck_log("\nrebuild-sb: Failed to open the journal device (%s).",
filename);
exit(retval == 1 ? EXIT_USER : EXIT_OPER);
}
} else if (!fsck_skip_journal(fs)) {
/* Check that specified non-standard journal device exists. */
journal_dev_name = fsck_data (fs)->journal_dev_name;
retval = stat64(journal_dev_name, &stat_buf);
if (retval == -1)
reiserfs_exit (EXIT_USER, "rebuild_sb: error while detecting the "
"specified journal device (%s): %s\n", journal_dev_name,
strerror(errno));
retval = 0;
if (magic_was_found) {
/* Super block was found. Try to open the journal on the base of its
* journal parameters. */
retval = reiserfs_open_journal(fs, journal_dev_name,
O_RDWR | O_LARGEFILE);
if (retval == 0) {
j_head = (struct reiserfs_journal_header *)(fs->fs_jh_bh->b_data);
retval = memcmp(&j_head->jh_journal, sb_jp(sb),
sizeof(struct journal_params));
if (retval) {
/* journal parameters from the SB and from the J_Header does not
* match. Close the jouranl, ask the user about correct journal
* parameters. */
reiserfs_close_journal(fs);
}
}
} else if (!fsck_skip_journal(fs) && standard_journal == 0) {
/* non standard journal */
struct reiserfs_journal_header * jh;
if (!reiserfs_journal_opened(fs)) {
fsck_log ("Journal cannot be opened, assuming specified journal device "
"is correct\n");
}
}
if (!reiserfs_journal_opened(fs)) {
__u64 default_value;
journal_dev_name = fsck_data (fs)->journal_dev_name;
retval = stat(journal_dev_name, &stat_buf);
if (retval == -1)
reiserfs_exit (16, "rebuild_sb: wrong journal device specified\n");
if (strcmp (fs->fs_file_name, journal_dev_name))
set_jp_journal_dev (sb_jp(sb), stat_buf.st_rdev);
else
set_jp_journal_dev (sb_jp(sb), 0);
/*
if (journal_dev_name == 0) {
// ask user about the dev
printf("\nEnter dev with journal[%s]: \n", fs->fs_file_name);
getline (&answer, &n, stdin);
if (strcmp(answer, "\n")) {
journal_dev_name = malloc (strlen(answer));
strncpy(journal_dev_name, answer, strlen(answer) - 1);
retval = stat(journal_dev_name, &stat_buf);
if (retval == -1)
die ("rebuild_sb: wrong device specified\n");
if (strcmp (fs->fs_file_name, journal_dev_name))
set_jp_journal_dev (sb_jp(sb), stat_buf.st_rdev);
else
set_jp_journal_dev (sb_jp(sb), 0);
} else {
set_jp_journal_dev (sb_jp(sb), 0);
journal_dev_name = fs->fs_file_name;
}
}
*/
retval = -1;
if (magic_was_found == 0 || (retval = reiserfs_open_journal (fs, journal_dev_name, O_RDONLY)) == 0) {
__u64 default_value;
/* journal header was not found or journal cannot be opened -> adjust journal size and offset */
/* default offset if magic was not found is 0 for relocated journal and get_journal_start_must
for any journal on the same device;
default offset if magic was found is found value */
if (retval == 0)
fsck_log ("Journal cannot be opened, assuming specified journal device is correct\n");
if (magic_was_found == 0)
default_value = (!strcmp(fs->fs_file_name, journal_dev_name)) ? p_jp_journal_1st_block : 0;
/* journal was not found or SB and J_Header parameters does not match. */
if (magic_was_found == 0)
default_value = (!strcmp(fs->fs_file_name, journal_dev_name)) ?
p_jp_journal_1st_block : 0;
else
default_value = get_jp_journal_1st_block (sb_jp(sb));
@@ -581,7 +617,8 @@ void rebuild_sb (reiserfs_filsys_t * fs, char * filename, struct fsck_data * dat
if (strcmp(answer, "\n")) {
retval = (int) strtol (answer, &tmp, 0);
if ((*tmp && strcmp(tmp, "\n")) || retval < 0)
reiserfs_exit(16, "rebuild_sb: wrong offset specified\n");
reiserfs_exit(EXIT_USER, "rebuild_sb: wrong offset specified\n");
set_jp_journal_1st_block (sb_jp(sb), retval);
} else
set_jp_journal_1st_block (sb_jp(sb), default_value);
@@ -590,27 +627,31 @@ void rebuild_sb (reiserfs_filsys_t * fs, char * filename, struct fsck_data * dat
/* 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)
reiserfs_exit(16, "rebuild_sb: offset is much then device size\n");
reiserfs_exit(EXIT_USER, "rebuild_sb: offset is much than device size\n");
}
/* default size if magic was not found is device size - journal_1st_block;
default size if magic was found is found value + 1 block for journal header */
default size if magic was found is found value + 1 block for journal
header */
if (magic_was_found == 0)
default_value = (!strcmp(fs->fs_file_name, journal_dev_name)) ?
journal_default_size (fs->fs_super_bh->b_blocknr, fs->fs_blocksize) + 1 :
p_jp_dev_size - get_jp_journal_1st_block (sb_jp(sb));
journal_default_size (fs->fs_super_bh->b_blocknr,
fs->fs_blocksize) + 1 :
p_jp_dev_size - get_jp_journal_1st_block (sb_jp(sb));
else
default_value = get_jp_journal_size (sb_jp(sb)) + 1;
printf("\nEnter journal size (including 1 block for journal header) on %s in blocks [%Lu]: \n",
journal_dev_name, (unsigned long long)default_value);
printf("\nEnter journal size (including 1 block for journal header) on "
"%s in blocks [%Lu]: \n", journal_dev_name,
(unsigned long long)default_value);
getline (&answer, &n, stdin);
if (strcmp(answer, "\n")) {
retval = (int) strtol (answer, &tmp, 0);
if ((*tmp && strcmp(tmp, "\n")) || retval < 0)
reiserfs_exit(16, "rebuild_sb: wrong offset specified\n");
reiserfs_exit(EXIT_USER, "rebuild_sb: wrong offset specified\n");
set_jp_journal_size (sb_jp(sb), retval - 1);
} else {
set_jp_journal_size (sb_jp(sb), default_value - 1);
@@ -619,26 +660,143 @@ void rebuild_sb (reiserfs_filsys_t * fs, char * filename, struct fsck_data * dat
/* some checks for journal size */
if (get_jp_journal_size (sb_jp(sb)) +
get_jp_journal_1st_block (sb_jp(sb)) + 1 > p_jp_dev_size)
reiserfs_exit(16, "rebuild_sb: journal offset + journal size is much then device size\n");
reiserfs_exit(EXIT_USER, "rebuild_sb: journal offset + journal size is "
"greater than device size\n");
/* some checks for journal size */
if (get_jp_journal_size (sb_jp(sb)) < JOURNAL_MIN_SIZE)
reiserfs_exit(EXIT_USER, "rebuild_sb: journal size cannot be less than "
"%lu blocks.\n", JOURNAL_MIN_SIZE + 1);
if (reiserfs_open_journal (fs, journal_dev_name, O_RDONLY) == 0)
reiserfs_exit(16, "rebuild-sb: journal header is not found, wrong dev/offset/size configuration\n");
}
if ((retval = reiserfs_open_journal(fs, journal_dev_name,
O_RDWR | O_LARGEFILE)))
{
fsck_log("\nrebuild-sb: Failed to open a journal device (%s).",
journal_dev_name);
exit(retval == 1 ? EXIT_USER : EXIT_OPER);
}
/* SB was found, but journal params were broken and have been recovered.
* Futher work goes as SB would not be found. */
magic_was_found = 0;
}
if (strcmp (fs->fs_file_name, journal_dev_name))
set_jp_journal_dev (sb_jp(sb), stat_buf.st_rdev);
else
set_jp_journal_dev (sb_jp(sb), 0);
jh = (struct reiserfs_journal_header *)fs->fs_jh_bh->b_data;
memcpy (sb_jp(sb), &jh->jh_journal, sizeof (struct journal_params));
} else {
fsck_log ("Journal was specified as not available, zeroing all journal fields in super block..");
set_jp_journal_dev (sb_jp(sb), 0);
set_sb_reserved_for_journal (sb, 0);
set_jp_journal_1st_block (sb_jp(sb) , 0);
set_jp_journal_size (sb_jp(sb), 0);
set_jp_journal_max_trans_len (sb_jp(sb), 0);
set_jp_journal_max_batch (sb_jp(sb), 0);
set_jp_journal_max_commit_age (sb_jp(sb), 0);
set_jp_journal_max_commit_age (sb_jp(sb), 0);
fsck_log ("\nJournal was specified as not available. reiserfstune is "
"needed.\n\n");
set_jp_journal_magic (sb_jp(sb), NEED_TUNE);
}
if (reiserfs_journal_opened(fs)) {
/* Journal was openned. Check/fix journal parameters and copy it the journal
* header. */
if (get_jp_journal_max_trans_len (sb_jp(sb)) !=
advise_journal_max_trans_len( get_jp_journal_max_trans_len (sb_jp(sb)),
get_jp_journal_size (sb_jp(sb)),
fs->fs_blocksize, 0))
{
fsck_conditional_log (magic_was_found, "rebuild-sb: wrong journal max "
"transaction length occured (%lu), fixed (%d)\n",
get_jp_journal_max_trans_len (sb_jp(sb)),
advise_journal_max_trans_len ( get_jp_journal_max_trans_len (sb_jp(sb)),
get_jp_journal_size (sb_jp(sb)),
fs->fs_blocksize, 0));
set_jp_journal_max_trans_len (sb_jp(sb),
advise_journal_max_trans_len ( get_jp_journal_max_trans_len (sb_jp(sb)),
get_jp_journal_size (sb_jp(sb)),
fs->fs_blocksize, 0));
}
if (get_jp_journal_max_batch (sb_jp(sb)) !=
advise_journal_max_batch(get_jp_journal_max_trans_len (sb_jp(sb))))
{
fsck_conditional_log (magic_was_found, "rebuild-sb: wrong journal max "
"batch size occured (%lu), fixed (%d)\n",
get_jp_journal_max_batch (sb_jp(sb)),
advise_journal_max_batch(get_jp_journal_max_trans_len (sb_jp(sb))));
set_jp_journal_max_batch (sb_jp(sb),
advise_journal_max_batch(get_jp_journal_max_trans_len (sb_jp(sb))));
}
if (get_jp_journal_max_commit_age (sb_jp(sb)) !=
advise_journal_max_commit_age())
{
fsck_conditional_log (magic_was_found, "rebuild-sb: wrong journal "
"max commit age occured (%lu), fixed (%d)\n",
get_jp_journal_max_commit_age (sb_jp(sb)), advise_journal_max_commit_age());
set_jp_journal_max_commit_age (sb_jp(sb), advise_journal_max_commit_age());
}
if (get_jp_journal_max_trans_age (sb_jp(sb)) != advise_journal_max_trans_age()) {
fsck_log ("rebuild-sb: wrong journal max commit age occured (%u), "
"fixed (%u)\n", get_jp_journal_max_trans_age (sb_jp(sb)),
advise_journal_max_trans_age());
set_jp_journal_max_trans_age (sb_jp(sb), advise_journal_max_trans_age());
}
j_head = (struct reiserfs_journal_header *)(fs->fs_jh_bh->b_data);
if (standard_journal == 0) {
if (get_jp_journal_magic (sb_jp(sb)) == 0 ||
get_jp_journal_magic (sb_jp(sb)) == NEED_TUNE)
{
int magic;
magic = random();
fsck_log ("rebuild-sb: genarate the new journal magic (%d)\n", magic);
set_jp_journal_magic (sb_jp(sb), magic);
set_jp_journal_magic (&j_head->jh_journal, magic);
}
} else {
set_jp_journal_magic (sb_jp(sb), 0);
}
retval = memcmp(&j_head->jh_journal, sb_jp(sb), sizeof(struct journal_params));
if (retval) {
if (standard_journal == 1) {
fsck_log("\nrebuild-sb: You either have a corrupted journal or have just "
"changed\nthe start of the partition with some partition table editor. "
"If you are\nsure that the start of the partition is ok, rebuild the "
"journal header.\n");
} else if (!magic_was_found) {
fsck_log("\nrebuild-sb: journal header is not found. You either have "
"a corrupted,\nbad configured(device/offset/size), not available "
"journal or have just changed\nthe start of the journal partition "
"with some partition table editor. In the \ncase of corrupted "
"journal you need to use --no-journal-available. If you are\n"
"sure that the start of the partition is ok and journal is "
"available, rebuild\nthe journal header.\n");
}
if (standard_journal || !magic_was_found) {
if (!user_confirmed (stdout, "Do you want to rebuild the journal header? "
"(y/n)[n]: ", "y\n"))
{
exit(EXIT_USER);
} else
exit_code = EXIT_FIXED;
}
memcpy(&j_head->jh_journal, sb_jp(sb), sizeof(struct journal_params));
mark_buffer_dirty(fs->fs_jh_bh);
bwrite (fs->fs_jh_bh);
}
}
/* whether journal header contains params with the same dev, offset, size will be
checked in open_journal */
@@ -647,11 +805,12 @@ void rebuild_sb (reiserfs_filsys_t * fs, char * filename, struct fsck_data * dat
else
sb_size = SB_SIZE_V1;
if (!magic_was_found || memcmp(ondisk_sb, sb, sb_size -
((sb_size == SB_SIZE) ? sizeof(fs->fs_ondisk_sb->s_unused) : 0)) )
if (ondisk_sb == NULL ||
memcmp(ondisk_sb, sb, sb_size - ((sb_size == SB_SIZE) ?
sizeof(fs->fs_ondisk_sb->s_unused) : 0)))
{
/* smth was changed in SB or a new one has been built */
set_sb_fs_state (sb, get_sb_fs_state (sb) || REISERFS_CORRUPTED);
set_sb_fs_state (sb, get_sb_fs_state (sb) | FS_ERROR);
if (ondisk_sb) {
/* if super_block was found, we keep sb in ondisk_sb */
@@ -660,13 +819,15 @@ void rebuild_sb (reiserfs_filsys_t * fs, char * filename, struct fsck_data * dat
freemem(sb);
}
fflush(stdout);
print_block (stderr, fs, fs->fs_super_bh);
if (user_confirmed (stderr, "Is this ok ? (y/n)[n]: ", "y\n")) {
mark_buffer_uptodate (fs->fs_super_bh, 1);
mark_buffer_dirty (fs->fs_super_bh);
bwrite (fs->fs_super_bh);
fsck_progress ("\nDo not forget to run reiserfsck --rebuild-tree\n\n");
fsck_progress ("The fs may still be unconsistent. Run reiserfsck --check.\n\n");
exit_code = EXIT_FIXED;
} else {
mark_buffer_clean (fs->fs_super_bh);
fsck_progress ("Super block was not written\n");
@@ -677,6 +838,8 @@ void rebuild_sb (reiserfs_filsys_t * fs, char * filename, struct fsck_data * dat
mark_buffer_clean (fs->fs_super_bh);
fsck_progress ("\nSuper block seems to be correct\n\n");
}
exit(exit_code);
}
/* if (version == 0) {