/*
 * Copyright 2002-2004 by Hans Reiser, licensing governed by 
 * reiserfsprogs/README
 */

#define _GNU_SOURCE

#include "includes.h"
#include "progbar.h"

/* compares description block with commit block. returns 0 if they differ, 1
   if they match */
static int does_desc_match_commit (struct buffer_head *d_bh, 
			    struct buffer_head *c_bh) 
{
    return (get_commit_trans_id (c_bh) == get_desc_trans_id (d_bh) &&
	    get_commit_trans_len (c_bh) == get_desc_trans_len (d_bh));
}


/* d_bh is descriptor, return number of block where commit block of this
   transaction is to be */
unsigned long commit_expected (reiserfs_filsys_t * fs, struct buffer_head * d_bh)
{
    unsigned long offset;
    struct journal_params * sb_jp;


    sb_jp = sb_jp (fs->fs_ondisk_sb);
    //desc = (struct reiserfs_journal_desc *)d_bh->b_data;
    offset = d_bh->b_blocknr - get_jp_journal_1st_block (sb_jp);
    return get_jp_journal_1st_block (sb_jp) + 
	((offset + get_desc_trans_len (d_bh) + 1) % get_jp_journal_size (sb_jp));
}


/* d_bh contains journal descriptor, returns number of block where descriptor
   block of next transaction should be */
unsigned long next_desc_expected (reiserfs_filsys_t * fs, struct buffer_head * d_bh)
{
    unsigned long offset;
    struct journal_params * sb_jp;


    sb_jp = sb_jp (fs->fs_ondisk_sb);
    //desc = (struct reiserfs_journal_desc *)d_bh->b_data;
    offset = d_bh->b_blocknr - get_jp_journal_1st_block (sb_jp);
    return get_jp_journal_1st_block (sb_jp) + 
	((offset + get_desc_trans_len (d_bh) + 2) % get_jp_journal_size (sb_jp));
}

/* common checks for validness of a transaction */
int transaction_check_content (reiserfs_filsys_t * fs, reiserfs_trans_t * trans) {
    struct buffer_head *d_bh, *c_bh;
    struct reiserfs_journal_desc * desc;
    struct reiserfs_journal_commit * commit;
    unsigned long block;
    unsigned int trans_half, i;

    d_bh = bread (fs->fs_journal_dev, trans->desc_blocknr, fs->fs_blocksize);

    if (!d_bh || who_is_this (d_bh->b_data, d_bh->b_size) != THE_JDESC)
	goto error_desc_brelse;

    /* read expected commit block and compare with descriptor block */
    c_bh = bread (fs->fs_journal_dev, commit_expected (fs, d_bh), fs->fs_blocksize);
    if (!c_bh)
	goto error_desc_brelse;
 
    if (!does_desc_match_commit (d_bh, c_bh)) 
	goto error_commit_brelse;

    /* Check that all target blocks are journalable */
    desc = (struct reiserfs_journal_desc *)(d_bh->b_data);
    commit = (struct reiserfs_journal_commit *)(c_bh->b_data);

    trans_half = journal_trans_half (d_bh->b_size);
    for (i = 0; i < get_desc_trans_len(d_bh); i++) {
	if (i < trans_half)
	    block = le32_to_cpu (desc->j2_realblock[i]);
	else
	    block = le32_to_cpu (commit->j3_realblock[i - trans_half]);

	if (not_journalable(fs, block)) 
	    goto error_commit_brelse;
    }
    
    brelse (d_bh);
    brelse (c_bh);
    return 1;
    
error_commit_brelse:
    brelse (c_bh);
error_desc_brelse:
    brelse(d_bh);
    return 0;
}

/* common checks for validness of a transaction */
int transaction_check_desc(reiserfs_filsys_t * fs, struct buffer_head * d_bh) {
    struct buffer_head * c_bh;
    int ret = 1;

    if (!d_bh || who_is_this (d_bh->b_data, d_bh->b_size) != THE_JDESC)
	return 0;

    /* read expected commit block and compare with descriptor block */
    c_bh = bread (fs->fs_journal_dev, commit_expected (fs, d_bh), fs->fs_blocksize);
    if (!c_bh)
	return 0;
 
    if (!does_desc_match_commit (d_bh, c_bh)) 
	ret = 0;

    brelse (c_bh);
    return ret;
}


/* read the journal and find the oldest and newest transactions, return number
   of transactions found */
int get_boundary_transactions (reiserfs_filsys_t * fs,
			       reiserfs_trans_t * oldest,
			       reiserfs_trans_t * newest)
{
    struct reiserfs_super_block * sb;
    unsigned long j_cur;
    unsigned long j_start;
    unsigned long j_size;
    struct buffer_head * d_bh;
    __u32 newest_trans_id, oldest_trans_id, trans_id;
    int trans_nr;

    sb = fs->fs_ondisk_sb;
    
    j_start = get_jp_journal_1st_block (sb_jp (sb));
    j_size = get_jp_journal_size (sb_jp (sb));
    
    oldest_trans_id = 0xffffffff;
    newest_trans_id = 0;

    trans_nr = 0;
    for (j_cur = 0; j_cur < j_size; j_cur ++) {
	d_bh = bread (fs->fs_journal_dev, j_start + j_cur, fs->fs_blocksize);
	if (!transaction_check_desc (fs, d_bh)) {
	    brelse (d_bh);
	    continue;
	}

	trans_nr ++;

	trans_id = get_desc_trans_id (d_bh);
	if (trans_id < oldest_trans_id) {
	    oldest_trans_id = trans_id;

	    oldest->mount_id = get_desc_mount_id (d_bh);
	    oldest->trans_id = get_desc_trans_id (d_bh);
	    oldest->desc_blocknr = d_bh->b_blocknr;
	    oldest->trans_len = get_desc_trans_len (d_bh);
	    oldest->commit_blocknr = commit_expected (fs, d_bh);
	    oldest->next_trans_offset = next_desc_expected (fs, d_bh) - j_start;
	}

	if (trans_id > newest_trans_id) {
	    newest_trans_id = trans_id;

	    newest->mount_id = get_desc_mount_id (d_bh);
	    newest->trans_id = get_desc_trans_id (d_bh);
	    newest->desc_blocknr = d_bh->b_blocknr;
	    newest->trans_len = get_desc_trans_len (d_bh);
	    newest->commit_blocknr = commit_expected (fs, d_bh);
	    newest->next_trans_offset = next_desc_expected (fs, d_bh) - j_start;
	}

	j_cur += get_desc_trans_len (d_bh) + 1;
	brelse (d_bh);
    }

    return trans_nr;
}

#define TRANS_FOUND     1
#define TRANS_NOT_FOUND 0

/* trans is a valid transaction. Look for valid transaction with smallest
   trans id which is greater than the id of the current one */
int next_transaction (reiserfs_filsys_t * fs, reiserfs_trans_t * trans, reiserfs_trans_t break_trans)
{
    struct buffer_head * d_bh, * next_d_bh;
    int found;
    unsigned long j_start;
    unsigned long j_offset;
    unsigned long block;


    j_start = get_jp_journal_1st_block (sb_jp (fs->fs_ondisk_sb));

    found = TRANS_NOT_FOUND;

    if (trans->trans_id == break_trans.trans_id)
	return found;
	
    /* make sure that 'trans' is a valid transaction */
    d_bh = bread (fs->fs_journal_dev, trans->desc_blocknr, fs->fs_blocksize);
    if (!transaction_check_desc (fs, d_bh))
	die ("next_transaction: valid transaction is expected");

    block = next_desc_expected (fs, d_bh);
    j_offset = block - j_start;

    while (1) {
	next_d_bh = bread (fs->fs_journal_dev, block, fs->fs_blocksize);
	if (transaction_check_desc (fs, next_d_bh))
	    break;

	brelse (next_d_bh);
	j_offset ++;
	block = j_start + (j_offset % get_jp_journal_size (sb_jp (fs->fs_ondisk_sb)));
    }

    //next_desc = (struct reiserfs_journal_desc *)next_d_bh->b_data;
    
    if (break_trans.trans_id >= get_desc_trans_id (next_d_bh)) {
	/* found transaction is newer */
	trans->mount_id = get_desc_mount_id (next_d_bh);
	trans->trans_id = get_desc_trans_id (next_d_bh);
	trans->desc_blocknr = next_d_bh->b_blocknr;
	trans->trans_len = get_desc_trans_len (next_d_bh);
	trans->commit_blocknr = commit_expected (fs, next_d_bh);
	trans->next_trans_offset = next_desc_expected (fs, next_d_bh) - j_start;
	found = TRANS_FOUND;
    }

    brelse (d_bh);
    brelse (next_d_bh);
    return found;
}

static void read_journal_write_in_place (reiserfs_filsys_t * fs, reiserfs_trans_t * trans, unsigned int index, 
                                         unsigned long in_journal, unsigned long in_place)
{
    struct buffer_head * j_bh, * bh;

    j_bh = bread (fs->fs_journal_dev, in_journal, fs->fs_blocksize);
    if (!j_bh) {
	fprintf (stderr, "replay_one_transaction: transaction %lu: reading %lu block failed\n",
		 trans->trans_id, in_journal);
	return;
    }
    if (not_journalable (fs, in_place)) {
	fprintf (stderr, "replay_one_transaction: transaction %lu: block %ld should not be journalled (%lu)\n",
		 trans->trans_id, in_journal, in_place);
	brelse (j_bh);
	return;
    }

    bh = getblk (fs->fs_dev, in_place, fs->fs_blocksize);
    
    memcpy (bh->b_data, j_bh->b_data, bh->b_size);
    mark_buffer_dirty (bh);
    mark_buffer_uptodate (bh, 1);
    bwrite (bh);
    brelse (bh);
    brelse (j_bh);
    
}


/* go through all blocks of transaction and call 'action' each of them */
void for_each_block (reiserfs_filsys_t * fs, reiserfs_trans_t * trans,
		     action_on_block_t action)
{
    struct buffer_head * d_bh, * c_bh;
    struct reiserfs_journal_desc * desc;
    struct reiserfs_journal_commit * commit;
    unsigned long j_start, j_offset, j_size;
    unsigned int i, trans_half;
    unsigned long block;
 
    d_bh = bread (fs->fs_journal_dev, trans->desc_blocknr, fs->fs_blocksize);
    if (!d_bh) {
	reiserfs_warning (stdout, "reading descriptor block %lu failed\n", trans->desc_blocknr);
	return;
    }

    c_bh = bread (fs->fs_journal_dev, trans->commit_blocknr, fs->fs_blocksize);
    if (!c_bh) {
	reiserfs_warning (stdout, "reading commit block %lu failed\n", trans->commit_blocknr);
	brelse (d_bh);
	return;
    }

    desc = (struct reiserfs_journal_desc *)(d_bh->b_data);
    commit = (struct reiserfs_journal_commit *)(c_bh->b_data);

    /* first block of journal and size of journal */
    j_start = get_jp_journal_1st_block (sb_jp (fs->fs_ondisk_sb));
    j_size = get_jp_journal_size (sb_jp (fs->fs_ondisk_sb));

    /* offset in the journal where the transaction starts */
    j_offset = trans->desc_blocknr - j_start + 1;

    trans_half = journal_trans_half (d_bh->b_size);
    for (i = 0; i < trans->trans_len; i ++, j_offset ++) {
	if (i < trans_half)
	    block = le32_to_cpu (desc->j2_realblock[i]);
	else
	    block = le32_to_cpu (commit->j3_realblock[i - trans_half]);
	action (fs, trans, i, j_start + (j_offset % j_size), block);
    }

    brelse (d_bh);
    brelse (c_bh);
}


/* transaction is supposed to be valid */
int replay_one_transaction (reiserfs_filsys_t * fs,
			    reiserfs_trans_t * trans)
{
    for_each_block (fs, trans, read_journal_write_in_place);
    fsync(fs->fs_dev);
    return 0;
}


void for_each_transaction (reiserfs_filsys_t * fs, action_on_trans_t action)
{
    reiserfs_trans_t oldest, newest;
    int ret = 0;

    if (!get_boundary_transactions (fs, &oldest, &newest))
	return;

    while (1) {
	action (fs, &oldest);	
	if ((ret = next_transaction (fs, &oldest, newest)) == TRANS_NOT_FOUND)
	    break;
    }
}

unsigned long get_size_of_journal_or_reserved_area(
    struct reiserfs_super_block * sb)
{
	if (is_reiserfs_jr_magic_string (sb))
		return get_sb_reserved_for_journal (sb);

	/* with standard journal */
	return get_jp_journal_size (sb_jp (sb)) + 1;
}


__u32 advise_journal_max_trans_len (__u32 desired, __u32 journal_size /* no j_header */, 
    int blocksize, int verbose)
{
    __u32 saved;
    __u32 ratio = 1;

    if (blocksize < 4096)
	ratio = 4096/blocksize;
	
    saved = desired;
    if (!desired)
		desired = JOURNAL_TRANS_MAX/ratio;
    
    if (journal_size / desired < JOURNAL_MIN_RATIO)
		desired = journal_size / JOURNAL_MIN_RATIO;
    
    if (desired > JOURNAL_TRANS_MAX/ratio)
		desired = JOURNAL_TRANS_MAX/ratio;
    
    if (desired < JOURNAL_TRANS_MIN/ratio)
		desired = JOURNAL_TRANS_MIN/ratio;

    if (verbose) {
	if (saved && saved != desired)
		reiserfs_warning (stderr,
		    "WARNING: wrong transaction max size (%u). Changed to %u\n", 
		    saved, desired);
    }

    return desired;
}
#if 0
    __u32 ret_val;
    ret_val = 0;
    if (!desired)                   ret_val = JOURNAL_TRANS_MAX;
    if (desired<journal_size/8)     ret_val = journal_size/8;
    if (desired>journal_size/2)     ret_val = journal_size/2;
    if (desired>JOURNAL_TRANS_MAX)  ret_val = JOURNAL_TRANS_MAX;
    if (ret_val) {
        reiserfs_warning (stderr, "WARNING: Journal max trans length is wrong seting: %u, resetting to available possible %u\n",
                          desired, ret_val);
    } else {
        ret_val = desired;
    }
    return ret_val;
}
#endif

__u32 advise_journal_max_batch (unsigned long journal_trans_max)
{
    return journal_trans_max*JOURNAL_MAX_BATCH/JOURNAL_TRANS_MAX;
}


__u32 advise_journal_max_commit_age (void)
{
    return JOURNAL_MAX_COMMIT_AGE;
}


__u32 advise_journal_max_trans_age (void)
{
    return JOURNAL_MAX_TRANS_AGE;
}


int reiserfs_journal_params_check (reiserfs_filsys_t * fs) {
    struct reiserfs_journal_header * j_head;
    struct reiserfs_super_block * sb = fs->fs_ondisk_sb;
    
    j_head = (struct reiserfs_journal_header *)(fs->fs_jh_bh->b_data);
	
    /* Check the superblock's journal parameters. */
    if (!is_reiserfs_jr_magic_string (sb)) {    
	if (get_jp_journal_dev (sb_jp(sb)) != 0 || 
	    get_jp_journal_1st_block (sb_jp(sb)) != get_journal_start_must (fs) || 
	    get_jp_journal_size (sb_jp(sb)) != 
	    journal_default_size(fs->fs_super_bh->b_blocknr, fs->fs_blocksize))
	{
	    reiserfs_warning (stderr, 
		"\nreiserfs_open_journal: wrong journal parameters found in the "
		"super block. \nYou should run reiserfsck with --rebuild-sb to "
		"check your superblock consistency.\n\n");
		
	    return 1;
	}
    }
	
    if (memcmp(&j_head->jh_journal, sb_jp (sb), sizeof(struct journal_params))) {
	if (!is_reiserfs_jr_magic_string (sb)) {
	    reiserfs_warning (stderr, 
		"\nreiserfs_open_journal: journal parameters from the superblock "
		"does not match \nto the journal headers ones. It looks like that "
		"you created your fs with old\nreiserfsprogs. Journal header is "
		"fixed.\n\n", fs->fs_j_file_name);
		
	    memcpy(&j_head->jh_journal, sb_jp(sb), sizeof(struct journal_params));
	    mark_buffer_dirty(fs->fs_jh_bh);
	    bwrite(fs->fs_jh_bh);
	} else {
	    reiserfs_warning (stderr,
		"\nreiserfs_open_journal: journal parameters from the super block "
		"does not match \nto journal parameters from the journal. You should "
		"run  reiserfsck with --rebuild-sb to check your superblock consistency.\n\n");
		
	    return 1;	
	}
    }
    
    return 0;
}

/* read journal header and make sure that it matches with the filesystem
   opened */
int reiserfs_open_journal (reiserfs_filsys_t * fs, char * j_filename, int flags) {
    struct reiserfs_super_block * sb;
    __u64 count;
    
    sb = fs->fs_ondisk_sb;

    if (!j_filename) {
	/*
        if (is_reiserfs_jr_magic_string (sb)) {
            // create a special file to access journal
            return 1;
        } */
	
	j_filename = fs->fs_file_name;
    } else if (!is_reiserfs_jr_magic_string (sb)) {
        /* make sure that name specified is a correct name */
	if (strcmp (j_filename, fs->fs_file_name)) {
	    reiserfs_warning (stderr, "Filesystem with standard journal found, "
		"wrong name of specified journal device %s \n", j_filename);
	    return 2;
	}
    }

    fs->fs_journal_dev = open (j_filename, flags 
#if defined(O_LARGEFILE)
			       | O_LARGEFILE
#endif
			       );
    if (fs->fs_journal_dev == -1) 
        return -1;
    
    asprintf (&fs->fs_j_file_name, "%s", j_filename);
    
    if (get_jp_journal_size(sb_jp(sb)) < JOURNAL_MIN_SIZE) {
	reiserfs_warning (stderr, "Journal of (%lu) block size found on "
	    "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;
    }
    
    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);

    if (!fs->fs_jh_bh) {
	reiserfs_warning (stderr, "reiserfs_open_journal: bread failed "
			  "reading journal  header.\n");
	close(fs->fs_journal_dev);
	return -1;
    }

    return 0;
}

/* initialize super block's journal related fields and journal header fields. 
 * If len is 0 - make journal of default size */
int reiserfs_create_journal(
    reiserfs_filsys_t * fs, 
    char * j_device,		/* journal device name */
    unsigned long offset,	/* journal offset on the j_device */
    unsigned long len,		/* including journal header */
    int transaction_max_size,
    int force)
{
    struct stat st;
    struct buffer_head * bh;
    struct reiserfs_journal_header * jh;
    struct reiserfs_super_block * sb;
    unsigned long blocks;

    sb = fs->fs_ondisk_sb;
    
    if (!j_device || !strcmp (j_device, fs->fs_file_name)) {
	/* Journal is to be on the host device, check the amount space for the 
	 * journal on it. */
	len = len ? len : journal_default_size(fs->fs_super_bh->b_blocknr, 
	    fs->fs_blocksize) + 1;
		
	offset = offset ? offset : get_journal_start_must(fs);
	
	if (offset < get_journal_start_must(fs)) {
	    reiserfs_warning (stderr, "reiserfs_create_journal: offset is "
		"%lu, but it cannot be less then %llu on the device %s\n", 
		offset, get_journal_start_must(fs), j_device);
	    return 0;
	}
	
	if (!is_block_count_correct(offset, fs->fs_blocksize, 
	    get_sb_block_count(sb), len)) 
	{
	    /* host device does not contain enough blocks */
	    reiserfs_warning (stderr, "reiserfs_create_journal: cannot create "
		"a journal of %lu blocks with %lu offset on %u blocks\n",
		len, offset, get_sb_block_count(sb));
		return 0;
	}
	
	j_device = fs->fs_file_name;
	
	
	st.st_rdev = 0;
    } else {
	/* journal is to be on separate device */
	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) {
		reiserfs_warning (stderr, "reiserfs_create_journal: offset is "
		    "%lu, blocks on device %lu\n", offset, blocks);
		return 0;
	    }
	    /* XXX jdm: This can end up being huge and could result
	     * in an unmountable file system:
	     * len = blocks - offset; */
	    len = journal_default_size(fs->fs_super_bh->b_blocknr,
	                               fs->fs_blocksize) + 1;

	}

	if (!force && len > journal_default_size (fs->fs_super_bh->b_blocknr,
	    fs->fs_blocksize) + 1) 
	{
	    unsigned long journal_max = journal_max_size (fs->fs_super_bh->b_blocknr, fs->fs_blocksize);
	    fflush(stderr);
	    
	    reiserfs_warning (stdout, "\n*** You've specified a journal "
	                      "size larger than the default size of "
	                      "%lu\n*** blocks. This may slow down "
	                      "journal initialization and mounting "
	                      "of\n*** the file system.%s",
	                      journal_default_size(fs->fs_super_bh->b_blocknr, fs->fs_blocksize) + 1,
	                      len > journal_max ? " " : "\n");
	    if (len > journal_max)
		reiserfs_warning (stdout, "On 32-bit systems, and on "
		                  "64-bit systems with\n*** limited "
		                  "memory, this may also cause the file "
		                  "system to be unmountable.\n*** Please "
		                  "consider using a journal size "
		                  "<= %lu blocks.\n\nFile system creation "
				  "failed. You may override this behavior "
				  "with the -f option.\n", journal_max);
		    return 0;
	}

	if (len < blocks)
		reiserfs_warning (stdout, "\n\n*** Your journal device is %lu "
		                  "blocks, but your journal is only %lu "
				  "blocks.\n*** You may want to consider "
				  "resizing the journal device to avoid "
				  "wasting space.\n\n", blocks, len);

	if (blocks < offset + len) {
	    reiserfs_warning (stderr, "reiserfs_create_journal: no enough "
		"blocks on device %lu, needed %lu\n", blocks, offset + len);
	    return 0;
	}
	
	if (stat (j_device, &st) == -1) {
	    reiserfs_warning (stderr, "reiserfs_create_journal: stat %s failed"
		": %s\n", j_device, strerror(errno));
	    return 0;
	}
/*
	if (!S_ISBLK (st.st_mode)) {
		reiserfs_warning (stderr, "reiserfs_create_journal: "
		"%s is not a block device (%x)\n", j_device, st.st_rdev);
		return 0;
	}
*/
    }

    fs->fs_journal_dev = open (j_device, O_RDWR 
#if defined(O_LARGEFILE)
			       | O_LARGEFILE
#endif
			       );
    if (fs->fs_journal_dev == -1) {
	reiserfs_warning (stderr, "reiserfs_create_journal: could not open "
	    "%s: %s\n", j_device, strerror(errno));
	return 0;
    }

    asprintf (&fs->fs_j_file_name, "%s", j_device);

    if (len < JOURNAL_MIN_SIZE + 1) {
	reiserfs_warning (stderr, "WARNING: Journal size (%u) is less, than "
	    "minimal supported journal size (%u).\n", len, JOURNAL_MIN_SIZE + 1);
        return 0;
    }
    /* get journal header */
    bh = getblk (fs->fs_journal_dev, offset + len - 1, fs->fs_blocksize);
    if (!bh) {
	reiserfs_warning (stderr, "reiserfs_create_journal: getblk failed\n");
	return 0;
    }

    /* fill journal header */
    jh = (struct reiserfs_journal_header *)bh->b_data;
    set_jp_journal_1st_block(&jh->jh_journal, offset);
    set_jp_journal_dev(&jh->jh_journal, st.st_rdev);
    set_jp_journal_magic(&jh->jh_journal, get_random());

    set_jp_journal_size(&jh->jh_journal, len - 1);
    set_jp_journal_max_trans_len(&jh->jh_journal, advise_journal_max_trans_len(
	transaction_max_size, len - 1, fs->fs_blocksize, 1));
    set_jp_journal_max_batch(&jh->jh_journal, advise_journal_max_batch(
	get_jp_journal_max_trans_len(&jh->jh_journal)));
    set_jp_journal_max_commit_age(&jh->jh_journal, 
	advise_journal_max_commit_age());
    set_jp_journal_max_trans_age(&jh->jh_journal, 
	advise_journal_max_trans_age ());

    mark_buffer_uptodate (bh, 1);
    mark_buffer_dirty (bh);
    
    fs->fs_jh_bh = bh;
    
    /* make a copy of journal header in the super block */
    memcpy (sb_jp (sb), &jh->jh_journal, sizeof (struct journal_params));
    mark_buffer_dirty (fs->fs_super_bh);

    return 1;
}


/* brelse journal header, flush all dirty buffers, close device, open, read
   journal header */
void reiserfs_reopen_journal (reiserfs_filsys_t * fs, int flag)
{
    unsigned long jh_block;


    if (!reiserfs_journal_opened (fs))
	return;

    jh_block = fs->fs_jh_bh->b_blocknr;
    brelse (fs->fs_jh_bh);
    flush_buffers (fs->fs_journal_dev);
    invalidate_buffers (fs->fs_journal_dev);
    if (close (fs->fs_journal_dev))
	die ("reiserfs_reopen_journal: closed failed: %s", strerror(errno));

    fs->fs_journal_dev = open (fs->fs_j_file_name, flag 
#if defined(O_LARGEFILE)
			       | O_LARGEFILE
#endif
			       );
    if (fs->fs_journal_dev == -1)
	die ("reiserfs_reopen_journal: could not reopen journal device");

    fs->fs_jh_bh = bread (fs->fs_journal_dev, jh_block, fs->fs_blocksize);
    if (!fs->fs_jh_bh)
	die ("reiserfs_reopen_journal: reading journal header failed");
}


int reiserfs_journal_opened (reiserfs_filsys_t * fs)
{
    return fs->fs_jh_bh ? 1 : 0;
}


void reiserfs_flush_journal (reiserfs_filsys_t * fs)
{
    if (!reiserfs_journal_opened (fs))
		return;
    flush_buffers (fs->fs_journal_dev);
}


void reiserfs_free_journal (reiserfs_filsys_t * fs)
{
    if (!reiserfs_journal_opened (fs))
		return;
    brelse (fs->fs_jh_bh);
    fs->fs_jh_bh = 0;
    free (fs->fs_j_file_name);
    fs->fs_j_file_name = 0;
}


void reiserfs_close_journal (reiserfs_filsys_t * fs)
{
    reiserfs_flush_journal (fs);
    reiserfs_free_journal (fs);

}

/* update journal header */
static void update_journal_header (reiserfs_filsys_t * fs, 
				   struct buffer_head * bh_jh, 
				   reiserfs_trans_t *trans) 
{
    struct reiserfs_journal_header * j_head;
	
    j_head = (struct reiserfs_journal_header *)(bh_jh->b_data);

    /* update journal header */
    set_jh_last_flushed (j_head, trans->trans_id);
    set_jh_mount_id (j_head, trans->mount_id);
    set_jh_replay_start_offset (j_head, trans->next_trans_offset);
    mark_buffer_dirty (bh_jh);
    bwrite (bh_jh);
    fsync(fs->fs_journal_dev);
}

/* fixme: what should be done when not all transactions can be replayed in proper order? */
int replay_journal (reiserfs_filsys_t * fs)
{
    struct buffer_head * bh;
    struct reiserfs_journal_header * j_head;
    reiserfs_trans_t cur, newest, control;
    int replayed, ret;
    struct progbar progbar;
    int trans_count;

    if (!reiserfs_journal_opened (fs))
        reiserfs_panic ("replay_journal: journal is not opened");
    
    if (!is_opened_rw (fs))
        reiserfs_panic ("replay_journal: fs is not opened with write perms");


    reiserfs_warning (stderr, "Replaying journal: ");
    bh = fs->fs_jh_bh;
	
    j_head = (struct reiserfs_journal_header *)(bh->b_data);
    control.mount_id = get_jh_mount_id (j_head);
    control.trans_id = get_jh_last_flushed (j_head);
    control.desc_blocknr = get_jh_replay_start_offset (j_head);

    if (!get_boundary_transactions (fs, &cur, &newest)) {
	reiserfs_warning (stderr, "No transactions found\n");
	return 0;
    }

    trans_count = newest.trans_id - cur.trans_id;

    /*  Smth strange with journal header or journal. We cannot say for sure what was the last 
	replaied transaction, but relying on JH data is preferable. */

    replayed = 0;
    ret = TRANS_FOUND;
    
    progbar_init(&progbar, " trans", stderr);
    /* Looking to the first valid not replayed transaction. */
    while (1) {
	if (cur.mount_id == control.mount_id && 
	    cur.trans_id > control.trans_id)
	    break;

	if ((ret = next_transaction (fs, &cur, newest)) != TRANS_FOUND)
	    break;
    }
    
    while (ret == TRANS_FOUND) {
	/* If not the next transaction to be replayed, break out here. */
	if ((cur.mount_id != control.mount_id) || 
	    (cur.trans_id != control.trans_id + 1 && control.trans_id))
	    break;
	
	if (!transaction_check_content(fs, &cur)) {
	    progbar_clear(&progbar);
	    reiserfs_warning (stderr, "Trans broken: mountid %lu, transid %lu, desc %lu, "
		"len %lu, commit %lu, next trans offset %lu\n", cur.mount_id, cur.trans_id, 
		cur.desc_blocknr, cur.trans_len, cur.commit_blocknr, cur.next_trans_offset);
	    break;
	}

        reiserfs_warning (stderr, "Trans replayed: mountid %lu, transid %lu, desc %lu, "
            "len %lu, commit %lu, next trans offset %lu\n",
	    cur.mount_id, cur.trans_id, cur.desc_blocknr, cur.trans_len,
	    cur.commit_blocknr, cur.next_trans_offset);
	replay_one_transaction (fs, &cur);
	update_journal_header (fs, bh, &cur);
	control = cur;
        replayed ++;

	progbar_update(&progbar, "Replaying journal", replayed, trans_count,
	               replayed);

	ret = next_transaction (fs, &cur, newest);
    }
    progbar_clear(&progbar);

    reiserfs_warning (stderr, "\rReplaying journal: Done.\nReiserfs journal '%s' in blocks [%u..%u]: %d "
		      "transactions replayed\n", fs->fs_j_file_name, 
		      get_jp_journal_1st_block(sb_jp(fs->fs_ondisk_sb)),
		      get_jp_journal_1st_block(sb_jp(fs->fs_ondisk_sb)) + 
		      get_jp_journal_size(sb_jp(fs->fs_ondisk_sb)) + 1,
		      replayed);
	
    mark_buffer_dirty (fs->fs_super_bh);
    bwrite (fs->fs_super_bh);
	
    update_journal_header (fs, bh, &newest);

    return 0;
}