| /* |
| * 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 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 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; |
| } |