lgcosta/reiserfsprogs
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
47cff7274856753098786e4fc224d0276bbc903c
reiserfsprogs/tune/tune.c
T
Jeff Mahoney 47cff72748 cleanup: run indent with the Linux Kernel style across all code 
Over the years, the reiserfs kernel code has been gradually cleaned up
to be more readable. This patch does the same to the progs code.

Signed-off-by: Jeff Mahoney <jeffm@suse.com>
2013-08-26 17:14:42 -04:00

914 lines
24 KiB
C
Raw Blame History

/*
* Copyright 2002-2004 by Hans Reiser, licensing governed by
* reiserfsprogs/README
*/
#define _GNU_SOURCE
#include "tune.h"
#include <getopt.h>
#include <stdarg.h>
#include <string.h>
#include <errno.h>
#include <limits.h>
#include "parse_time.h"
char *program_name;
static void message(const char *fmt, ...)
__attribute__ ((format(printf, 1, 2)));
static void message(const char *fmt, ...)
{
char *buf;
va_list args;
buf = NULL;
va_start(args, fmt);
vasprintf(&buf, fmt, args);
va_end(args);
if (buf) {
fprintf(stderr, "%s: %s\n", program_name, buf);
free(buf);
}
}
reiserfs_filsys_t *fs;
static void print_usage_and_exit(void)
{
message("Usage: %s [options] device [block-count]\n"
"\n"
"Options:\n\n"
" -j | --journal-device file\tcurrent journal device\n"
" --journal-new-device file\tnew journal device\n"
" -o | --journal-new-offset N\tnew journal offset in blocks\n"
" -s | --journal-new-size N\tnew journal size in blocks\n"
" -t | --trans-max-size N\tnew journal max transaction size in blocks\n"
" --no-journal-available\tcurrent journal is not available\n"
" --make-journal-standard\tnew journal to be standard\n"
/*"\t-p | --keep-old-journal-param (keep parametrs from old journal to new one)\n" */
" -b | --add-badblocks file\tadd to bad block list\n"
" -B | --badblocks file\t\tset the bad block list\n"
" -u | --uuid UUID|random\tset new UUID\n"
" -l | --label LABEL\t\tset new label\n"
" -f | --force\t\t\tforce tuning, less confirmations\n"
" -c | --check-interval\t\tset interval in days for fsck -a to check,\n"
" \t\t\"disable\" to disable check,\n"
" \t\tor \"default\" to restore default\n"
" -C | --time-last-checked\tset the time the filesystem was last checked\n"
" \t(now or YYYYMMDD[HH[MM[SS]]])\n"
" -m | --max-mnt-count\t\tset maximum number of mounts before fsck -a\n"
" \t\tchecks, \"disable\" to disable check,\n"
" \t\tor \"default\" to restore default\n"
" -M | --mnt-count\t\tset the number of times the filesystem\n"
" \t\thas been mounted\n"
" -h | --help\t\t\tprint help and exit\n"
" -V\t\t\t\tprint version and exit\n", program_name);
exit(1);
}
unsigned long Journal_size = 0;
int Max_trans_size = JOURNAL_TRANS_MAX;
unsigned short Max_mnt_count = 0;
unsigned short Mnt_count = 0;
unsigned int Check_interval = 0;
time_t Time_last_checked = 0;
int Offset = 0;
__u16 Options = 0;
int Force = 0;
int Bads = 0;
char *LABEL;
unsigned char UUID[16];
char *badblocks_file;
/* If specified paramenters defines the standard journal, make it standard. */
static int should_make_journal_standard(reiserfs_filsys_t *fs,
char *j_new_dev_name)
{
if (!is_reiserfs_jr_magic_string(fs->fs_ondisk_sb))
return 0;
/*
if (!user_confirmed (stderr, "ATTENTION! Filesystem with non-standard journal "
"found. Continue? (y/n):", "y\n")) {
exit(1);
}
*/
/* make sure journal is on main device, it has default size
and the file system has non-standard magic */
if (j_new_dev_name) {
/* new journal was specified - check if it is available */
if (strcmp(j_new_dev_name, fs->fs_file_name))
return 0;
if (Journal_size && Journal_size !=
journal_default_size(fs->fs_super_bh->b_blocknr,
fs->fs_blocksize) + 1)
return 0;
if (Max_trans_size && (Max_trans_size != JOURNAL_TRANS_MAX))
return 0;
} else {
/* new journal was not specified - check ondisk journal params */
if (get_sb_reserved_for_journal(fs->fs_ondisk_sb) <
journal_default_size(fs->fs_super_bh->b_blocknr,
fs->fs_blocksize) + 1) {
message
("Can not create standard journal of the size %llu",
journal_default_size(fs->fs_super_bh->b_blocknr,
fs->fs_blocksize) + 1);
return 0;
}
}
return 1;
}
static int set_standard_journal_params(reiserfs_filsys_t *fs)
{
struct buffer_head *bh;
/* ondisk superblock update */
if (get_sb_version(fs->fs_ondisk_sb) == 0)
memcpy(fs->fs_ondisk_sb->s_v1.s_magic,
REISERFS_3_5_SUPER_MAGIC_STRING,
strlen(REISERFS_3_5_SUPER_MAGIC_STRING));
else if (get_sb_version(fs->fs_ondisk_sb) == 2)
memcpy(fs->fs_ondisk_sb->s_v1.s_magic,
REISERFS_3_6_SUPER_MAGIC_STRING,
strlen(REISERFS_3_6_SUPER_MAGIC_STRING));
else {
message
("Can not set standard reiserfs magic: unknown format found %u,"
" try reiserfsck first", get_sb_version(fs->fs_ondisk_sb));
return 0;
}
set_jp_journal_1st_block(sb_jp(fs->fs_ondisk_sb),
get_journal_start_must(fs));
set_jp_journal_dev(sb_jp(fs->fs_ondisk_sb), 0);
set_jp_journal_size(sb_jp(fs->fs_ondisk_sb),
journal_default_size(fs->fs_super_bh->b_blocknr,
fs->fs_blocksize));
if (get_jp_journal_max_trans_len(sb_jp(fs->fs_ondisk_sb)) !=
JOURNAL_TRANS_MAX)
set_jp_journal_max_trans_len(sb_jp(fs->fs_ondisk_sb),
JOURNAL_TRANS_MAX);
if (get_jp_journal_max_batch(sb_jp(fs->fs_ondisk_sb)) !=
JOURNAL_MAX_BATCH)
set_jp_journal_max_batch(sb_jp(fs->fs_ondisk_sb),
JOURNAL_MAX_BATCH);
if (get_jp_journal_max_commit_age(sb_jp(fs->fs_ondisk_sb)) !=
JOURNAL_MAX_COMMIT_AGE)
set_jp_journal_max_commit_age(sb_jp(fs->fs_ondisk_sb),
JOURNAL_MAX_COMMIT_AGE);
if (get_jp_journal_max_trans_age(sb_jp(fs->fs_ondisk_sb)) !=
JOURNAL_MAX_TRANS_AGE)
set_jp_journal_max_trans_age(sb_jp(fs->fs_ondisk_sb),
JOURNAL_MAX_TRANS_AGE);
set_sb_reserved_for_journal(fs->fs_ondisk_sb, 0);
/* journal_header update */
bh = getblk(fs->fs_journal_dev,
get_jp_journal_1st_block(sb_jp(fs->fs_ondisk_sb)) +
get_jp_journal_size(sb_jp(fs->fs_ondisk_sb)),
fs->fs_blocksize);
if (!bh) {
message
("Cannot get the journal header block. getblk failed.\n");
return 0;
}
((struct reiserfs_journal_header *)(bh->b_data))->jh_journal =
*(sb_jp(fs->fs_ondisk_sb));
mark_buffer_uptodate(bh, 1);
mark_buffer_dirty(bh);
bwrite(bh);
brelse(bh);
return 1;
}
void zero_journal(reiserfs_filsys_t *fs)
{
unsigned int i;
struct buffer_head *bh;
unsigned long done;
unsigned long start, len;
fprintf(stderr, "Initializing journal - ");
start = get_jp_journal_1st_block(sb_jp(fs->fs_ondisk_sb));
len = get_jp_journal_size(sb_jp(fs->fs_ondisk_sb));
done = 0;
for (i = 0; i < len; i++) {
print_how_far(stderr, &done, len, 1, 1 /*be quiet */ );
bh = getblk(fs->fs_journal_dev, start + i, fs->fs_blocksize);
if (!bh)
die("zero_journal: getblk failed");
memset(bh->b_data, 0, bh->b_size);
mark_buffer_dirty(bh);
mark_buffer_uptodate(bh, 1);
bwrite(bh);
brelse(bh);
}
fprintf(stderr, "\n");
fflush(stderr);
}
static int str2int(char *str)
{
int val;
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);
return val;
}
static void set_transaction_max_size(char *str)
{
Max_trans_size = str2int(str);
}
/* journal must fit into number of blocks pointed by first bitmap */
static void set_journal_device_size(char *str)
{
Journal_size = str2int(str);
}
static void set_offset_in_journal_device(char *str)
{
Offset = str2int(str);
}
static void set_max_mnt_count(char *str)
{
if (!strcmp(str, "disable"))
Max_mnt_count = USHRT_MAX;
else if (!strcmp(str, "default"))
Max_mnt_count = DEFAULT_MAX_MNT_COUNT;
else
Max_mnt_count = str2int(str);
}
static void set_mnt_count(char *str)
{
Mnt_count = str2int(str);
}
static void set_check_interval(char *str)
{
if (!strcmp(str, "disable"))
Check_interval = UINT_MAX;
else if (!strcmp(str, "default"))
Check_interval = DEFAULT_CHECK_INTERVAL;
else
Check_interval = str2int(str) * 60 * 60 * 24;
}
static void set_time_last_checked(char *str)
{
if (!strcmp(str, "now"))
Time_last_checked = time(NULL);
else
Time_last_checked = parse_time(str);
if (Time_last_checked == 0)
print_usage_and_exit();
}
static void callback_new_badblocks(reiserfs_filsys_t *fs,
struct reiserfs_path *badblock_path,
void *data)
{
struct item_head *tmp_ih;
__u32 *ind_item, i;
tmp_ih = get_ih(badblock_path);
ind_item = (__u32 *) get_item(badblock_path);
for (i = 0; i < I_UNFM_NUM(tmp_ih); i++) {
if (reiserfs_bitmap_test_bit(fs->fs_badblocks_bm,
d32_get(ind_item, i))) {
message("Block %u is marked as bad already.",
d32_get(ind_item, i));
reiserfs_bitmap_clear_bit(fs->fs_badblocks_bm,
d32_get(ind_item, i));
}
}
pathrelse(badblock_path);
}
static void callback_clear_badblocks(reiserfs_filsys_t *fs,
struct reiserfs_path *badblock_path,
void *data)
{
struct item_head *tmp_ih;
__u32 *ind_item, i;
tmp_ih = get_ih(badblock_path);
ind_item = (__u32 *) get_item(badblock_path);
for (i = 0; i < I_UNFM_NUM(tmp_ih); i++) {
reiserfs_bitmap_clear_bit(fs->fs_bitmap2, d32_get(ind_item, i));
}
pathrelse(badblock_path);
}
static void add_badblocks(reiserfs_filsys_t *fs)
{
unsigned long i, marked = 0;
if (reiserfs_open_ondisk_bitmap(fs) < 0) {
message("Failed to open reiserfs ondisk bitmap.\n");
reiserfs_close(fs);
exit(1);
}
if (create_badblock_bitmap(fs, badblocks_file)) {
message("Failed to initialize the bad block bitmap.\n");
reiserfs_close(fs);
exit(1);
}
if (Bads == 1)
badblock_list(fs, callback_new_badblocks, NULL);
else
badblock_list(fs, callback_clear_badblocks, NULL);
for (i = 0; i < get_sb_block_count(fs->fs_ondisk_sb); i++) {
if (reiserfs_bitmap_test_bit(fs->fs_badblocks_bm, i)) {
if (!reiserfs_bitmap_test_bit(fs->fs_bitmap2, i)) {
reiserfs_bitmap_set_bit(fs->fs_bitmap2, i);
marked++;
} else {
/* Check that this is a block */
message
("Bad block %lu is used already in reiserfs tree. "
"To mark it as a bad block use reiserfsck\n"
"--fix-fixable with -B option.", i);
reiserfs_bitmap_clear_bit(fs->fs_badblocks_bm,
i);
}
}
}
if (marked) {
set_sb_free_blocks(fs->fs_ondisk_sb,
get_sb_free_blocks(fs->fs_ondisk_sb) -
fs->fs_badblocks_bm->bm_set_bits);
mark_buffer_dirty(fs->fs_super_bh);
}
if (Bads == 1) {
/* fs->fs_badblocks_bm contains blocks which are not in the bad
block list yet. Merge it with what is in the tree already. */
badblock_list(fs, mark_badblock, NULL);
}
if (marked) {
add_badblock_list(fs, 1);
}
message("%lu blocks were marked as bad.", marked);
}
int main(int argc, char **argv)
{
reiserfs_filsys_t *fs;
char *device_name;
char *jdevice_name;
char *j_new_device_name;
int c;
static int flag;
struct reiserfs_journal_header *j_head;
reiserfs_trans_t old, new;
int Is_journal_or_maxtrans_size_specified = 0;
program_name = strrchr(argv[0], '/');
if (program_name)
program_name++;
else
program_name = argv[0];
if (argc < 2)
print_usage_and_exit();
device_name = 0;
jdevice_name = 0;
j_new_device_name = 0;
memset(UUID, 0, 16);
while (1) {
static struct option options[] = {
{"help", no_argument, 0, 'h'},
{"journal-device", required_argument, 0, 'j'},
{"journal-new-device", required_argument, &flag,
OPT_NEW_J},
{"journal-new-size", required_argument, 0, 's'},
{"trans-max-size", required_argument, 0, 't'},
{"journal-new-offset", required_argument, 0, 'o'},
{"no-journal-available", no_argument, &flag,
OPT_SKIP_J},
/*{"keep-old-journal-param", no_argument, 0, 'p'}, */
{"uuid", required_argument, 0, 'u'},
{"label", required_argument, 0, 'l'},
{"add-badblocks", required_argument, 0, 'b'},
{"badblocks", required_argument, 0, 'B'},
{"force", no_argument, 0, 'f'},
{"make-journal-standard", no_argument, &flag,
OPT_STANDARD},
{"check-interval", required_argument, 0, 'c'},
{"time-last-checked", required_argument, 0, 'C'},
{"max-mount-count", required_argument, 0, 'm'},
{"mount-count", required_argument, 0, 'M'},
{0, 0, 0, 0}
};
int option_index;
c = getopt_long(argc, argv, "hj:s:t:o:fu:l:b:B:Vc:C:m:M:",
options, &option_index);
if (c == -1)
break;
switch (c) {
case 0:
/* long-only optins */
if (flag == OPT_NEW_J) {
Options |= OPT_NEW_J;
j_new_device_name = optarg;
}
if (flag == OPT_SKIP_J) {
Options |= OPT_SKIP_J;
}
if (flag == OPT_STANDARD) {
Options |= OPT_STANDARD;
}
break;
case 'j': /* --journal-device */
jdevice_name = optarg;
break;
case 's': /* --journal-new-size */
set_journal_device_size(optarg);
Is_journal_or_maxtrans_size_specified = 1;
break;
case 't': /* --trans-max-size */
set_transaction_max_size(optarg);
Is_journal_or_maxtrans_size_specified = 1;
break;
case 'o': /* --offset */
set_offset_in_journal_device(optarg);
break;
case 'f':
/* forces replacing standard journal with non-standard
one. Specified more than once - allows to avoid asking for
confirmation */
Force++;
break;
case 'b': /* --add-badblocks */
asprintf(&badblocks_file, "%s", optarg);
Bads = 1;
break;
case 'B': /* --badblocks */
asprintf(&badblocks_file, "%s", optarg);
Bads = 2;
break;
case 'u':
/* UUID */
#if defined(HAVE_LIBUUID) && defined(HAVE_UUID_UUID_H)
if (!strcmp(optarg, "random")) {
uuid_generate(UUID);
} else {
if (uuid_parse(optarg, UUID) < 0) {
message
("Invalid UUID '%s' was specified\n",
optarg);
return 1;
}
}
#else
message("Cannot set the UUID, uuidlib was not found "
"by configure.\n");
return 1;
#endif
break;
case 'l':
/* LABEL */
LABEL = optarg;
break;
case 'V':
print_banner("reiserfstune");
exit(0);
case 'h':
print_usage_and_exit();
break;
case 'c':
set_check_interval(optarg);
break;
case 'C':
set_time_last_checked(optarg);
break;
case 'm':
set_max_mnt_count(optarg);
break;
case 'M':
set_mnt_count(optarg);
break;
#if 0
case 'J': /* --journal-new-device */
Options |= OPT_NEW_J;
j_new_device_name = optarg;
break;
case 'u': /* --no-journal-available */
Options |= OPT_SKIPJ;
break;
case 'p': /* --keep-old-journal-param */
Options |= OPT_KEEPO;
break;
#endif
default:
print_usage_and_exit();
}
}
if (optind != argc - 1)
print_usage_and_exit();
/* device to be formatted */
device_name = argv[optind];
fs = reiserfs_open(device_name, O_RDONLY, 0, NULL, 1);
if (no_reiserfs_found(fs)) {
message("Cannot open reiserfs on %s", device_name);
return 1;
}
/* journal was opened or it wasn't opened but the option
--no-journal-available has been specified by user */
/* make sure filesystem is not mounted */
if (misc_device_mounted(fs->fs_file_name) > 0) {
/* fixme: it can not be mounted, btw */
message
("Reiserfstune is not allowed to be run on mounted filesystem.");
reiserfs_close(fs);
return 1;
}
if (!reiserfs_is_fs_consistent(fs)) {
message
("Filesystem looks not cleanly umounted, check the consistency first.\n");
reiserfs_close(fs);
return 1;
}
reiserfs_reopen(fs, O_RDWR);
if (badblocks_file) {
add_badblocks(fs);
reiserfs_close(fs);
exit(0);
}
if (!jdevice_name && !(Options & OPT_SKIP_J)) {
message
("Journal device has not been specified. Assuming journal is on the main "
"device (%s).\n", device_name);
jdevice_name = device_name;
}
if (jdevice_name && (Options & OPT_SKIP_J)) {
message("Either specify journal device, "
"or choose the option --no-journal-available");
return 1;
}
if (j_new_device_name && (Options & OPT_STANDARD)) {
/* New device was specified and --make-journal-standard was also. */
message("Either specify new journal device, "
"or choose the option --make-journal-standard");
return 1;
}
/* now we try to open journal, it makes sence if there is no the flag
NEED_TUNE in ondisk superblock and --no-journal available is not
specified. */
if (get_jp_journal_magic(sb_jp(fs->fs_ondisk_sb)) != NEED_TUNE &&
!(Options & OPT_SKIP_J)) {
if (reiserfs_open_journal(fs, jdevice_name, O_RDWR
#if defined(O_LARGEFILE)
| O_LARGEFILE
#endif
)) {
message("Failed to open the journal device (%s).",
jdevice_name);
return 1;
}
if (reiserfs_journal_params_check(fs)) {
message
("Unable to open old journal. Wrong journal parameters.");
reiserfs_close(fs);
return 1;
}
}
/* in spite of journal was opened, the file system can be non-consistent or
there are non-replayed transaction in journal,
make sure it isn't (if there is no the flag NEED_TUNE in ondisk superblock */
if (get_jp_journal_magic(sb_jp(fs->fs_ondisk_sb)) != NEED_TUNE &&
reiserfs_journal_opened(fs)) {
j_head =
(struct reiserfs_journal_header *)(fs->fs_jh_bh->b_data);
if (get_boundary_transactions(fs, &old, &new)) {
if (new.trans_id != get_jh_last_flushed(j_head)) {
message
("There are non-replayed transaction in old journal,"
" check filesystem consistency first");
reiserfs_close(fs);
return 1;
}
}
if (!reiserfs_is_fs_consistent(fs)) {
message("Check filesystem consistency first");
reiserfs_close(fs);
return 1;
}
}
/* set UUID and LABEL if specified */
if (fs->fs_format == REISERFS_FORMAT_3_6) {
int need_dirty = 0;
#if defined(HAVE_LIBUUID) && defined(HAVE_UUID_UUID_H)
if (!uuid_is_null(UUID)) {
memcpy(fs->fs_ondisk_sb->s_uuid, UUID, 16);
need_dirty = 1;
}
#endif
if (LABEL != NULL) {
if (strlen(LABEL) > 16)
message
("Specified LABEL is longer then 16 characters, will be truncated\n");
strncpy(fs->fs_ondisk_sb->s_label, LABEL, 16);
need_dirty = 1;
}
if (Max_mnt_count &&
Max_mnt_count !=
get_sb_v2_max_mnt_count(fs->fs_ondisk_sb)) {
if (Max_mnt_count <= 0)
reiserfs_exit(1, "max-mnt-count must be > 0\n");
set_sb_v2_max_mnt_count(fs->fs_ondisk_sb,
Max_mnt_count);
need_dirty = 1;
}
if (Mnt_count &&
Mnt_count != get_sb_v2_mnt_count(fs->fs_ondisk_sb)) {
if (Max_mnt_count <= 0)
reiserfs_exit(1, "max-mnt-count must be > 0\n");
set_sb_v2_mnt_count(fs->fs_ondisk_sb, Mnt_count);
need_dirty = 1;
}
if (Check_interval &&
Check_interval !=
get_sb_v2_check_interval(fs->fs_ondisk_sb)) {
if (Check_interval <= 0)
reiserfs_exit(1,
"check-interval must be > 0\n");
set_sb_v2_check_interval(fs->fs_ondisk_sb,
Check_interval);
need_dirty = 1;
}
if (Time_last_checked &&
Time_last_checked !=
get_sb_v2_lastcheck(fs->fs_ondisk_sb)) {
set_sb_v2_lastcheck(fs->fs_ondisk_sb,
Time_last_checked);
need_dirty = 1;
}
if (need_dirty) {
mark_buffer_dirty(fs->fs_super_bh);
fs->fs_dirt = 1;
}
} else {
#if defined(HAVE_LIBUUID) && defined(HAVE_UUID_UUID_H)
if (!uuid_is_null(UUID))
reiserfs_exit(1,
"UUID cannot be specified for 3.5 format\n");
#endif
if (LABEL)
reiserfs_exit(1,
"LABEL cannot be specified for 3.5 format\n");
if (Max_mnt_count)
reiserfs_exit(1,
"max-mnt-count cannot be specified for 3.5 format\n");
if (Check_interval)
reiserfs_exit(1,
"check-interval cannot be specified for 3.5 format\n");
}
if (!j_new_device_name) {
/* new journal device hasn't been specified */
printf("Current parameters:\n");
print_filesystem_state(stdout, fs);
print_block(stdout, fs, fs->fs_super_bh);
if ((Options & OPT_STANDARD)
&& should_make_journal_standard(fs, j_new_device_name)) {
if (!user_confirmed
(stderr,
"ATTENTION! Filesystem with "
"non-standard journal found. Continue? (y/n):",
"y\n")) {
exit(1);
}
fs->fs_journal_dev = fs->fs_dev;
if (set_standard_journal_params(fs)) {
printf("\nNew parameters:\n");
print_filesystem_state(stdout, fs);
print_block(stdout, fs, fs->fs_super_bh);
printf("New journal parameters:\n");
print_journal_params(stdout,
sb_jp(fs->fs_ondisk_sb));
mark_buffer_dirty(fs->fs_super_bh);
mark_buffer_uptodate(fs->fs_super_bh, 1);
reiserfs_close(fs);
printf("Syncing..");
fflush(stdout);
sync();
printf("ok\n");
return 0;
}
}
if (Is_journal_or_maxtrans_size_specified) {
/* new journal device hasn't been specified, but
journal size or max transaction size have been, so we suppose
that journal device remains the same */
if (!reiserfs_journal_opened(fs)) {
message
("Cannot set up new paramenters for not specified journal.");
return 1;
}
j_new_device_name = jdevice_name;
} else {
/* the only parameter has been specified is device_name, so
there is nothing to do */
reiserfs_close(fs);
return 0;
}
}
/* new journal device has been specified */
/* make sure new journal device is block device file */
if (!can_we_format_it(j_new_device_name, Force)) {
reiserfs_close(fs);
return 1;
}
if (!strcmp(device_name, j_new_device_name)) {
unsigned long reserved, journal_size;
/* we have to put journal on main device. It is only possible if there
is enough space reserved by mkreiserfs */
if (!is_reiserfs_jr_magic_string(fs->fs_ondisk_sb))
/* standard journal */
reserved =
get_jp_journal_size(sb_jp(fs->fs_ondisk_sb)) + 1;
else
/* non-standard journal */
reserved =
get_sb_reserved_for_journal(fs->fs_ondisk_sb);
journal_size = Journal_size;
if (!journal_size) {
journal_size =
journal_default_size(fs->fs_super_bh->b_blocknr,
fs->fs_blocksize) + 1;
message
("Journal size has not been specified. Assuming it is the default size (%lu)",
journal_size);
}
/* journal_size = (Journal_size ? Journal_size : // specified
(fs->fs_blocksize == 1024 ? (fs->fs_blocksize) * 8 - 3 -
REISERFS_DISK_OFFSET_IN_BYTES / fs->fs_blocksize :
JOURNAL_DEFAULT_SIZE + 1)); // default
*/
if (journal_size + Offset >
get_journal_start_must(fs) + reserved) {
message
("There is no enough space reserved for journal on main "
"device (journal_size=%lu, reserved=%lu)\n",
journal_size, reserved);
reiserfs_close(fs);
return 1;
}
}
message("Current journal parameters:");
print_journal_params(stdout, sb_jp(fs->fs_ondisk_sb));
if (!is_reiserfs_jr_magic_string(fs->fs_ondisk_sb)) {
/* we have standard journal, so check if we can convert it
to non-standard one */
/*
if (!should_make_journal_non_standard (Force)) {
reiserfs_close (fs);
return 1;
}
*/
if (is_reiserfs_3_6_magic_string(fs->fs_ondisk_sb))
set_sb_version(fs->fs_ondisk_sb, REISERFS_FORMAT_3_6);
else if (is_reiserfs_3_5_magic_string(fs->fs_ondisk_sb))
set_sb_version(fs->fs_ondisk_sb, REISERFS_FORMAT_3_5);
else {
message
("Could not convert from unknown version, try reiserfsck first");
reiserfs_close(fs);
return 1;
}
memcpy(fs->fs_ondisk_sb->s_v1.s_magic,
REISERFS_JR_SUPER_MAGIC_STRING,
strlen(REISERFS_JR_SUPER_MAGIC_STRING));
set_sb_reserved_for_journal(fs->fs_ondisk_sb,
get_jp_journal_size(sb_jp
(fs->
fs_ondisk_sb))
+ 1);
}
/* now we are going to close old journal and to create a new one */
reiserfs_close_journal(fs);
if (!reiserfs_create_journal(fs, j_new_device_name, Offset,
Journal_size, Max_trans_size, Force)) {
message("Could not create new journal");
reiserfs_close(fs);
return 1;
}
if (should_make_journal_standard(fs, j_new_device_name))
set_standard_journal_params(fs);
message("New journal parameters:");
print_journal_params(stdout, sb_jp(fs->fs_ondisk_sb));
print_block(stdout, fs, fs->fs_super_bh);
if (Force < 2) {
message
("ATTENTION: YOU ARE ABOUT TO SETUP THE NEW JOURNAL FOR THE \"%s\"!\n"
"AREA OF \"%s\" DEDICATED FOR JOURNAL WILL BE ZEROED!",
device_name, j_new_device_name);
if (!user_confirmed(stderr, "Continue (y/n):", "y\n")) {
return 1;
}
}
zero_journal(fs);
reiserfs_close(fs);
printf("Syncing..");
fflush(stdout);
sync();
printf("ok\n");
return 0;
}
Reference in new issue View Git Blame Copy Permalink