lgcosta/reiserfsprogs
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
dac518d099bbd0b3b4feb58351cc41d89683e40d
reiserfsprogs/libreiserfs/journal.c
T

1086 lines
32 KiB
C
Raw Blame History

/*
* Copyright 2002-2004 by Hans Reiser, licensing governed by
* reiserfsprogs/README
*/
#ifdef HAVE_CONFIG_H
# include <config.h>
#endif
#include "reiserfs/libreiserfs.h"
#include "misc/device.h"
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
/* check whether 'block' can be logged */
static int not_journalable (reiserfs_filsys_t * fs, unsigned long block)
{
reiserfs_blktype_t type;
type = reiserfs_fs_block(fs, block);
return (type == BT_INVAL || type == BT_JOURNAL);
}
/* compares description block with commit block. returns 0 if they differ, 1
if they match */
static int does_desc_match_commit (reiserfs_bh_t *d_bh,
reiserfs_bh_t *c_bh)
{
return (reiserfs_jc_get_trans (c_bh) == reiserfs_jd_get_trans (d_bh) &&
reiserfs_jc_get_len (c_bh) == reiserfs_jd_get_len (d_bh));
}
/* d_bh is descriptor, return number of block where commit block of this
transaction is to be */
static unsigned long commit_expected (reiserfs_filsys_t * fs,
reiserfs_bh_t * d_bh)
{
unsigned long offset;
reiserfs_journal_param_t * sb_jp;
sb_jp = reiserfs_sb_jp (fs->fs_ondisk_sb);
//desc = (struct reiserfs_journal_desc *)d_bh->b_data;
offset = d_bh->b_blocknr - reiserfs_jp_get_start (sb_jp);
return reiserfs_jp_get_start (sb_jp) +
((offset + reiserfs_jd_get_len (d_bh) + 1) % reiserfs_jp_get_size (sb_jp));
}
/* d_bh contains journal descriptor, returns number of block where descriptor
block of next transaction should be */
static unsigned long next_desc_expected (reiserfs_filsys_t * fs,
reiserfs_bh_t * d_bh)
{
unsigned long offset;
reiserfs_journal_param_t * sb_jp;
sb_jp = reiserfs_sb_jp (fs->fs_ondisk_sb);
//desc = (struct reiserfs_journal_desc *)d_bh->b_data;
offset = d_bh->b_blocknr - reiserfs_jp_get_start (sb_jp);
return reiserfs_jp_get_start (sb_jp) +
((offset + reiserfs_jd_get_len (d_bh) + 2) % reiserfs_jp_get_size (sb_jp));
}
/* common checks for validness of a transaction */
static int transaction_check_content (reiserfs_filsys_t * fs,
reiserfs_trans_t * trans)
{
reiserfs_bh_t *d_bh, *c_bh;
struct reiserfs_journal_desc * desc;
struct reiserfs_journal_commit * commit;
unsigned long block;
unsigned int trans_half, i;
d_bh = reiserfs_buffer_read (fs->fs_journal_dev, trans->desc_blocknr, fs->fs_blocksize);
if (!d_bh || reiserfs_node_type (d_bh) != NT_JDESC)
goto error_desc_brelse;
/* read expected commit block and compare with descriptor block */
c_bh = reiserfs_buffer_read (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 = reiserfs_jt_half (d_bh->b_size);
for (i = 0; i < reiserfs_jd_get_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;
}
reiserfs_buffer_close (d_bh);
reiserfs_buffer_close (c_bh);
return 1;
error_commit_brelse:
reiserfs_buffer_close (c_bh);
error_desc_brelse:
reiserfs_buffer_close(d_bh);
return 0;
}
/* common checks for validness of a transaction */
static int transaction_check_desc(reiserfs_filsys_t * fs,
reiserfs_bh_t * d_bh)
{
reiserfs_bh_t * c_bh;
int ret = 1;
if (!d_bh || reiserfs_node_type (d_bh) != NT_JDESC)
return 0;
/* read expected commit block and compare with descriptor block */
c_bh = reiserfs_buffer_read (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;
reiserfs_buffer_close (c_bh);
return ret;
}
/* read the journal and find the oldest and newest transactions, return number
of transactions found */
int reiserfs_journal_get_transactions (reiserfs_filsys_t * fs,
reiserfs_trans_t * oldest,
reiserfs_trans_t * newest)
{
reiserfs_sb_t * sb;
unsigned long j_cur;
unsigned long j_start;
unsigned long j_size;
reiserfs_bh_t * d_bh;
__u32 newest_trans_id, oldest_trans_id, trans_id;
int trans_nr;
sb = fs->fs_ondisk_sb;
j_start = reiserfs_jp_get_start (reiserfs_sb_jp (sb));
j_size = reiserfs_jp_get_size (reiserfs_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 = reiserfs_buffer_read (fs->fs_journal_dev, j_start + j_cur, fs->fs_blocksize);
if (!transaction_check_desc (fs, d_bh)) {
reiserfs_buffer_close (d_bh);
continue;
}
trans_nr ++;
trans_id = reiserfs_jd_get_trans (d_bh);
if (trans_id < oldest_trans_id) {
oldest_trans_id = trans_id;
oldest->mount_id = reiserfs_jd_get_mount (d_bh);
oldest->trans_id = reiserfs_jd_get_trans (d_bh);
oldest->desc_blocknr = d_bh->b_blocknr;
oldest->trans_len = reiserfs_jd_get_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 = reiserfs_jd_get_mount (d_bh);
newest->trans_id = reiserfs_jd_get_trans (d_bh);
newest->desc_blocknr = d_bh->b_blocknr;
newest->trans_len = reiserfs_jd_get_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 += reiserfs_jd_get_len (d_bh) + 1;
reiserfs_buffer_close (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 */
static int next_transaction (reiserfs_filsys_t * fs,
reiserfs_trans_t * trans,
reiserfs_trans_t break_trans)
{
reiserfs_bh_t * d_bh, * next_d_bh;
int found;
unsigned long j_start;
unsigned long j_offset;
unsigned long block;
j_start = reiserfs_jp_get_start (reiserfs_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 = reiserfs_buffer_read (fs->fs_journal_dev, trans->desc_blocknr, fs->fs_blocksize);
if (!transaction_check_desc (fs, d_bh))
misc_die ("next_transaction: valid transaction is expected");
block = next_desc_expected (fs, d_bh);
j_offset = block - j_start;
while (1) {
next_d_bh = reiserfs_buffer_read (fs->fs_journal_dev, block, fs->fs_blocksize);
if (transaction_check_desc (fs, next_d_bh))
break;
reiserfs_buffer_close (next_d_bh);
j_offset ++;
block = j_start +
(j_offset % reiserfs_jp_get_size (reiserfs_sb_jp (fs->fs_ondisk_sb)));
}
//next_desc = (struct reiserfs_journal_desc *)next_d_bh->b_data;
if (break_trans.trans_id >= reiserfs_jd_get_trans (next_d_bh)) {
/* found transaction is newer */
trans->mount_id = reiserfs_jd_get_mount (next_d_bh);
trans->trans_id = reiserfs_jd_get_trans (next_d_bh);
trans->desc_blocknr = next_d_bh->b_blocknr;
trans->trans_len = reiserfs_jd_get_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;
}
reiserfs_buffer_close (d_bh);
reiserfs_buffer_close (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)
{
reiserfs_bh_t * j_bh, * bh;
j_bh = reiserfs_buffer_read (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);
reiserfs_buffer_close (j_bh);
return;
}
bh = reiserfs_buffer_open (fs->fs_dev, in_place, fs->fs_blocksize);
memcpy (bh->b_data, j_bh->b_data, bh->b_size);
reiserfs_buffer_mkdirty (bh);
reiserfs_buffer_mkuptodate (bh, 1);
reiserfs_buffer_write (bh);
reiserfs_buffer_close (bh);
reiserfs_buffer_close (j_bh);
}
/* go through all blocks of transaction and call 'action' each of them */
void reiserfs_journal_foreach (reiserfs_filsys_t * fs,
reiserfs_trans_t * trans,
action_on_block_t action)
{
reiserfs_bh_t * 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 = reiserfs_buffer_read (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 = reiserfs_buffer_read (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);
reiserfs_buffer_close (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 = reiserfs_jp_get_start (reiserfs_sb_jp (fs->fs_ondisk_sb));
j_size = reiserfs_jp_get_size (reiserfs_sb_jp (fs->fs_ondisk_sb));
/* offset in the journal where the transaction starts */
j_offset = trans->desc_blocknr - j_start + 1;
trans_half = reiserfs_jt_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);
}
reiserfs_buffer_close (d_bh);
reiserfs_buffer_close (c_bh);
}
/* transaction is supposed to be valid */
static int replay_one_transaction (reiserfs_filsys_t * fs,
reiserfs_trans_t * trans)
{
reiserfs_journal_foreach (fs, trans, read_journal_write_in_place);
fsync(fs->fs_dev);
return 0;
}
void reiserfs_journal_by_transaction (reiserfs_filsys_t * fs,
action_on_trans_t action)
{
reiserfs_trans_t oldest, newest;
int ret = 0;
if (!reiserfs_journal_get_transactions (fs, &oldest, &newest))
return;
while (1) {
action (fs, &oldest);
if ((ret = next_transaction (fs, &oldest, newest)) == TRANS_NOT_FOUND)
break;
}
}
/* Get the size of the journal or reserved area. */
unsigned long reiserfs_journal_hostsize(reiserfs_sb_t * sb)
{
if (reiserfs_super_jr_magic (sb))
return reiserfs_sb_get_reserved (sb);
/* with standard journal */
return reiserfs_jp_get_size (reiserfs_sb_jp (sb)) + 1;
}
__u32 reiserfs_journal_tlen (__u32 desired, __u32 journal_size,
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 reiserfs_journal_batch (unsigned long journal_trans_max) {
return journal_trans_max*JOURNAL_MAX_BATCH/JOURNAL_TRANS_MAX;
}
__u32 reiserfs_journal_commit_age (void) {
return JOURNAL_MAX_COMMIT_AGE;
}
__u32 reiserfs_journal_trans_age (void) {
return JOURNAL_MAX_TRANS_AGE;
}
int reiserfs_journal_params_check (reiserfs_filsys_t * fs) {
struct reiserfs_journal_header * j_head;
reiserfs_sb_t * sb = fs->fs_ondisk_sb;
j_head = (struct reiserfs_journal_header *)(fs->fs_jh_bh->b_data);
/* Check the superblock's journal parameters. */
if (!reiserfs_super_jr_magic (sb)) {
if ((reiserfs_jp_get_dev (reiserfs_sb_jp(sb)) != 0) ||
(reiserfs_jp_get_start (reiserfs_sb_jp(sb)) !=
reiserfs_journal_start_must (fs)) ||
(reiserfs_jp_get_size (reiserfs_sb_jp(sb)) !=
reiserfs_journal_default(fs->fs_super_bh->b_blocknr, fs->fs_blocksize)))
{
reiserfs_warning (stderr,
"\nreiserfs_journal_open: 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, reiserfs_sb_jp (sb), sizeof(reiserfs_journal_param_t))) {
if (!reiserfs_super_jr_magic (sb)) {
reiserfs_warning (stderr, "\nreiserfs_journal_open: 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, reiserfs_sb_jp(sb),
sizeof(reiserfs_journal_param_t));
reiserfs_buffer_mkdirty(fs->fs_jh_bh);
reiserfs_buffer_write(fs->fs_jh_bh);
} else {
reiserfs_warning (stderr, "\nreiserfs_journal_open: 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_journal_open (reiserfs_filsys_t * fs, char * j_filename, int flags) {
reiserfs_sb_t * sb;
char buf[4096];
__u64 count;
dev_t rdev;
sb = fs->fs_ondisk_sb;
if (j_filename && j_filename[0] != '\0') {
if (!reiserfs_super_jr_magic (sb) &&
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;
}
} else {
if (!reiserfs_super_jr_magic (sb)) {
j_filename = fs->fs_file_name;
} else {
/* Not standard journal and no device is specified.
Find the device by rdev. */
strcpy(buf, "/dev");
rdev = reiserfs_sb_jp(sb)->jp_dev;
if ((misc_dir_walk(buf, misc_device_rdev_match, &rdev)) <= 0) {
reiserfs_warning (stderr, "Filesystem with non-standard "
"journal found, failed to find a block "
"device (%u:%u) in /dev.\nCreate such "
"a device in /dev or specify the journal "
"device with -j option.\n",
major(rdev), minor(rdev));
return 2;
}
j_filename = buf;
}
}
fs->fs_journal_dev = open (j_filename, flags
#if defined(O_LARGEFILE)
| O_LARGEFILE
#endif
);
if (fs->fs_journal_dev == -1)
return -1;
strncpy(fs->fs_j_file_name, j_filename, sizeof(fs->fs_j_file_name));
if (reiserfs_jp_get_size(reiserfs_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",
reiserfs_jp_get_size (reiserfs_sb_jp (sb)) + 1, j_filename,
JOURNAL_MIN_SIZE + 1);
close(fs->fs_journal_dev);
return 1;
}
if (!(count = misc_device_count_blocks (j_filename, fs->fs_blocksize))) {
close(fs->fs_journal_dev);
return -1;
}
if (reiserfs_jp_get_start (reiserfs_sb_jp (sb)) +
reiserfs_jp_get_size (reiserfs_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, reiserfs_jp_get_start(reiserfs_sb_jp (sb)),
reiserfs_jp_get_size(reiserfs_sb_jp (sb)) + 1, count);
close(fs->fs_journal_dev);
return 1;
}
/* read journal header */
fs->fs_jh_bh = reiserfs_buffer_read (fs->fs_journal_dev,
reiserfs_jp_get_start (reiserfs_sb_jp (sb)) +
reiserfs_jp_get_size (reiserfs_sb_jp (sb)),
fs->fs_blocksize);
if (!fs->fs_jh_bh) {
reiserfs_warning (stderr, "reiserfs_journal_open: reiserfs_buffer_read 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_journal_create(
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)
{
struct stat st;
reiserfs_bh_t * bh;
struct reiserfs_journal_header * jh;
reiserfs_sb_t * 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 : reiserfs_journal_default(fs->fs_super_bh->b_blocknr,
fs->fs_blocksize) + 1;
offset = offset ? offset : reiserfs_journal_start_must(fs);
if (offset < reiserfs_journal_start_must(fs)) {
reiserfs_warning (stderr, "reiserfs_journal_create: offset is "
"%lu, but it cannot be less then %llu on the device %s\n",
offset, reiserfs_journal_start_must(fs), j_device);
return 0;
}
if (!reiserfs_journal_fits(offset, fs->fs_blocksize,
reiserfs_sb_get_blocks(sb), len))
{
/* host device does not contain enough blocks */
reiserfs_warning (stderr, "reiserfs_journal_create: cannot create "
"a journal of %lu blocks with %lu offset on %d blocks\n",
len, offset, reiserfs_sb_get_blocks(sb));
return 0;
}
j_device = fs->fs_file_name;
st.st_rdev = 0;
} else {
/* journal is to be on separate device */
if (!(blocks = misc_device_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_journal_create: offset is "
"%lu, blocks on device %lu\n", offset, blocks);
return 0;
}
len = blocks - offset;
}
if (len > reiserfs_journal_default (fs->fs_super_bh->b_blocknr,
fs->fs_blocksize) + 1)
{
fflush(stderr);
reiserfs_warning (stdout, "NOTE: journal new size %lu is greater "
"than default size %lu:\nthis may slow down initializing and "
"mounting of the journal. Hope it is ok.\n\n", len,
reiserfs_journal_default(fs->fs_super_bh->b_blocknr,
fs->fs_blocksize) + 1);
}
if (blocks < offset + len) {
reiserfs_warning (stderr, "reiserfs_journal_create: no enough "
"blocks on device %lu, needed %lu\n", blocks, offset + len);
return 0;
}
if (stat (j_device, &st) == -1) {
reiserfs_warning (stderr, "reiserfs_journal_create: stat %s failed"
": %s\n", j_device, strerror(errno));
return 0;
}
/*
if (!S_ISBLK (st.st_mode)) {
reiserfs_warning (stderr, "reiserfs_journal_create: "
"%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_journal_create: could not open "
"%s: %s\n", j_device, strerror(errno));
return 0;
}
strncpy(fs->fs_j_file_name, j_device, sizeof(fs->fs_j_file_name));
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 = reiserfs_buffer_open (fs->fs_journal_dev, offset + len - 1, fs->fs_blocksize);
if (!bh) {
reiserfs_warning (stderr, "reiserfs_journal_create: reiserfs_buffer_open failed\n");
return 0;
}
/* fill journal header */
jh = (struct reiserfs_journal_header *)bh->b_data;
reiserfs_jp_set_start(&jh->jh_journal, offset);
reiserfs_jp_set_dev(&jh->jh_journal, st.st_rdev);
reiserfs_jp_set_magic(&jh->jh_journal, misc_random());
reiserfs_jp_set_size(&jh->jh_journal, len - 1);
reiserfs_jp_set_tlen(&jh->jh_journal, reiserfs_journal_tlen(
transaction_max_size, len - 1, fs->fs_blocksize, 1));
reiserfs_jp_set_max_batch(&jh->jh_journal, reiserfs_journal_batch(
reiserfs_jp_get_tlen(&jh->jh_journal)));
reiserfs_jp_set_commit_age(&jh->jh_journal,
reiserfs_journal_commit_age());
reiserfs_jp_set_trans_age(&jh->jh_journal,
reiserfs_journal_trans_age ());
reiserfs_buffer_mkuptodate (bh, 1);
reiserfs_buffer_mkdirty (bh);
fs->fs_jh_bh = bh;
/* make a copy of journal header in the super block */
memcpy (reiserfs_sb_jp (sb), &jh->jh_journal, sizeof (reiserfs_journal_param_t));
reiserfs_buffer_mkdirty (fs->fs_super_bh);
return 1;
}
/* reiserfs_buffer_close journal header, flush all dirty buffers, close device, open, read
journal header */
void reiserfs_journal_reopen (reiserfs_filsys_t * fs, int flag)
{
unsigned long jh_block;
if (!reiserfs_journal_opened (fs))
return;
jh_block = fs->fs_jh_bh->b_blocknr;
reiserfs_buffer_close (fs->fs_jh_bh);
reiserfs_buffer_flush_all (fs->fs_journal_dev);
reiserfs_buffer_invalidate_all(fs->fs_journal_dev);
if (close (fs->fs_journal_dev))
misc_die ("reiserfs_journal_reopen: 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)
misc_die ("reiserfs_journal_reopen: could not reopen journal device");
fs->fs_jh_bh = reiserfs_buffer_read (fs->fs_journal_dev, jh_block, fs->fs_blocksize);
if (!fs->fs_jh_bh)
misc_die ("reiserfs_journal_reopen: reading journal header failed");
}
int reiserfs_journal_opened (reiserfs_filsys_t * fs)
{
return fs->fs_jh_bh ? 1 : 0;
}
void reiserfs_journal_flush (reiserfs_filsys_t * fs)
{
if (!reiserfs_journal_opened (fs))
return;
reiserfs_buffer_flush_all(fs->fs_journal_dev);
}
void reiserfs_journal_free (reiserfs_filsys_t * fs)
{
if (!reiserfs_journal_opened (fs))
return;
reiserfs_buffer_close (fs->fs_jh_bh);
fs->fs_jh_bh = 0;
fs->fs_j_file_name[0] = '\0';
}
void reiserfs_journal_close (reiserfs_filsys_t * fs)
{
reiserfs_journal_flush (fs);
reiserfs_journal_free (fs);
}
/* update journal header */
static void update_journal_header (reiserfs_filsys_t * fs,
reiserfs_bh_t * 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 */
reiserfs_jh_set_flushed (j_head, trans->trans_id);
reiserfs_jh_set_mount (j_head, trans->mount_id);
reiserfs_jh_set_start (j_head, trans->next_trans_offset);
reiserfs_buffer_mkdirty (bh_jh);
reiserfs_buffer_write (bh_jh);
fsync(fs->fs_journal_dev);
}
/* FIXME: what should be done when not all transactions can be replayed in
proper order? */
int reiserfs_journal_replay (reiserfs_filsys_t * fs)
{
reiserfs_bh_t * bh;
struct reiserfs_journal_header * j_head;
reiserfs_trans_t cur, newest, control;
int replayed, ret;
if (!reiserfs_journal_opened (fs))
reiserfs_panic ("reiserfs_journal_replay: journal is not opened");
if (!reiserfs_fs_rw (fs)) {
reiserfs_panic ("reiserfs_journal_replay: fs is not opened with "
"write perms");
}
reiserfs_warning (stderr, "Replaying journal..\n");
bh = fs->fs_jh_bh;
j_head = (struct reiserfs_journal_header *)(bh->b_data);
control.mount_id = reiserfs_jh_get_mount (j_head);
control.trans_id = reiserfs_jh_get_flushed (j_head);
control.desc_blocknr = reiserfs_jh_get_start (j_head);
if (!reiserfs_journal_get_transactions (fs, &cur, &newest)) {
reiserfs_warning (stderr, "No transactions found\n");
return 0;
}
/* 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;
/* 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)) {
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 ++;
ret = next_transaction (fs, &cur, newest);
}
reiserfs_warning (stderr, "Reiserfs journal '%s' in blocks [%u..%u]: %d "
"transactions replayed\n", fs->fs_j_file_name,
reiserfs_jp_get_start(reiserfs_sb_jp(fs->fs_ondisk_sb)),
reiserfs_jp_get_start(reiserfs_sb_jp(fs->fs_ondisk_sb)) +
reiserfs_jp_get_size(reiserfs_sb_jp(fs->fs_ondisk_sb)) + 1,
replayed);
reiserfs_buffer_mkdirty (fs->fs_super_bh);
reiserfs_buffer_write (fs->fs_super_bh);
update_journal_header (fs, bh, &newest);
return 0;
}
int reiserfs_journal_desc_valid (reiserfs_bh_t *bh) {
struct reiserfs_journal_desc *desc;
desc = (struct reiserfs_journal_desc *)bh->b_data;
if (!memcmp(bh->b_data + bh->b_size - 12, JOURNAL_DESC_MAGIC, 8) &&
le32_to_cpu (desc->j2_len) > 0)
{
return 1;
}
return 0;
}
int reiserfs_journal_block (reiserfs_filsys_t * fs, unsigned long block) {
unsigned long start;
start = reiserfs_journal_start_must(fs);
if (!reiserfs_super_jr_magic (fs->fs_ondisk_sb)) {
/* standard journal */
if (block >= start &&
block <= start + reiserfs_jp_get_size (reiserfs_sb_jp (fs->fs_ondisk_sb)))
{
return 1;
}
return 0;
}
if (reiserfs_sb_get_reserved (fs->fs_ondisk_sb)) {
/* there is space reserved for the journal on the host device */
if (block >= start &&
block < start + reiserfs_sb_get_reserved (fs->fs_ondisk_sb))
{
return 1;
}
}
return 0;
}
// in reiserfs version 0 (undistributed bitmap)
// FIXME: what if number of bitmaps is 15?
static unsigned int reiserfs_journal_oldstart_must (reiserfs_filsys_t * fs) {
unsigned int bmap_nr;
bmap_nr = reiserfs_bmap_nr(reiserfs_sb_get_blocks(fs->fs_ondisk_sb),
fs->fs_blocksize);
return (REISERFS_OLD_DISK_OFFSET_IN_BYTES / fs->fs_blocksize) + 1 + bmap_nr;
}
static unsigned int reiserfs_journal_newstart_must (reiserfs_filsys_t * fs) {
return (REISERFS_DISK_OFFSET_IN_BYTES / fs->fs_blocksize) + 2;
}
unsigned int reiserfs_journal_start_must (reiserfs_filsys_t * fs) {
if (reiserfs_old_location(fs->fs_super_bh->b_blocknr, fs->fs_blocksize))
return reiserfs_journal_oldstart_must (fs);
return reiserfs_journal_newstart_must(fs);
}
void reiserfs_journal_print_params (FILE * fp, reiserfs_journal_param_t * jp)
{
reiserfs_warning (fp, "\tDevice [0x%x]\n", reiserfs_jp_get_dev (jp));
reiserfs_warning (fp, "\tMagic [0x%x]\n", reiserfs_jp_get_magic (jp));
reiserfs_warning (fp, "\tSize %u blocks (including 1 for journal header) (first block %u)\n",
reiserfs_jp_get_size (jp) + 1,
reiserfs_jp_get_start (jp));
reiserfs_warning (fp, "\tMax transaction length %u blocks\n", reiserfs_jp_get_tlen (jp));
reiserfs_warning (fp, "\tMax batch size %u blocks\n", reiserfs_jp_get_max_batch (jp));
reiserfs_warning (fp, "\tMax commit age %u\n", reiserfs_jp_get_commit_age (jp));
reiserfs_warning (fp, "\tMax transaction age %u\n", reiserfs_jp_get_trans_age (jp));
}
void reiserfs_journal_print_header (reiserfs_filsys_t * fs) {
struct reiserfs_journal_header * j_head;
j_head = (struct reiserfs_journal_header *)(fs->fs_jh_bh->b_data);
reiserfs_warning (stdout, "Journal header (block #%lu of %s):\n"
"\tj_last_flush_trans_id %ld\n"
"\tj_first_unflushed_offset %ld\n"
"\tj_mount_id %ld\n",
fs->fs_jh_bh->b_blocknr, fs->fs_j_file_name,
reiserfs_jh_get_flushed (j_head),
reiserfs_jh_get_start (j_head),
reiserfs_jh_get_mount (j_head));
reiserfs_journal_print_params (stdout, &j_head->jh_journal);
}
static void print_trans_element (reiserfs_filsys_t * fs,
reiserfs_trans_t * trans,
unsigned int index,
unsigned long in_journal,
unsigned long in_place)
{
if (index % 8 == 0)
reiserfs_warning (stdout, "#%d\t", index);
reiserfs_warning (stdout, "%lu->%lu%s ", in_journal, in_place,
reiserfs_bitmap_block (fs, in_place) ? "B" : "");
if ((index + 1) % 8 == 0 || index == trans->trans_len - 1)
reiserfs_warning (stdout, "\n");
}
static void print_one_transaction (reiserfs_filsys_t * fs,
reiserfs_trans_t * trans)
{
reiserfs_warning (stdout, "Mountid %u, transid %u, desc %lu, length %u, "
"commit %lu\n", trans->mount_id, trans->trans_id,
trans->desc_blocknr, trans->trans_len,
trans->commit_blocknr);
reiserfs_journal_foreach (fs, trans, print_trans_element);
}
/* print all valid transactions and found dec blocks */
void reiserfs_journal_print (reiserfs_filsys_t * fs)
{
if (!reiserfs_journal_opened (fs)) {
reiserfs_warning (stderr, "reiserfs_journal_print: journal is not opened\n");
return;
}
reiserfs_journal_print_header (fs);
reiserfs_journal_by_transaction (fs, print_one_transaction);
}
int reiserfs_print_jdesc (FILE * fp, reiserfs_bh_t * bh) {
if (memcmp(reiserfs_jd_magic (bh), JOURNAL_DESC_MAGIC, 8))
return 1;
reiserfs_warning (fp, "Desc block %lu (j_trans_id %ld, j_mount_id %ld, j_len %ld)\n",
bh->b_blocknr, reiserfs_jd_get_trans (bh),
reiserfs_jd_get_mount (bh), reiserfs_jd_get_len (bh));
return 0;
}
/* reiserfs needs at least: enough blocks for journal, 64 k at the beginning,
one block for super block, bitmap block and root block. Note that first
bitmap block must point to all of them */
int reiserfs_journal_fits(unsigned long journal_offset,
unsigned int block_size,
unsigned long block_count,
unsigned long journal_size)
{
unsigned long blocks;
/* RESERVED, MD RAID SBs, super block, bitmap, root, journal size with journal header */
blocks = journal_offset + journal_size;
/* we have a limit: skipped area, super block, journal and root block
all have to be addressed by one first bitmap */
if (blocks > block_size * 8)
return 0;
if (blocks > block_count)
return 0;
return 1;
}
Reference in new issue View Git Blame Copy Permalink